Enqueue mDns requests if send on socket in progress.

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>
@@ skipping 34 matching lines @@
     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(MDnsSocketFactory* socket_factory);
-  bool Send(IOBuffer* buffer, unsigned size);
+  void Send(const scoped_refptr<IOBuffer>& buffer, unsigned size);
 
  private:
   class SocketHandler {
    public:
     SocketHandler(scoped_ptr<DatagramServerSocket> socket,
                   MDnsConnection* connection);
     ~SocketHandler();
 
     int Start();
-    int Send(IOBuffer* buffer, unsigned size);
+    void Send(const scoped_refptr<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_;
     DnsResponse response_;
     IPEndPoint multicast_addr_;
+    bool send_in_progress_;
+    std::queue<std::pair<scoped_refptr<IOBuffer>, unsigned> > send_queue_;
 
     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);
+  void PostOnError(SocketHandler* loop, int rv);
+  void OnError(int rv);
 
   // Only socket handlers which successfully bound and started are kept.
   ScopedVector<SocketHandler> socket_handlers_;
 
   Delegate* delegate_;
 
+  base::WeakPtrFactory<MDnsConnection> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(MDnsConnection);
 };
 
 class MDnsListenerImpl;
 
 class NET_EXPORT_PRIVATE MDnsClientImpl : public MDnsClient {
  public:
   // 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
@@ skipping 191 matching lines @@
   MDnsClientImpl* client_;
 
   bool started_;
   int flags_;
 
   DISALLOW_COPY_AND_ASSIGN(MDnsTransactionImpl);
 };
 
 }  // namespace net
 #endif  // NET_DNS_MDNS_CLIENT_IMPL_H_