base::Bind: Convert HostResolver::Resolve.

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"
@@ skipping 10 matching lines @@
 namespace content {
 
 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)) {
+        resolver_(host_resolver) {
   }
 
   void Resolve(const std::string& host_name,
                const DoneCallback& done_callback) {
     DCHECK(!done_callback.is_null());
 
     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));
-    int result = resolver_.Resolve(info, &addresses_, &completion_callback_,
-                                   net::BoundNetLog());
+    int result = resolver_.Resolve(
+        info, &addresses_,
+        base::Bind(&P2PSocketDispatcherHost::DnsRequest::OnDone,
+                   base::Unretained(this)),
+        net::BoundNetLog());
     if (result != net::ERR_IO_PENDING)
       OnDone(result);
   }
 
   int32 routing_id() { return routing_id_; }
   int32 request_id() { return request_id_; }
 
  private:
   void OnDone(int result) {
     if (result != net::OK) {
@@ skipping 22 matching lines @@
   }
 
   int32 routing_id_;
   int32 request_id_;
   net::AddressList addresses_;
 
   std::string host_name_;
   net::SingleRequestHostResolver resolver_;
 
   DoneCallback done_callback_;
-
-  net::OldCompletionCallbackImpl<DnsRequest> completion_callback_;
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
     const content::ResourceContext* resource_context)
     : resource_context_(resource_context),
       monitoring_networks_(false) {
 }
 
 P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
   DCHECK(sockets_.empty());
@@ skipping 169 matching lines @@
       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.";
   }
 }
 
 }  // namespace content