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 {
 
+class MDnsSocketFactoryImpl : public MDnsSocketFactory {
+ public:
+  MDnsSocketFactoryImpl() {};
+  virtual ~MDnsSocketFactoryImpl() {};
+
+  virtual void CreateSockets(
+      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MDnsSocketFactoryImpl);
+};
+
 // 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 SocketFactory {
-   public:
-    virtual ~SocketFactory() {}
-
-    virtual scoped_ptr<DatagramServerSocket> CreateSocket() = 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 Init(MDnsSocketFactory* 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<DatagramServerSocket> 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_;
-
     MDnsConnection* connection_;
     IPEndPoint recv_addr_;
-    scoped_ptr<DnsResponse> response_;
+    DnsResponse response_;
     IPEndPoint multicast_addr_;
+
+    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 11 matching lines @@
   // The core object exists while the MDnsClient is listening, and is deleted
   // whenever the number of listeners reaches zero. The deletion happens
   // asychronously, so destroying the last listener does not immediately
   // invalidate the core.
   class Core : public base::SupportsWeakPtr<Core>, MDnsConnection::Delegate {
    public:
     explicit Core(MDnsClientImpl* client);
     virtual ~Core();
 
     // Initialize the core. Returns true on success.
-    bool Init(MDnsConnection::SocketFactory* socket_factory);
+    bool Init(MDnsSocketFactory* socket_factory);
 
     // Send a query with a specific rrtype and name. Returns true on success.
     bool SendQuery(uint16 rrtype, std::string name);
 
     // Add/remove a listener to the list of listeners.
     void AddListener(MDnsListenerImpl* listener);
     void RemoveListener(MDnsListenerImpl* listener);
 
     // Query the cache for records of a specific type and name.
     void QueryCache(uint16 rrtype, const std::string& name,
@@ skipping 34 matching lines @@
     MDnsCache cache_;
 
     base::CancelableCallback<void()> cleanup_callback_;
     base::Time scheduled_cleanup_;
 
     scoped_ptr<MDnsConnection> connection_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
-  explicit MDnsClientImpl(
-      scoped_ptr<MDnsConnection::SocketFactory> socket_factory_);
+  MDnsClientImpl();
   virtual ~MDnsClientImpl();
 
   // MDnsClient implementation:
   virtual scoped_ptr<MDnsListener> CreateListener(
       uint16 rrtype,
       const std::string& name,
       MDnsListener::Delegate* delegate) OVERRIDE;
 
   virtual scoped_ptr<MDnsTransaction> CreateTransaction(
       uint16 rrtype,
       const std::string& name,
       int flags,
       const MDnsTransaction::ResultCallback& callback) OVERRIDE;
 
-  virtual bool StartListening() OVERRIDE;
+  virtual bool StartListening(MDnsSocketFactory* socket_factory) OVERRIDE;
   virtual void StopListening() OVERRIDE;
   virtual bool IsListening() const OVERRIDE;
 
   Core* core() { return core_.get(); }
 
  private:
   scoped_ptr<Core> core_;
 
-  scoped_ptr<MDnsConnection::SocketFactory> socket_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(MDnsClientImpl);
 };
 
 class MDnsListenerImpl : public MDnsListener,
                          public base::SupportsWeakPtr<MDnsListenerImpl> {
  public:
   MDnsListenerImpl(uint16 rrtype,
                    const std::string& name,
                    MDnsListener::Delegate* delegate,
                    MDnsClientImpl* client);
@@ skipping 84 matching lines @@
   MDnsClientImpl* client_;
 
   bool started_;
   int flags_;
 
   DISALLOW_COPY_AND_ASSIGN(MDnsTransactionImpl);
 };
 
 }  // namespace net
 #endif  // NET_DNS_MDNS_CLIENT_IMPL_H_