Add IPC for DNS host address resolution.

content/browser/renderer_host/p2p/socket_dispatcher_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/p2p/socket_dispatcher_host.h"
 
+#include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
+#include "content/browser/resource_context.h"
 #include "content/common/p2p_messages.h"
+#include "net/base/address_list.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_log.h"
+#include "net/base/single_request_host_resolver.h"
+#include "net/base/sys_addrinfo.h"
 
-P2PSocketDispatcherHost::P2PSocketDispatcherHost()
-    : monitoring_networks_(false) {
+class P2PSocketDispatcherHost::DnsRequest {
+ public:
+  typedef base::Callback<void(const net::IPAddressNumber&)> DoneCallback;
+
+  DnsRequest(int32 routing_id, int32 request_id,
+             net::HostResolver* host_resolver)
+      : routing_id_(routing_id),
+        request_id_(request_id),
+        resolver_(host_resolver),
+        ALLOW_THIS_IN_INITIALIZER_LIST(completion_callback_(
+            this, &P2PSocketDispatcherHost::DnsRequest::OnDone)) {
+  }
+
+  void Resolve(const std::string& host_name,
+               const DoneCallback& done_callback) {

[awong, 2011/08/09 00:25:56]

DCHECK here that done_callback is initialized?

[Sergey Ulanov, 2011/08/09 00:41:35]

Done.

+    host_name_ = host_name;
+    done_callback_ = done_callback;
+
+    // Return an error if it's an empty string.
+    if (host_name_.empty()) {
+      done_callback_.Run(net::IPAddressNumber());
+      return;
+    }
+
+    // Add period at the end to make sure that we only resolve
+    // fully-qualified names.
+    if (host_name_.at(host_name_.size() - 1) != '.')
+      host_name_ = host_name_ + '.';
+
+    net::HostResolver::RequestInfo info(net::HostPortPair(host_name_, 0));
+    resolver_.Resolve(info, &addresses_, &completion_callback_,
+                      net::BoundNetLog());
+  }
+
+  int32 routing_id() { return routing_id_; }
+  int32 request_id() { return request_id_; }
+
+ private:
+  void OnDone(int result) {
+    if (result != net::OK) {
+      LOG(ERROR) << "Failed to resolve address for " << host_name_
+                 << ", errorcode: " << result;
+      done_callback_.Run(net::IPAddressNumber());

[awong, 2011/08/09 00:25:56]

I'd prefer a return here, and then move the whole else clouse back up a level.

Seems to fit better with the early exist style of error handling we usually use.

[Sergey Ulanov, 2011/08/09 00:41:35]

Done.

+    } else {
+      if (addresses_.head() == NULL) {
+        LOG(ERROR) << "Received 0 addresses when trying to resolve address for "
+                   << host_name_;
+        done_callback_.Run(net::IPAddressNumber());
+        return;
+      }
+
+      net::IPEndPoint end_point;
+      if (!end_point.FromSockAddr(addresses_.head()->ai_addr,
+                                  addresses_.head()->ai_addrlen)) {
+        LOG(ERROR) << "Received invalid address for " << host_name_;
+        done_callback_.Run(net::IPAddressNumber());
+        return;
+      }
+
+      done_callback_.Run(end_point.address());
+    }
+  }
+
+  int32 routing_id_;
+  int32 request_id_;
+  net::AddressList addresses_;
+
+  std::string host_name_;
+  net::SingleRequestHostResolver resolver_;
+
+  DoneCallback done_callback_;
+
+  net::CompletionCallbackImpl<DnsRequest> completion_callback_;
+};
+
+P2PSocketDispatcherHost::P2PSocketDispatcherHost(
+    const content::ResourceContext* resource_context)
+    : resource_context_(resource_context),
+      monitoring_networks_(false) {
 }
 
 P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
   DCHECK(sockets_.empty());

[Wez, 2011/08/08 21:47:18]

Check |dns_requests_| here, or clean it up?

[Sergey Ulanov, 2011/08/09 00:41:35]

Done.

 
   if (monitoring_networks_)
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void P2PSocketDispatcherHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
 
   // Since the IPC channel is gone, close pending connections.
   STLDeleteContainerPairSecondPointers(sockets_.begin(), sockets_.end());
   sockets_.clear();
+
+  STLDeleteContainerPointers(dns_requests_.begin(), dns_requests_.end());
+  dns_requests_.clear();
 }
 
 void P2PSocketDispatcherHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool P2PSocketDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                 bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(P2PSocketDispatcherHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(P2PHostMsg_StartNetworkNotifications,
                         OnStartNetworkNotifications)
     IPC_MESSAGE_HANDLER(P2PHostMsg_StopNetworkNotifications,
                         OnStopNetworkNotifications)
+    IPC_MESSAGE_HANDLER(P2PHostMsg_GetHostAddress, OnGetHostAddress)
     IPC_MESSAGE_HANDLER(P2PHostMsg_CreateSocket, OnCreateSocket)
     IPC_MESSAGE_HANDLER(P2PHostMsg_AcceptIncomingTcpConnection,
                         OnAcceptIncomingTcpConnection)
     IPC_MESSAGE_HANDLER(P2PHostMsg_Send, OnSend)
     IPC_MESSAGE_HANDLER(P2PHostMsg_DestroySocket, OnDestroySocket)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
@@ skipping 42 matching lines @@
 }
 
 void P2PSocketDispatcherHost::SendNetworkList(
     const net::NetworkInterfaceList& list) {
   for (std::set<int>::iterator it = notifications_routing_ids_.begin();
        it != notifications_routing_ids_.end(); ++it) {
     Send(new P2PMsg_NetworkListChanged(*it, list));
   }
 }
 
+void P2PSocketDispatcherHost::OnGetHostAddress(const IPC::Message& msg,
+                                               const std::string& host_name,
+                                               int32 request_id) {
+  DnsRequest* request = new DnsRequest(
+      msg.routing_id(), request_id, resource_context_->host_resolver());
+  request->Resolve(host_name, base::Bind(
+      &P2PSocketDispatcherHost::OnAddressResolved,
+      base::Unretained(this), request));

[awong, 2011/08/09 00:25:56]

Can the P2PSocketDispatcherHost be deleted before this callback runs?

[Sergey Ulanov, 2011/08/09 00:41:35]

Yes, but all pending requests will be deleted before that (see
OnChannelClosing()), so the callback will never be called after this object is
destroyed.

+  dns_requests_.insert(request);
+}
+
+void P2PSocketDispatcherHost::OnAddressResolved(
+    DnsRequest* request,
+    const net::IPAddressNumber& result) {
+  Send(new P2PMsg_GetHostAddressResult(

[Wez, 2011/08/08 21:47:18]

Can we bubble the net error-code back across the IPC channel to the renderer,
rather than just success or failure?

[Sergey Ulanov, 2011/08/09 00:41:35]

We currently don't do it for any other P2P IPC, and there isn't much renderer
can do with the code anyway. Beside that, there may be some security
implications of returning error to the renderer, so I would rather avoid it,
unless we know we need it.

+      request->routing_id(), request->request_id(), result));
+
+  dns_requests_.erase(request);
+  delete request;
+}
+
 void P2PSocketDispatcherHost::OnCreateSocket(
     const IPC::Message& msg, P2PSocketType type, int socket_id,
     const net::IPEndPoint& local_address,
     const net::IPEndPoint& remote_address) {
   if (LookupSocket(msg.routing_id(), socket_id)) {
     LOG(ERROR) << "Received P2PHostMsg_CreateSocket for socket "
         "that already exists.";
     return;
   }
 
@@ skipping 44 matching lines @@
                                               int socket_id) {
   SocketsMap::iterator it = sockets_.find(
       ExtendedSocketId(msg.routing_id(), socket_id));
   if (it != sockets_.end()) {
     delete it->second;
     sockets_.erase(it);
   } else {
     LOG(ERROR) << "Received P2PHostMsg_DestroySocket for invalid socket_id.";
   }
 }