Enqueue mDns requests if send on socket in progress.

net/dns/mdns_client_impl.cc

 // 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.
 
 #include "net/dns/mdns_client_impl.h"
 
+#include <queue>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/rand_callback.h"
 #include "net/dns/dns_protocol.h"
@@ skipping 30 matching lines @@
     if (socket)
       sockets->push_back(socket.release());
   }
 }
 
 MDnsConnection::SocketHandler::SocketHandler(
     scoped_ptr<DatagramServerSocket> socket,
     MDnsConnection* connection)
     : socket_(socket.Pass()),
       connection_(connection),
-      response_(dns_protocol::kMaxMulticastSize) {
+      response_(dns_protocol::kMaxMulticastSize),
+      send_in_progress_(false) {
 }
 
 MDnsConnection::SocketHandler::~SocketHandler() {
 }
 
 int MDnsConnection::SocketHandler::Start() {
   IPEndPoint end_point;
   int rv = socket_->GetLocalAddress(&end_point);
   if (rv != OK)
     return rv;
@@ skipping 20 matching lines @@
     return rv;
 
   return OK;
 }
 
 void MDnsConnection::SocketHandler::OnDatagramReceived(int rv) {
   if (rv >= OK)
     rv = DoLoop(rv);
 
   if (rv != OK)
-    connection_->OnError(this, rv);
+    connection_->PostOnError(this, rv);
 }
 
-int MDnsConnection::SocketHandler::Send(IOBuffer* buffer, unsigned size) {
-  return socket_->SendTo(buffer, size, multicast_addr_,
-                         base::Bind(&MDnsConnection::SocketHandler::SendDone,
-                                    base::Unretained(this) ));
+void MDnsConnection::SocketHandler::Send(const scoped_refptr<IOBuffer>& buffer,
+                                         unsigned size) {
+  if (send_in_progress_) {
+    send_queue_.push(std::make_pair(buffer, size));
+    return;
+  }
+  int rv = socket_->SendTo(buffer.get(),
+                           size,
+                           multicast_addr_,
+                           base::Bind(&MDnsConnection::SocketHandler::SendDone,
+                                      base::Unretained(this)));
+  if (rv == ERR_IO_PENDING) {
+    send_in_progress_ = true;
+  } else if (rv < OK) {
+    connection_->PostOnError(this, rv);
+  }
 }
 
 void MDnsConnection::SocketHandler::SendDone(int rv) {
-  // TODO(noamsml): Retry logic.
+  DCHECK(send_in_progress_);
+  send_in_progress_ = false;
+  if (rv != OK)
+    connection_->PostOnError(this, rv);
+  while (!send_in_progress_ && !send_queue_.empty()) {
+    std::pair<scoped_refptr<IOBuffer>, unsigned> buffer = send_queue_.front();
+    send_queue_.pop();
+    Send(buffer.first, buffer.second);
+  }
 }
 
-MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
-      delegate_(delegate) {
+MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate)
+    : delegate_(delegate), weak_ptr_factory_(this) {
 }
 
 MDnsConnection::~MDnsConnection() {
 }
 
 bool MDnsConnection::Init(MDnsSocketFactory* socket_factory) {
   ScopedVector<DatagramServerSocket> sockets;
   socket_factory->CreateSockets(&sockets);
 
   for (size_t i = 0; i < sockets.size(); ++i) {
@@ skipping 11 matching lines @@
       socket_handlers_.erase(socket_handlers_.begin() + i);
       VLOG(1) << "Start failed, socket=" << i << ", error=" << rv;
     } else {
       ++i;
     }
   }
   VLOG(1) << "Sockets ready:" << socket_handlers_.size();
   return !socket_handlers_.empty();
 }
 
-bool MDnsConnection::Send(IOBuffer* buffer, unsigned size) {
-  bool success = false;
-  for (size_t i = 0; i < socket_handlers_.size(); ++i) {
-    int rv = socket_handlers_[i]->Send(buffer, size);
-    if (rv >= OK || rv == ERR_IO_PENDING) {
-      success = true;
-    } else {
-      VLOG(1) << "Send failed, socket=" << i << ", error=" << rv;
-    }
-  }
-  return success;
+void MDnsConnection::Send(const scoped_refptr<IOBuffer>& buffer,
+                          unsigned size) {
+  for (size_t i = 0; i < socket_handlers_.size(); ++i)
+    socket_handlers_[i]->Send(buffer, size);
 }
 
-void MDnsConnection::OnError(SocketHandler* loop,
-                             int error) {
+void MDnsConnection::PostOnError(SocketHandler* loop, int rv) {
+  VLOG(1) << "Socket error. id="
+          << std::find(socket_handlers_.begin(), socket_handlers_.end(), loop) -
+                 socket_handlers_.begin() << ", error=" << rv;
+  // Post to allow deletion of this object by delegate.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MDnsConnection::OnError, weak_ptr_factory_.GetWeakPtr(), rv));
+}
+
+void MDnsConnection::OnError(int rv) {
   // TODO(noamsml): Specific handling of intermittent errors that can be handled
   // in the connection.
-  delegate_->OnConnectionError(error);
+  delegate_->OnConnectionError(rv);
 }
 
 void MDnsConnection::OnDatagramReceived(
     DnsResponse* response,
     const IPEndPoint& recv_addr,
     int bytes_read) {
   // TODO(noamsml): More sophisticated error handling.
   DCHECK_GT(bytes_read, 0);
   delegate_->HandlePacket(response, bytes_read);
 }
@@ skipping 11 matching lines @@
 }
 
 bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, std::string name) {
   std::string name_dns;
   if (!DNSDomainFromDot(name, &name_dns))
     return false;
 
   DnsQuery query(0, name_dns, rrtype);
   query.set_flags(0);  // Remove the RD flag from the query. It is unneeded.
 
-  return connection_->Send(query.io_buffer(), query.io_buffer()->size());
+  connection_->Send(query.io_buffer(), query.io_buffer()->size());
+  return true;
 }
 
 void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
                                         int bytes_read) {
   unsigned offset;
   // Note: We store cache keys rather than record pointers to avoid
   // erroneous behavior in case a packet contains multiple exclusive
   // records with the same type and name.
   std::map<MDnsCache::Key, MDnsCache::UpdateType> update_keys;
 
@@ skipping 497 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net