Refactored to make MDnsSocketFactory return array of sockets.

net/dns/mdns_client_impl.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_DNS_MDNS_CLIENT_IMPL_H_
 #define NET_DNS_MDNS_CLIENT_IMPL_H_
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/dns/mdns_cache.h"
 #include "net/dns/mdns_client.h"
 #include "net/udp/datagram_server_socket.h"
 #include "net/udp/udp_server_socket.h"
 #include "net/udp/udp_socket.h"
 
 namespace net {
 
 // A connection to the network for multicast DNS clients. It reads data into
 // DnsResponse objects and alerts the delegate that a packet has been received.
 class NET_EXPORT_PRIVATE MDnsConnection {
  public:
+  class Socket {

[szym, 2013/11/27 00:28:09]

When compared to the more direct route of using DatagramServerSocket, wrapping
UDPServerSocket in a SocketImpl adds one virtual dispatch. 

What's the benefit of going this way?

[Vitaly Buka (NO REVIEWS), 2013/11/27 00:45:45]

1. Cleaner tests because no need to mock unnecessary functionality.
2. Maybe we will listen in browser, and handle in sandbox, so it will be easy to
have IPC proxy for this one then for entire DatagramServerSocket

3. And most important: To setup MDns with array of sockets, we need to keep also
IPEndPoint for each socket. So I need to have some wrapper anyway or have
CreateSockets(vector<pair<Socket, IPEndPoint>* sockets)
So if we go with wrapper, it should be cleaner this way.

On 2013/11/27 00:28:09, szym wrote:

[szym, 2013/11/27 02:25:28]

True, but less _test_ code is not a reason to slow _down_ production code.
Aren't the Sockets already pre-bound by CreateSockets? If CreateSockets returned
pre-bound DatagramServerSockets, then there's no need to return IPEndPoint.

+   public:
+    virtual ~Socket() {};
+
+    virtual int RecvFrom(IOBuffer* buf,
+                         int buf_len,
+                         IPEndPoint* address,
+                         const CompletionCallback& callback) = 0;
+    virtual int SendTo(IOBuffer* buf,

[szym, 2013/11/27 07:37:44]

Does not take an address, so this should be |Send| not |SendTo|.

[Vitaly Buka (NO REVIEWS), 2013/11/27 08:45:37]

This one does not, that was a point, make implementation to care about address.

+                       int buf_len,
+                       const CompletionCallback& callback) = 0;
+  };
+
   class SocketFactory {
    public:
     virtual ~SocketFactory() {}
-
-    virtual scoped_ptr<DatagramServerSocket> CreateSocket() = 0;
+    virtual void CreateSockets(ScopedVector<Socket>* sockets) = 0;
 
     static scoped_ptr<SocketFactory> CreateDefault();
   };
 
   class Delegate {
    public:
     // Handle an mDNS packet buffered in |response| with a size of |bytes_read|.
     virtual void HandlePacket(DnsResponse* response, int bytes_read) = 0;
     virtual void OnConnectionError(int error) = 0;
     virtual ~Delegate() {}
   };
 
   explicit MDnsConnection(MDnsConnection::Delegate* delegate);
-
   virtual ~MDnsConnection();
 
   // Both methods return true if at least one of the socket handlers succeeded.
   bool Init(MDnsConnection::SocketFactory* socket_factory);
   bool Send(IOBuffer* buffer, unsigned size);
 
  private:
   class SocketHandler {
    public:
-    SocketHandler(MDnsConnection* connection,
-                  const IPEndPoint& multicast_addr,
-                  SocketFactory* socket_factory);
+    SocketHandler(scoped_ptr<Socket> socket, MDnsConnection* connection);
     ~SocketHandler();
-    int Bind();
+
     int Start();
-
     int Send(IOBuffer* buffer, unsigned size);
 
    private:
     int DoLoop(int rv);
     void OnDatagramReceived(int rv);
 
     // Callback for when sending a query has finished.
     void SendDone(int rv);
 
-    scoped_ptr<DatagramServerSocket> socket_;
-
+    scoped_ptr<Socket> socket_;
     MDnsConnection* connection_;
     IPEndPoint recv_addr_;
-    scoped_ptr<DnsResponse> response_;
-    IPEndPoint multicast_addr_;
+    DnsResponse response_;
+
+    DISALLOW_COPY_AND_ASSIGN(SocketHandler);
   };
 
   // Callback for handling a datagram being received on either ipv4 or ipv6.
   void OnDatagramReceived(DnsResponse* response,
                           const IPEndPoint& recv_addr,
                           int bytes_read);
 
   void OnError(SocketHandler* loop, int error);
 
   // Only socket handlers which successfully bound and started are kept.
@@ skipping 197 matching lines @@
   MDnsClientImpl* client_;
 
   bool started_;
   int flags_;
 
   DISALLOW_COPY_AND_ASSIGN(MDnsTransactionImpl);
 };
 
 }  // namespace net
 #endif  // NET_DNS_MDNS_CLIENT_IMPL_H_