1 files changed, 30 insertions, 46 deletions

diff --git a/chromium/net/dns/mock_mdns_socket_factory.cc b/chromium/net/dns/mock_mdns_socket_factory.cc
index bbdee07eb80..4946efe2666 100644
--- a/chromium/net/dns/mock_mdns_socket_factory.cc
+++ b/chromium/net/dns/mock_mdns_socket_factory.cc
@@ -13,8 +13,6 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "net/dns/public/util.h"
-#include "net/socket/socket_tag.h"
-#include "net/traffic_annotation/network_traffic_annotation.h"
 
 using testing::_;
 using testing::Invoke;
@@ -33,14 +31,15 @@ int MockMDnsDatagramServerSocket::SendTo(IOBuffer* buf,
                                          const IPEndPoint& address,
                                          CompletionOnceCallback callback) {
   return SendToInternal(std::string(buf->data(), buf_len), address.ToString(),
-                        &callback);
+                        base::AdaptCallbackForRepeating(std::move(callback)));
 }
 
 int MockMDnsDatagramServerSocket::RecvFrom(IOBuffer* buffer,
                                            int size,
                                            IPEndPoint* address,
                                            CompletionOnceCallback callback) {
-  return RecvFromInternal(buffer, size, address, &callback);
+  return RecvFromInternal(buffer, size, address,
+                          base::AdaptCallbackForRepeating(std::move(callback)));
 }
 
 int MockMDnsDatagramServerSocket::GetLocalAddress(IPEndPoint* address) const {
@@ -57,7 +56,7 @@ int MockMDnsDatagramServerSocket::HandleRecvNow(
     IOBuffer* buffer,
     int size,
     IPEndPoint* address,
-    CompletionOnceCallback* callback) {
+    CompletionRepeatingCallback callback) {
   int size_returned =
       std::min(response_packet_.size(), static_cast<size_t>(size));
   memcpy(buffer->data(), response_packet_.data(), size_returned);
@@ -68,53 +67,38 @@ int MockMDnsDatagramServerSocket::HandleRecvLater(
     IOBuffer* buffer,
     int size,
     IPEndPoint* address,
-    CompletionOnceCallback* callback) {
+    CompletionRepeatingCallback callback) {
   int rv = HandleRecvNow(buffer, size, address, callback);
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(std::move(*callback), rv));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                base::BindOnce(callback, rv));
   return ERR_IO_PENDING;
 }
 
-MockMDnsDatagramClientSocket::MockMDnsDatagramClientSocket() = default;
-
-MockMDnsDatagramClientSocket::~MockMDnsDatagramClientSocket() = default;
-
-int MockMDnsDatagramClientSocket::Write(
-    IOBuffer* buf,
-    int buf_len,
-    CompletionOnceCallback callback,
-    const NetworkTrafficAnnotationTag& traffic_annotation) {
-  return WriteInternal(std::string(buf->data(), buf_len), &callback,
-                       traffic_annotation);
-}
-
 MockMDnsSocketFactory::MockMDnsSocketFactory() = default;
 
 MockMDnsSocketFactory::~MockMDnsSocketFactory() = default;
 
-void MockMDnsSocketFactory::CreateSocketPairs(
-    std::vector<MDnsSendRecvSocketPair>* socket_pairs) {
-  CreateSocketPair(ADDRESS_FAMILY_IPV4, socket_pairs);
-  CreateSocketPair(ADDRESS_FAMILY_IPV6, socket_pairs);
+void MockMDnsSocketFactory::CreateSockets(
+    std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
+  CreateSocket(ADDRESS_FAMILY_IPV4, sockets);
+  CreateSocket(ADDRESS_FAMILY_IPV6, sockets);
 }
 
-void MockMDnsSocketFactory::CreateSocketPair(
+void MockMDnsSocketFactory::CreateSocket(
     AddressFamily address_family,
-    std::vector<MDnsSendRecvSocketPair>* socket_pairs) {
-  auto new_send_socket =
-      std::make_unique<testing::NiceMock<MockMDnsDatagramClientSocket>>();
-  auto new_recv_socket =
-      std::make_unique<testing::NiceMock<MockMDnsDatagramServerSocket>>(
-          address_family);
+    std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
+  std::unique_ptr<testing::NiceMock<MockMDnsDatagramServerSocket>> new_socket(
+      new testing::NiceMock<MockMDnsDatagramServerSocket>(address_family));
 
-  ON_CALL(*new_send_socket, WriteInternal(_, _, _))
-      .WillByDefault(Invoke(this, &MockMDnsSocketFactory::WriteInternal));
+  ON_CALL(*new_socket, SendToInternal(_, _, _))
+      .WillByDefault(Invoke(
+          this,
+          &MockMDnsSocketFactory::SendToInternal));
 
-  ON_CALL(*new_recv_socket, RecvFromInternal(_, _, _, _))
+  ON_CALL(*new_socket, RecvFromInternal(_, _, _, _))
       .WillByDefault(Invoke(this, &MockMDnsSocketFactory::RecvFromInternal));
 
-  socket_pairs->push_back(
-      std::make_pair(std::move(new_send_socket), std::move(new_recv_socket)));
+  sockets->push_back(std::move(new_socket));
 }
 
 void MockMDnsSocketFactory::SimulateReceive(const uint8_t* packet, int size) {
@@ -126,20 +110,20 @@ void MockMDnsSocketFactory::SimulateReceive(const uint8_t* packet, int size) {
   base::ResetAndReturn(&recv_callback_).Run(size);
 }
 
-int MockMDnsSocketFactory::RecvFromInternal(IOBuffer* buffer,
-                                            int size,
-                                            IPEndPoint* address,
-                                            CompletionOnceCallback* callback) {
+int MockMDnsSocketFactory::RecvFromInternal(
+    IOBuffer* buffer,
+    int size,
+    IPEndPoint* address,
+    CompletionRepeatingCallback callback) {
   recv_buffer_ = buffer;
   recv_buffer_size_ = size;
-  recv_callback_ = std::move(*callback);
+  recv_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
-int MockMDnsSocketFactory::WriteInternal(
-    const std::string& packet,
-    CompletionOnceCallback* callback,
-    const NetworkTrafficAnnotationTag& traffic_annotation) {
+int MockMDnsSocketFactory::SendToInternal(const std::string& packet,
+                                          const std::string& address,
+                                          CompletionOnceCallback callback) {
   OnSendTo(packet);
   return packet.size();
 }