base::Bind: Convert HostResolver::Resolve.

BUG=none
TEST=none

R=willchan@chromium.org

Review URL: http://codereview.chromium.org/8549004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@110333 0039d316-1c4b-4281-b951-d872f2087c98

39 files changed, 306 insertions, 279 deletions

diff --git a/chrome/browser/net/network_stats.cc b/chrome/browser/net/network_stats.cc
index 210bc15..1892a4e 100644
--- a/chrome/browser/net/network_stats.cc
+++ b/chrome/browser/net/network_stats.cc
@@ -82,8 +82,6 @@ NetworkStats::NetworkStats()
       bytes_to_send_(0),
       encoded_message_(""),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          resolve_callback_(this, &NetworkStats::OnResolveComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &NetworkStats::OnReadComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_callback_(this, &NetworkStats::OnWriteComplete)),
@@ -105,11 +103,11 @@ bool NetworkStats::Start(net::HostResolver* host_resolver,
   Initialize(bytes_to_send, finished_callback);
 
   net::HostResolver::RequestInfo request(server_host_port_pair);
-  int rv = host_resolver->Resolve(request,
-                                  &addresses_,
-                                  &resolve_callback_,
-                                  NULL,
-                                  net::BoundNetLog());
+  int rv = host_resolver->Resolve(
+      request, &addresses_,
+      base::Bind(&NetworkStats::OnResolveComplete,
+                 base::Unretained(this)),
+      NULL, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     return true;
   return DoConnect(rv);
diff --git a/chrome/browser/net/network_stats.h b/chrome/browser/net/network_stats.h
index 65742b6..8fcee6d 100644
--- a/chrome/browser/net/network_stats.h
+++ b/chrome/browser/net/network_stats.h
@@ -176,9 +176,6 @@ class NetworkStats {
   // HostResolver fills out the |addresses_| after host resolution is completed.
   net::AddressList addresses_;
 
-  // Callback to call when host resolution is completed.
-  net::OldCompletionCallbackImpl<NetworkStats> resolve_callback_;
-
   // Callback to call when data is read from the server.
   net::OldCompletionCallbackImpl<NetworkStats> read_callback_;
 
diff --git a/chrome/browser/net/predictor.cc b/chrome/browser/net/predictor.cc
index 51bc4ae..365e7e1 100644
--- a/chrome/browser/net/predictor.cc
+++ b/chrome/browser/net/predictor.cc
@@ -82,9 +82,7 @@ class Predictor::LookupRequest {
   LookupRequest(Predictor* predictor,
                 net::HostResolver* host_resolver,
                 const GURL& url)
-      : ALLOW_THIS_IN_INITIALIZER_LIST(
-            net_callback_(this, &LookupRequest::OnLookupFinished)),
-        predictor_(predictor),
+      : predictor_(predictor),
         url_(url),
         resolver_(host_resolver) {
   }
@@ -102,7 +100,9 @@ class Predictor::LookupRequest {
     // lets the HostResolver know it can de-prioritize it.
     resolve_info.set_is_speculative(true);
     return resolver_.Resolve(
-        resolve_info, &addresses_, &net_callback_, net::BoundNetLog());
+        resolve_info, &addresses_,
+        base::Bind(&LookupRequest::OnLookupFinished, base::Unretained(this)),
+        net::BoundNetLog());
   }
 
  private:
@@ -110,9 +110,6 @@ class Predictor::LookupRequest {
     predictor_->OnLookupFinished(this, url_, result == net::OK);
   }
 
-  // HostResolver will call us using this callback when resolution is complete.
-  net::OldCompletionCallbackImpl<LookupRequest> net_callback_;
-
   Predictor* predictor_;  // The predictor which started us.
 
   const GURL url_;  // Hostname to resolve.
diff --git a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
index 3ff79e3..ee337ce 100644
--- a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
+++ b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
@@ -28,9 +28,7 @@ class P2PSocketDispatcherHost::DnsRequest {
              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,
@@ -52,8 +50,11 @@ class P2PSocketDispatcherHost::DnsRequest {
       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);
   }
@@ -96,8 +97,6 @@ class P2PSocketDispatcherHost::DnsRequest {
   net::SingleRequestHostResolver resolver_;
 
   DoneCallback done_callback_;
-
-  net::OldCompletionCallbackImpl<DnsRequest> completion_callback_;
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc
index de155a5..9895dfb 100644
--- a/content/browser/renderer_host/pepper_message_filter.cc
+++ b/content/browser/renderer_host/pepper_message_filter.cc
@@ -181,7 +181,6 @@ class PepperMessageFilter::TCPSocket {
   ConnectionState connection_state_;
   bool end_of_file_reached_;
 
-  net::OldCompletionCallbackImpl<TCPSocket> resolve_callback_;
   net::OldCompletionCallbackImpl<TCPSocket> connect_callback_;
   net::OldCompletionCallbackImpl<TCPSocket> ssl_handshake_callback_;
   net::OldCompletionCallbackImpl<TCPSocket> read_callback_;
@@ -304,8 +303,6 @@ PepperMessageFilter::TCPSocket::TCPSocket(
       connection_state_(BEFORE_CONNECT),
       end_of_file_reached_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          resolve_callback_(this, &TCPSocket::OnResolveCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
           connect_callback_(this, &TCPSocket::OnConnectCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           ssl_handshake_callback_(this, &TCPSocket::OnSSLHandshakeCompleted)),
@@ -335,8 +332,10 @@ void PepperMessageFilter::TCPSocket::Connect(const std::string& host,
   net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
   resolver_.reset(new net::SingleRequestHostResolver(
       manager_->GetHostResolver()));
-  int result = resolver_->Resolve(request_info, &address_list_,
-                                  &resolve_callback_, net::BoundNetLog());
+  int result = resolver_->Resolve(
+      request_info, &address_list_,
+      base::Bind(&TCPSocket::OnResolveCompleted, base::Unretained(this)),
+      net::BoundNetLog());
   if (result != net::ERR_IO_PENDING)
     OnResolveCompleted(result);
 }
diff --git a/jingle/notifier/communicator/xmpp_connection_generator.cc b/jingle/notifier/communicator/xmpp_connection_generator.cc
index 5a234e7..b19d16b 100644
--- a/jingle/notifier/communicator/xmpp_connection_generator.cc
+++ b/jingle/notifier/communicator/xmpp_connection_generator.cc
@@ -20,6 +20,7 @@
 
 #include <vector>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ -45,10 +46,6 @@ XmppConnectionGenerator::XmppConnectionGenerator(
     const ServerList& servers)
     : delegate_(delegate),
       host_resolver_(host_resolver),
-      resolve_callback_(
-          ALLOW_THIS_IN_INITIALIZER_LIST(
-              NewCallback(this,
-                          &XmppConnectionGenerator::OnServerDNSResolved))),
       settings_list_(new ConnectionSettingsList()),
       settings_index_(0),
       servers_(servers),
@@ -126,12 +123,13 @@ void XmppConnectionGenerator::UseNextConnection() {
       net::HostResolver::RequestInfo request_info(server);
       int status =
           host_resolver_.Resolve(
-              request_info, &address_list_, resolve_callback_.get(),
+              request_info, &address_list_,
+              base::Bind(&XmppConnectionGenerator::OnServerDNSResolved,
+                         base::Unretained(this)),
               bound_net_log_);
-      if (status == net::ERR_IO_PENDING) {
-        // resolve_callback_ will call us when it's called.
+      if (status == net::ERR_IO_PENDING)  // OnServerDNSResolved will be called.
         return;
-      }
+
       HandleServerDNSResolved(status);
     } else {
       // We are not resolving DNS here (DNS will be resolved by a lower layer).
diff --git a/jingle/notifier/communicator/xmpp_connection_generator.h b/jingle/notifier/communicator/xmpp_connection_generator.h
index 1100575..9f3ad79 100644
--- a/jingle/notifier/communicator/xmpp_connection_generator.h
+++ b/jingle/notifier/communicator/xmpp_connection_generator.h
@@ -9,7 +9,6 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
-#include "net/base/completion_callback.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/single_request_host_resolver.h"
@@ -65,7 +64,6 @@ class XmppConnectionGenerator {
 
   Delegate* delegate_;
   net::SingleRequestHostResolver host_resolver_;
-  scoped_ptr<net::OldCompletionCallback> resolve_callback_;
   net::AddressList address_list_;
   net::BoundNetLog bound_net_log_;
   scoped_ptr<ConnectionSettingsList> settings_list_;
diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h
index b47fa81..a596610 100644
--- a/net/base/host_resolver.h
+++ b/net/base/host_resolver.h
@@ -116,7 +116,7 @@ class NET_EXPORT HostResolver {
   // incompatible IP literal (e.g. IPv6 is disabled and it is an IPv6
   // literal).
   //
-  // If the operation cannnot be completed synchronously, ERR_IO_PENDING will
+  // If the operation cannot be completed synchronously, ERR_IO_PENDING will
   // be returned and the real result code will be passed to the completion
   // callback.  Otherwise the result code is returned immediately from this
   // call.
@@ -128,7 +128,7 @@ class NET_EXPORT HostResolver {
   // Profiling information for the request is saved to |net_log| if non-NULL.
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) = 0;
 
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index 31f08c0..d01820b 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -16,6 +16,7 @@
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
@@ -262,7 +263,7 @@ class HostResolverImpl::Request {
   Request(const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
           const RequestInfo& info,
-          OldCompletionCallback* callback,
+          const CompletionCallback& callback,
           AddressList* addresses)
       : source_net_log_(source_net_log),
         request_net_log_(request_net_log),
@@ -275,12 +276,12 @@ class HostResolverImpl::Request {
   // Mark the request as cancelled.
   void MarkAsCancelled() {
     job_ = NULL;
-    callback_ = NULL;
     addresses_ = NULL;
+    callback_.Reset();
   }
 
   bool was_cancelled() const {
-    return callback_ == NULL;
+    return callback_.is_null();
   }
 
   void set_job(Job* job) {
@@ -292,9 +293,9 @@ class HostResolverImpl::Request {
   void OnComplete(int error, const AddressList& addrlist) {
     if (error == OK)
       *addresses_ = CreateAddressListUsingPort(addrlist, port());
-    OldCompletionCallback* callback = callback_;
+    CompletionCallback callback = callback_;
     MarkAsCancelled();
-    callback->Run(error);
+    callback.Run(error);
   }
 
   int port() const {
@@ -328,7 +329,7 @@ class HostResolverImpl::Request {
   Job* job_;
 
   // The user's callback to invoke when the request completes.
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
 
   // The address list to save result into.
   AddressList* addresses_;
@@ -1120,12 +1121,12 @@ void HostResolverImpl::SetPoolConstraints(JobPoolIndex pool_index,
 
 int HostResolverImpl::Resolve(const RequestInfo& info,
                               AddressList* addresses,
-                              OldCompletionCallback* callback,
+                              const CompletionCallback& callback,
                               RequestHandle* out_req,
                               const BoundNetLog& source_net_log) {
   DCHECK(addresses);
-  DCHECK(callback);
   DCHECK(CalledOnValidThread());
+  DCHECK_EQ(false, callback.is_null());
 
   // Make a log item for the request.
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
@@ -1146,7 +1147,7 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
     return rv;
   }
 
-   // Create a handle for this request, and pass it back to the user if they
+  // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
   Request* req = new Request(source_net_log, request_net_log, info,
                              callback, addresses);
diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h
index a32cce0..da69451 100644
--- a/net/base/host_resolver_impl.h
+++ b/net/base/host_resolver_impl.h
@@ -129,7 +129,7 @@ class NET_EXPORT HostResolverImpl
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& source_net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index a4d1954..487520d 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -6,6 +6,8 @@
 
 #include <string>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ -267,24 +269,25 @@ class ResolveRequest {
                  Delegate* delegate)
       : info_(HostPortPair(hostname, port)),
         resolver_(resolver),
-        delegate_(delegate),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &ResolveRequest::OnLookupFinished)) {
+        delegate_(delegate)  {
     // Start the request.
-    int err = resolver->Resolve(info_, &addrlist_, &callback_, &req_,
-                                BoundNetLog());
+    int err = resolver->Resolve(
+        info_, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)),
+        &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
   ResolveRequest(HostResolver* resolver,
                  const HostResolver::RequestInfo& info,
                  Delegate* delegate)
-      : info_(info), resolver_(resolver), delegate_(delegate),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &ResolveRequest::OnLookupFinished)) {
+      : info_(info), resolver_(resolver), delegate_(delegate) {
     // Start the request.
-    int err = resolver->Resolve(info, &addrlist_, &callback_, &req_,
-                                BoundNetLog());
+    int err = resolver->Resolve(
+        info, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished,
+                   base::Unretained(this)),
+       &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
@@ -329,7 +332,6 @@ class ResolveRequest {
   HostResolver* resolver_;
 
   Delegate* delegate_;
-  OldCompletionCallbackImpl<ResolveRequest> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ResolveRequest);
 };
@@ -338,21 +340,21 @@ class HostResolverImplTest : public testing::Test {
  public:
   HostResolverImplTest()
       : callback_called_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &HostResolverImplTest::OnLookupFinished)) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&HostResolverImplTest::OnLookupFinished,
+                       base::Unretained(this)))) {
   }
 
  protected:
-  bool callback_called_;
-  int callback_result_;
-  OldCompletionCallbackImpl<HostResolverImplTest> callback_;
-
- private:
   void OnLookupFinished(int result) {
     callback_called_ = true;
     callback_result_ = result;
     MessageLoop::current()->Quit();
   }
+
+  bool callback_called_;
+  int callback_result_;
+  CompletionCallback callback_;
 };
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
@@ -368,7 +370,7 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {
 
   HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  int err = host_resolver->Resolve(info, &addrlist, &callback_, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
@@ -458,7 +460,7 @@ TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
-    int err = host_resolver->Resolve(info, &addrlist, &callback_, NULL,
+    int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
@@ -515,9 +517,9 @@ TEST_F(HostResolverImplTest, NumericIPv4Address) {
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("127.1.2.3", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(OK, err);
 
@@ -542,9 +544,9 @@ TEST_F(HostResolverImplTest, NumericIPv6Address) {
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("2001:db8::1", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(OK, err);
 
@@ -574,9 +576,9 @@ TEST_F(HostResolverImplTest, EmptyHost) {
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
@@ -591,9 +593,9 @@ TEST_F(HostResolverImplTest, LongHost) {
   AddressList addrlist;
   const int kPortnum = 5555;
   std::string hostname(4097, 'a');
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair(hostname, kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
@@ -937,15 +939,13 @@ class BypassCacheVerifier : public ResolveRequest::Delegate {
       // Since caching is enabled, this should complete synchronously.
 
       // Note that |junk_callback| shouldn't be used since we are going to
-      // complete synchronously. We can't specify NULL though since that would
-      // mean synchronous mode so we give it a value of 1.
-      OldCompletionCallback* junk_callback =
-          reinterpret_cast<OldCompletionCallback*> (1);
+      // complete synchronously.
+      TestCompletionCallback junk_callback;
       AddressList addrlist;
 
       HostResolver::RequestInfo info(HostPortPair("a", 70));
-      int error = resolver->Resolve(info, &addrlist, junk_callback, NULL,
-                                    BoundNetLog());
+      int error = resolver->Resolve(info, &addrlist, junk_callback.callback(),
+                                    NULL, BoundNetLog());
       EXPECT_EQ(OK, error);
 
       // Ok good. Now make sure that if we ask to bypass the cache, it can no
@@ -991,15 +991,16 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
 
   // Resolve "host1".
   HostResolver::RequestInfo info1(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
-  int rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL,
+  TestCompletionCallback callback;
+  int rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Resolve "host1" again -- this time it will be served from cache, but it
   // should still notify of completion.
-  rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog());
+  rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
+                              BoundNetLog());
   ASSERT_EQ(OK, rv);  // Should complete synchronously.
 
   // Flush cache by triggering an IP address change.
@@ -1008,7 +1009,8 @@ TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
 
   // Resolve "host1" again -- this time it won't be served from cache, so it
   // will complete asynchronously.
-  rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog());
+  rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
+                              BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);  // Should complete asynchronously.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
@@ -1021,9 +1023,9 @@ TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1053,9 +1055,9 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1069,7 +1071,7 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
 
-  rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   resolver_proc->Wait();
@@ -1077,24 +1079,24 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
-class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > {
+class ResolveWithinCallback {
  public:
   explicit ResolveWithinCallback(const HostResolver::RequestInfo& info)
       : info_(info) {}
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
+  const CompletionCallback& callback() const { return callback_.callback(); }
+
+  int WaitForResult() {
+    int result = callback_.WaitForResult();
     // Ditch the WaitingHostResolverProc so that the subsequent request
     // succeeds.
-    callback_.RunWithParams(params);
     host_resolver_.reset(
         CreateHostResolverImpl(CreateCatchAllHostResolverProc()));
     EXPECT_EQ(ERR_IO_PENDING,
-              host_resolver_->Resolve(info_, &addrlist_, &nested_callback_,
-                                      NULL, BoundNetLog()));
-  }
-
-  int WaitForResult() {
-    return callback_.WaitForResult();
+              host_resolver_->Resolve(info_, &addrlist_,
+                                      nested_callback_.callback(), NULL,
+                                      BoundNetLog()));
+    return result;
   }
 
   int WaitForNestedResult() {
@@ -1104,8 +1106,8 @@ class ResolveWithinCallback : public CallbackRunner< Tuple1<int> > {
  private:
   const HostResolver::RequestInfo info_;
   AddressList addrlist_;
-  TestOldCompletionCallback callback_;
-  TestOldCompletionCallback nested_callback_;
+  TestCompletionCallback callback_;
+  TestCompletionCallback nested_callback_;
   scoped_ptr<HostResolver> host_resolver_;
 };
 
@@ -1118,7 +1120,7 @@ TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   ResolveWithinCallback callback(info);
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ -1158,13 +1160,14 @@ TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
       CreateResolverRequest("req5", HIGHEST),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], NULL, BoundNetLog());
+                                    callback[i].callback(), NULL,
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
@@ -1218,14 +1221,15 @@ TEST_F(HostResolverImplTest, CancelPendingRequest) {
       CreateResolverRequest("req6", MEDIUM),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
@@ -1294,14 +1298,15 @@ TEST_F(HostResolverImplTest, QueueOverflow) {
       CreateResolverRequest("req7", MEDIUM),   // Evicts req2.
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     if (i == 4u)
       EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv);
     else
@@ -1361,14 +1366,15 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV6),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv) << i;
   }
 
@@ -1431,14 +1437,15 @@ TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV4),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv) << i;
   }
 
@@ -1493,8 +1500,9 @@ TEST_F(HostResolverImplTest, DisallowNonCachedResponses) {
   EXPECT_EQ(ERR_DNS_CACHE_MISS, err);
 
   // This time, we fetch normally.
-  TestOldCompletionCallback callback;
-  err = host_resolver->Resolve(info, &addrlist, &callback, NULL, log.bound());
+  TestCompletionCallback callback;
+  err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
+                               log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
   err = callback.WaitForResult();
   EXPECT_EQ(OK, err);
@@ -1538,9 +1546,9 @@ TEST_F(HostResolverImplTest, MultipleAttempts) {
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
diff --git a/net/base/mapped_host_resolver.cc b/net/base/mapped_host_resolver.cc
index cb036f4..0166c33 100644
--- a/net/base/mapped_host_resolver.cc
+++ b/net/base/mapped_host_resolver.cc
@@ -21,11 +21,11 @@ MappedHostResolver::~MappedHostResolver() {
 
 int MappedHostResolver::Resolve(const RequestInfo& info,
                                 AddressList* addresses,
-                                OldCompletionCallback* callback,
+                                const CompletionCallback& callback,
                                 RequestHandle* out_req,
                                 const BoundNetLog& net_log) {
   DCHECK(addresses);
-  DCHECK(callback);
+  DCHECK_EQ(false, callback.is_null());
   // Modify the request before forwarding it to |impl_|.
   RequestInfo modified_info = info;
   HostPortPair host_port(info.host_port_pair());
diff --git a/net/base/mapped_host_resolver.h b/net/base/mapped_host_resolver.h
index aa98b97..a781f7e 100644
--- a/net/base/mapped_host_resolver.h
+++ b/net/base/mapped_host_resolver.h
@@ -46,7 +46,7 @@ class NET_EXPORT MappedHostResolver : public HostResolver {
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
diff --git a/net/base/mapped_host_resolver_unittest.cc b/net/base/mapped_host_resolver_unittest.cc
index e24fca3..7e691be 100644
--- a/net/base/mapped_host_resolver_unittest.cc
+++ b/net/base/mapped_host_resolver_unittest.cc
@@ -33,10 +33,11 @@ TEST(MappedHostResolverTest, Inclusion) {
 
   // Try resolving "www.google.com:80". There are no mappings yet, so this
   // hits |resolver_impl| and fails.
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("www.google.com", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
@@ -47,7 +48,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   // Try resolving "www.google.com:80". Should be remapped to "baz.com:80".
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("www.google.com", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -57,7 +59,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   // Try resolving "foo.com:77". This will NOT be remapped, so result
   // is "foo.com:77".
   rv = resolver->Resolve(HostResolver::RequestInfo(HostPortPair("foo.com", 77)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -70,7 +73,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   // Try resolving "chromium.org:61". Should be remapped to "proxy:99".
   rv = resolver->Resolve(HostResolver::RequestInfo
                              (HostPortPair("chromium.org", 61)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -91,7 +95,7 @@ TEST(MappedHostResolverTest, Exclusion) {
 
   int rv;
   AddressList address_list;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   // Remap "*.com" to "baz".
   EXPECT_TRUE(resolver->AddRuleFromString("map *.com baz"));
@@ -102,7 +106,8 @@ TEST(MappedHostResolverTest, Exclusion) {
   // Try resolving "www.google.com". Should not be remapped due to exclusion).
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("www.google.com", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -112,7 +117,8 @@ TEST(MappedHostResolverTest, Exclusion) {
   // Try resolving "chrome.com:80". Should be remapped to "baz:80".
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("chrome.com", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -132,7 +138,7 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
 
   int rv;
   AddressList address_list;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   // Remap "*.com" to "baz", and *.net to "bar:60".
   resolver->SetRulesFromString("map *.com baz , map *.net bar:60");
@@ -140,7 +146,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   // Try resolving "www.google.com". Should be remapped to "baz".
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("www.google.com", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -150,7 +157,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   // Try resolving "chrome.net:80". Should be remapped to "bar:60".
   rv = resolver->Resolve(HostResolver::RequestInfo(
                              HostPortPair("chrome.net", 80)),
-                         &address_list, &callback, NULL, BoundNetLog());
+                         &address_list, callback.callback(), NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 6d4b185..612c600 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -60,11 +60,11 @@ int ParseAddressList(const std::string& host_list,
 struct MockHostResolverBase::Request {
   Request(const RequestInfo& req_info,
           AddressList* addr,
-          OldCompletionCallback* cb)
+          const CompletionCallback& cb)
       : info(req_info), addresses(addr), callback(cb) {}
   RequestInfo info;
   AddressList* addresses;
-  OldCompletionCallback* callback;
+  CompletionCallback callback;
 };
 
 MockHostResolverBase::~MockHostResolverBase() {
@@ -73,7 +73,7 @@ MockHostResolverBase::~MockHostResolverBase() {
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
-                                  OldCompletionCallback* callback,
+                                  const CompletionCallback& callback,
                                   RequestHandle* handle,
                                   const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
@@ -188,8 +188,8 @@ void MockHostResolverBase::ResolveNow(size_t id) {
   scoped_ptr<Request> req(it->second);
   requests_.erase(it);
   int rv = ResolveProc(id, req->info, req->addresses);
-  if (req->callback)
-    req->callback->Run(rv);
+  if (!req->callback.is_null())
+    req->callback.Run(rv);
 }
 
 //-----------------------------------------------------------------------------
@@ -364,7 +364,7 @@ RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
 
 int HangingHostResolver::Resolve(const RequestInfo& info,
                                  AddressList* addresses,
-                                 OldCompletionCallback* callback,
+                                 const CompletionCallback& callback,
                                  RequestHandle* out_req,
                                  const BoundNetLog& net_log) {
   return ERR_IO_PENDING;
diff --git a/net/base/mock_host_resolver.h b/net/base/mock_host_resolver.h
index 1aff3cb..76b7ce1 100644
--- a/net/base/mock_host_resolver.h
+++ b/net/base/mock_host_resolver.h
@@ -65,7 +65,7 @@ class MockHostResolverBase : public HostResolver,
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
@@ -179,7 +179,7 @@ class HangingHostResolver : public HostResolver {
  public:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
diff --git a/net/base/single_request_host_resolver.cc b/net/base/single_request_host_resolver.cc
index 5af3dd5..b975c00 100644
--- a/net/base/single_request_host_resolver.cc
+++ b/net/base/single_request_host_resolver.cc
@@ -4,6 +4,8 @@
 
 #include "net/base/single_request_host_resolver.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "net/base/net_errors.h"
@@ -13,9 +15,9 @@ namespace net {
 SingleRequestHostResolver::SingleRequestHostResolver(HostResolver* resolver)
     : resolver_(resolver),
       cur_request_(NULL),
-      cur_request_callback_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &SingleRequestHostResolver::OnResolveCompletion)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+          base::Bind(&SingleRequestHostResolver::OnResolveCompletion,
+                     base::Unretained(this)))) {
   DCHECK(resolver_ != NULL);
 }
 
@@ -23,25 +25,25 @@ SingleRequestHostResolver::~SingleRequestHostResolver() {
   Cancel();
 }
 
-int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info,
-                                       AddressList* addresses,
-                                       OldCompletionCallback* callback,
-                                       const BoundNetLog& net_log) {
+int SingleRequestHostResolver::Resolve(
+    const HostResolver::RequestInfo& info, AddressList* addresses,
+    const CompletionCallback& callback, const BoundNetLog& net_log) {
   DCHECK(addresses);
-  DCHECK(callback);
-  DCHECK(!cur_request_callback_) << "resolver already in use";
+  DCHECK_EQ(false, callback.is_null());
+  DCHECK(cur_request_callback_.is_null()) << "resolver already in use";
 
   HostResolver::RequestHandle request = NULL;
 
   // We need to be notified of completion before |callback| is called, so that
   // we can clear out |cur_request_*|.
-  OldCompletionCallback* transient_callback = callback ? &callback_ : NULL;
+  CompletionCallback transient_callback =
+      callback.is_null() ? CompletionCallback() : callback_;
 
   int rv = resolver_->Resolve(
       info, addresses, transient_callback, &request, net_log);
 
   if (rv == ERR_IO_PENDING) {
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
     // Cleared in OnResolveCompletion().
     cur_request_ = request;
     cur_request_callback_ = callback;
@@ -51,24 +53,25 @@ int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info,
 }
 
 void SingleRequestHostResolver::Cancel() {
-  if (cur_request_callback_) {
+  if (!cur_request_callback_.is_null()) {
     resolver_->CancelRequest(cur_request_);
     cur_request_ = NULL;
-    cur_request_callback_ = NULL;
+    cur_request_callback_.Reset();
   }
 }
 
 void SingleRequestHostResolver::OnResolveCompletion(int result) {
-  DCHECK(cur_request_ && cur_request_callback_);
+  DCHECK(cur_request_);
+  DCHECK_EQ(false, cur_request_callback_.is_null());
 
-  OldCompletionCallback* callback = cur_request_callback_;
+  CompletionCallback callback = cur_request_callback_;
 
   // Clear the outstanding request information.
   cur_request_ = NULL;
-  cur_request_callback_ = NULL;
+  cur_request_callback_.Reset();
 
   // Call the user's original callback.
-  callback->Run(result);
+  callback.Run(result);
 }
 
 }  // namespace net
diff --git a/net/base/single_request_host_resolver.h b/net/base/single_request_host_resolver.h
index fb5c91e..03b646f 100644
--- a/net/base/single_request_host_resolver.h
+++ b/net/base/single_request_host_resolver.h
@@ -27,7 +27,7 @@ class NET_EXPORT SingleRequestHostResolver {
   // |addresses| object upon success. See HostResolver::Resolve() for details.
   int Resolve(const HostResolver::RequestInfo& info,
               AddressList* addresses,
-              OldCompletionCallback* callback,
+              const CompletionCallback& callback,
               const BoundNetLog& net_log);
 
   // Cancels the in-progress request, if any. This prevents the callback
@@ -44,10 +44,10 @@ class NET_EXPORT SingleRequestHostResolver {
 
   // The current request (if any).
   HostResolver::RequestHandle cur_request_;
-  OldCompletionCallback* cur_request_callback_;
+  CompletionCallback cur_request_callback_;
 
   // Completion callback for when request to |resolver_| completes.
-  OldCompletionCallbackImpl<SingleRequestHostResolver> callback_;
+  CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SingleRequestHostResolver);
 };
diff --git a/net/base/single_request_host_resolver_unittest.cc b/net/base/single_request_host_resolver_unittest.cc
index 7106af5f..295a318 100644
--- a/net/base/single_request_host_resolver_unittest.cc
+++ b/net/base/single_request_host_resolver_unittest.cc
@@ -32,7 +32,7 @@ class HangingHostResolver : public HostResolver {
 
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE {
     EXPECT_FALSE(has_outstanding_request());
@@ -74,10 +74,10 @@ TEST(SingleRequestHostResolverTest, NormalResolve) {
 
   // Resolve "watsup:90" using our SingleRequestHostResolver.
   AddressList addrlist;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo request(HostPortPair("watsup", 90));
   int rv = single_request_resolver.Resolve(
-      request, &addrlist, &callback, BoundNetLog());
+      request, &addrlist, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -94,10 +94,10 @@ TEST(SingleRequestHostResolverTest, Cancel) {
 
     // Resolve "watsup:90" using our SingleRequestHostResolver.
     AddressList addrlist;
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     HostResolver::RequestInfo request(HostPortPair("watsup", 90));
     int rv = single_request_resolver.Resolve(
-        request, &addrlist, &callback, BoundNetLog());
+        request, &addrlist, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_TRUE(resolver.has_outstanding_request());
   }
diff --git a/net/curvecp/test_client.cc b/net/curvecp/test_client.cc
index abf5957..d57a13f 100644
--- a/net/curvecp/test_client.cc
+++ b/net/curvecp/test_client.cc
@@ -57,7 +57,8 @@ bool TestClient::Start(const HostPortPair& server_host_port_pair,
   SingleRequestHostResolver host_resolver(system_host_resolver.get());
   HostResolver::RequestInfo request(server_host_port_pair);
   AddressList addresses;
-  int rv = host_resolver.Resolve(request, &addresses, NULL, BoundNetLog());
+  int rv = host_resolver.Resolve(request, &addresses, CompletionCallback(),
+                                 BoundNetLog());
   if (rv != OK) {
     LOG(ERROR) << "Could not resolve host";
     return false;
diff --git a/net/dns/async_host_resolver.cc b/net/dns/async_host_resolver.cc
index 31e612e..1666e04 100644
--- a/net/dns/async_host_resolver.cc
+++ b/net/dns/async_host_resolver.cc
@@ -85,7 +85,7 @@ class AsyncHostResolver::Request {
           const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
           const HostResolver::RequestInfo& info,
-          OldCompletionCallback* callback,
+          const CompletionCallback& callback,
           AddressList* addresses)
       : resolver_(resolver),
         source_net_log_(source_net_log),
@@ -103,7 +103,7 @@ class AsyncHostResolver::Request {
   }
 
   ~Request() {
-    if (callback_)
+    if (!callback_.is_null())
       resolver_->OnCancel(this);
   }
 
@@ -161,7 +161,7 @@ class AsyncHostResolver::Request {
   // |addresses_| and in case of an unsuccessful synchronous completion, we
   // do not touch |addresses_|.
   void OnSyncComplete(int result) {
-    callback_ = NULL;
+    callback_.Reset();
     resolver_->OnFinish(this, result);
   }
 
@@ -169,11 +169,11 @@ class AsyncHostResolver::Request {
   void OnAsyncComplete(int result, const AddressList& addresses) {
     if (result == OK)
       *addresses_ = CreateAddressListUsingPort(addresses, info_.port());
-    DCHECK(callback_);
-    OldCompletionCallback* callback = callback_;
-    callback_ = NULL;
+    DCHECK_EQ(false, callback_.is_null());
+    CompletionCallback callback = callback_;
+    callback_.Reset();
     resolver_->OnFinish(this, result);
-    callback->Run(result);
+    callback.Run(result);
   }
 
   // Returns true if request has a validly formed hostname.
@@ -187,7 +187,7 @@ class AsyncHostResolver::Request {
   BoundNetLog request_net_log_;
   const HostResolver::RequestInfo info_;
   Key key_;
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
   AddressList* addresses_;
   int result_;
 };
@@ -225,11 +225,11 @@ AsyncHostResolver::~AsyncHostResolver() {
 
 int AsyncHostResolver::Resolve(const RequestInfo& info,
                                AddressList* addresses,
-                               OldCompletionCallback* callback,
+                               const CompletionCallback& callback,
                                RequestHandle* out_req,
                                const BoundNetLog& source_net_log) {
   DCHECK(addresses);
-  DCHECK(callback);
+  DCHECK_EQ(false, callback.is_null());
   scoped_ptr<Request> request(
       CreateNewRequest(info, callback, addresses, source_net_log));
 
@@ -259,7 +259,7 @@ int AsyncHostResolver::ResolveFromCache(const RequestInfo& info,
                                         AddressList* addresses,
                                         const BoundNetLog& source_net_log) {
   scoped_ptr<Request> request(
-      CreateNewRequest(info, NULL, addresses, source_net_log));
+      CreateNewRequest(info, CompletionCallback(), addresses, source_net_log));
   int rv = ERR_UNEXPECTED;
   if (!request->IsValid())
     rv = ERR_NAME_NOT_RESOLVED;
@@ -382,7 +382,7 @@ void AsyncHostResolver::OnTransactionComplete(
 
 AsyncHostResolver::Request* AsyncHostResolver::CreateNewRequest(
     const RequestInfo& info,
-    OldCompletionCallback* callback,
+    const CompletionCallback& callback,
     AddressList* addresses,
     const BoundNetLog& source_net_log) {
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
diff --git a/net/dns/async_host_resolver.h b/net/dns/async_host_resolver.h
index 5d09ecf..c501d65 100644
--- a/net/dns/async_host_resolver.h
+++ b/net/dns/async_host_resolver.h
@@ -39,7 +39,7 @@ class NET_EXPORT AsyncHostResolver
   // HostResolver interface
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& source_net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
@@ -75,7 +75,7 @@ class NET_EXPORT AsyncHostResolver
 
   // Create a new request for the incoming Resolve() call.
   Request* CreateNewRequest(const RequestInfo& info,
-                            OldCompletionCallback* callback,
+                            const CompletionCallback& callback,
                             AddressList* addresses,
                             const BoundNetLog& source_net_log);
 
diff --git a/net/dns/async_host_resolver_unittest.cc b/net/dns/async_host_resolver_unittest.cc
index d0de625..d92887e 100644
--- a/net/dns/async_host_resolver_unittest.cc
+++ b/net/dns/async_host_resolver_unittest.cc
@@ -147,12 +147,12 @@ class AsyncHostResolverTest : public testing::Test {
   TestPrng test_prng_;
   RandIntCallback rand_int_cb_;
   scoped_ptr<HostResolver> resolver_;
-  TestOldCompletionCallback callback0_, callback1_, callback2_, callback3_;
+  TestCompletionCallback callback0_, callback1_, callback2_, callback3_;
 };
 
 TEST_F(AsyncHostResolverTest, EmptyHostLookup) {
   info0_.set_host_port_pair(HostPortPair("", kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
@@ -161,7 +161,7 @@ TEST_F(AsyncHostResolverTest, IPv4LiteralLookup) {
   const char* kIPLiteral = "192.168.1.2";
   info0_.set_host_port_pair(HostPortPair(kIPLiteral, kPortNum));
   info0_.set_host_resolver_flags(HOST_RESOLVER_CANONNAME);
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(OK, rv);
   std::vector<const char*> ip_addresses(1, kIPLiteral);
@@ -171,7 +171,7 @@ TEST_F(AsyncHostResolverTest, IPv4LiteralLookup) {
 
 TEST_F(AsyncHostResolverTest, IPv6LiteralLookup) {
   info0_.set_host_port_pair(HostPortPair("2001:db8:0::42", kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   // When support for IPv6 is added, this should succeed.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
@@ -182,7 +182,7 @@ TEST_F(AsyncHostResolverTest, CachedLookup) {
   EXPECT_EQ(ERR_DNS_CACHE_MISS, rv);
 
   // Cache the result of |info0_| lookup.
-  rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                           BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback0_.WaitForResult();
@@ -199,19 +199,19 @@ TEST_F(AsyncHostResolverTest, CachedLookup) {
 TEST_F(AsyncHostResolverTest, InvalidHostNameLookup) {
   const std::string kHostName1(64, 'a');
   info0_.set_host_port_pair(HostPortPair(kHostName1, kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 
   const std::string kHostName2(4097, 'b');
   info0_.set_host_port_pair(HostPortPair(kHostName2, kPortNum));
-  rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                           BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 TEST_F(AsyncHostResolverTest, Lookup) {
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback0_.WaitForResult();
@@ -220,11 +220,11 @@ TEST_F(AsyncHostResolverTest, Lookup) {
 }
 
 TEST_F(AsyncHostResolverTest, ConcurrentLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
@@ -247,11 +247,11 @@ TEST_F(AsyncHostResolverTest, ConcurrentLookup) {
 
 TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) {
   // We pass the info0_ to all requests.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
-  int rv2 = resolver_->Resolve(info0_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
@@ -275,12 +275,12 @@ TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) {
 
 TEST_F(AsyncHostResolverTest, CancelLookup) {
   HostResolver::RequestHandle req0 = NULL, req2 = NULL;
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0,
-                               BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
-                               BoundNetLog());
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(),
+                               &req0, BoundNetLog());
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
+                               &req2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
@@ -304,9 +304,9 @@ TEST_F(AsyncHostResolverTest, CancelSameHostLookup) {
   HostResolver::RequestHandle req0 = NULL;
 
   // Pass the info0_ to both requests.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0,
-                               BoundNetLog());
-  int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(),
+                               &req0, BoundNetLog());
+  int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
@@ -326,15 +326,15 @@ TEST_F(AsyncHostResolverTest, CancelSameHostLookup) {
 TEST_F(AsyncHostResolverTest, QueuedLookup) {
   // kMaxTransactions is 2, thus the following requests consume all
   // available transactions.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   // The following request will end up in queue.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv2);
   EXPECT_EQ(1u,
@@ -358,17 +358,17 @@ TEST_F(AsyncHostResolverTest, QueuedLookup) {
 TEST_F(AsyncHostResolverTest, CancelPendingLookup) {
   // kMaxTransactions is 2, thus the following requests consume all
   // available transactions.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   // The following request will end up in queue.
   HostResolver::RequestHandle req2 = NULL;
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2,
-                               BoundNetLog());
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
+                               &req2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv2);
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
@@ -389,12 +389,12 @@ TEST_F(AsyncHostResolverTest, CancelPendingLookup) {
 }
 
 TEST_F(AsyncHostResolverTest, ResolverDestructionCancelsLookups) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   // This one is queued.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
@@ -415,12 +415,12 @@ TEST_F(AsyncHostResolverTest, ResolverDestructionCancelsLookups) {
 // Test that when the number of pending lookups is at max, a new lookup
 // with a priority lower than all of those in the queue fails.
 TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   // This one is queued and fills up the queue since its size is 1.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
@@ -431,7 +431,7 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) {
 
   // This one fails.
   info3_.set_priority(LOWEST);
-  int rv3 = resolver_->Resolve(info3_, &addrlist3_, &callback3_, NULL,
+  int rv3 = resolver_->Resolve(info3_, &addrlist3_, callback3_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv3);
 
@@ -443,9 +443,9 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) {
 // with a priority higher than any of those in the queue succeeds and
 // causes the lowest priority lookup in the queue to fail.
 TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
 
   // Next lookup is queued.  Since this will be ejected from the queue and
@@ -454,8 +454,9 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) {
   HostResolver::RequestInfo info(HostPortPair("cnn.com", 80));
   info.set_address_family(ADDRESS_FAMILY_IPV4);
   AddressList addrlist_fail;
-  TestOldCompletionCallback callback_fail;
-  int rv_fail = resolver_->Resolve(info, &addrlist_fail, &callback_fail, NULL,
+  TestCompletionCallback callback_fail;
+  int rv_fail = resolver_->Resolve(info, &addrlist_fail,
+                                   callback_fail.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
@@ -466,7 +467,7 @@ TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) {
 
   // Lookup 2 causes the above to fail, but itself should succeed.
   info2_.set_priority(HIGHEST);
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
 
   rv0 = callback0_.WaitForResult();
diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc
index 24ab0f9..f5ef45e 100644
--- a/net/ftp/ftp_network_transaction.cc
+++ b/net/ftp/ftp_network_transaction.cc
@@ -4,6 +4,8 @@
 
 #include "net/ftp/ftp_network_transaction.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
@@ -627,7 +629,10 @@ int FtpNetworkTransaction::DoCtrlResolveHost() {
 
   HostResolver::RequestInfo info(HostPortPair::FromURL(request_->url));
   // No known referrer.
-  return resolver_.Resolve(info, &addresses_, &io_callback_, net_log_);
+  return resolver_.Resolve(
+      info, &addresses_,
+      base::Bind(&FtpNetworkTransaction::OnIOComplete, base::Unretained(this)),
+      net_log_);
 }
 
 int FtpNetworkTransaction::DoCtrlResolveHostComplete(int result) {
diff --git a/net/http/http_auth_handler_negotiate.cc b/net/http/http_auth_handler_negotiate.cc
index 05604bd..814cecd 100644
--- a/net/http/http_auth_handler_negotiate.cc
+++ b/net/http/http_auth_handler_negotiate.cc
@@ -4,6 +4,8 @@
 
 #include "net/http/http_auth_handler_negotiate.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ -101,8 +103,6 @@ HttpAuthHandlerNegotiate::HttpAuthHandlerNegotiate(
 #endif
       disable_cname_lookup_(disable_cname_lookup),
       use_port_(use_port),
-      ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
-          this, &HttpAuthHandlerNegotiate::OnIOComplete)),
       resolver_(resolver),
       already_called_(false),
       has_credentials_(false),
@@ -293,8 +293,11 @@ int HttpAuthHandlerNegotiate::DoResolveCanonicalName() {
   HostResolver::RequestInfo info(HostPortPair(origin_.host(), 0));
   info.set_host_resolver_flags(HOST_RESOLVER_CANONNAME);
   single_resolve_.reset(new SingleRequestHostResolver(resolver_));
-  return single_resolve_->Resolve(info, &address_list_, &io_callback_,
-                                  net_log_);
+  return single_resolve_->Resolve(
+      info, &address_list_,
+      base::Bind(&HttpAuthHandlerNegotiate::OnIOComplete,
+                 base::Unretained(this)),
+      net_log_);
 }
 
 int HttpAuthHandlerNegotiate::DoResolveCanonicalNameComplete(int rv) {
diff --git a/net/http/http_auth_handler_negotiate.h b/net/http/http_auth_handler_negotiate.h
index 2731f5f..868d88a 100644
--- a/net/http/http_auth_handler_negotiate.h
+++ b/net/http/http_auth_handler_negotiate.h
@@ -143,7 +143,6 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNegotiate : public HttpAuthHandler {
   AuthSystem auth_system_;
   bool disable_cname_lookup_;
   bool use_port_;
-  OldCompletionCallbackImpl<HttpAuthHandlerNegotiate> io_callback_;
   HostResolver* const resolver_;
 
   // Members which are needed for DNS lookup + SPN.
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index f5afd74..2af99c2 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -5813,10 +5813,11 @@ void BypassHostCacheOnRefreshHelper(int load_flags) {
 
   // Warm up the host cache so it has an entry for "www.google.com".
   AddressList addrlist;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
+  TestOldCompletionCallback old_callback;
   int rv = session_deps.host_resolver->Resolve(
       HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist,
-      &callback, NULL, BoundNetLog());
+      callback.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -5825,7 +5826,7 @@ void BypassHostCacheOnRefreshHelper(int load_flags) {
   // and confirming it completes synchronously.
   rv = session_deps.host_resolver->Resolve(
       HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist,
-      &callback, NULL, BoundNetLog());
+      callback.callback(), NULL, BoundNetLog());
   ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
@@ -5840,9 +5841,9 @@ void BypassHostCacheOnRefreshHelper(int load_flags) {
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Run the request.
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, &old_callback, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
-  rv = callback.WaitForResult();
+  rv = old_callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
@@ -8901,8 +8902,8 @@ void IPPoolingAddAlias(MockCachingHostResolver* host_resolver,
   // Resolve the host and port.
   AddressList addresses;
   HostResolver::RequestInfo info(host_port_pair);
-  TestOldCompletionCallback callback;
-  int rv = host_resolver->Resolve(info, &addresses, &callback, NULL,
+  TestCompletionCallback callback;
+  int rv = host_resolver->Resolve(info, &addresses, callback.callback(), NULL,
                                   BoundNetLog());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
@@ -8970,16 +8971,17 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
+  TestOldCompletionCallback old_callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
-  int rv = trans1.Start(&request1, &callback, BoundNetLog());
+  int rv = trans1.Start(&request1, &old_callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
@@ -8994,7 +8996,7 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
   HostPortPair host_port("www.gmail.com", 443);
   HostResolver::RequestInfo resolve_info(host_port);
   AddressList ignored;
-  rv = host_resolver.Resolve(resolve_info, &ignored, &callback, NULL,
+  rv = host_resolver.Resolve(resolve_info, &ignored, callback.callback(), NULL,
                              BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
@@ -9012,9 +9014,9 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(session);
 
-  rv = trans2.Start(&request2, &callback, BoundNetLog());
+  rv = trans2.Start(&request2, &old_callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
@@ -9040,7 +9042,7 @@ class OneTimeCachingHostResolver : public net::HostResolver {
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE {
     return host_resolver_.Resolve(
@@ -9123,16 +9125,17 @@ TEST_F(HttpNetworkTransactionTest,
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
-  int rv = trans1.Start(&request1, &callback, BoundNetLog());
+  TestOldCompletionCallback old_callback;
+  int rv = trans1.Start(&request1, &old_callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
@@ -9146,7 +9149,7 @@ TEST_F(HttpNetworkTransactionTest,
   // Preload cache entries into HostCache.
   HostResolver::RequestInfo resolve_info(HostPortPair("www.gmail.com", 443));
   AddressList ignored;
-  rv = host_resolver.Resolve(resolve_info, &ignored, &callback, NULL,
+  rv = host_resolver.Resolve(resolve_info, &ignored, callback.callback(), NULL,
                              BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
@@ -9164,9 +9167,9 @@ TEST_F(HttpNetworkTransactionTest,
   IPPoolingAddAlias(host_resolver.GetMockHostResolver(), &pool_peer,
                     "www.google.com", 443, "127.0.0.1");
 
-  rv = trans2.Start(&request2, &callback, BoundNetLog());
+  rv = trans2.Start(&request2, &old_callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index e4fa389..6ead6ef 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -73,7 +73,8 @@ class MockSyncHostResolver : public SyncHostResolver {
 
   virtual int Resolve(const HostResolver::RequestInfo& info,
                       AddressList* addresses) OVERRIDE {
-    return resolver_.Resolve(info, addresses, NULL, NULL, BoundNetLog());
+    return resolver_.Resolve(info, addresses, CompletionCallback(), NULL,
+                             BoundNetLog());
   }
 
   virtual void Shutdown() OVERRIDE {}
diff --git a/net/proxy/sync_host_resolver_bridge.cc b/net/proxy/sync_host_resolver_bridge.cc
index 7bd20c6..69dce07 100644
--- a/net/proxy/sync_host_resolver_bridge.cc
+++ b/net/proxy/sync_host_resolver_bridge.cc
@@ -4,6 +4,7 @@
 
 #include "net/proxy/sync_host_resolver_bridge.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ -52,7 +53,6 @@ class SyncHostResolverBridge::Core
 
   HostResolver* const host_resolver_;
   MessageLoop* const host_resolver_loop_;
-  net::OldCompletionCallbackImpl<Core> callback_;
   // The result from the current request (set on |host_resolver_loop_|).
   int err_;
   // The currently outstanding request to |host_resolver_|, or NULL.
@@ -75,8 +75,6 @@ SyncHostResolverBridge::Core::Core(HostResolver* host_resolver,
                                    MessageLoop* host_resolver_loop)
     : host_resolver_(host_resolver),
       host_resolver_loop_(host_resolver_loop),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &Core::OnResolveCompletion)),
       err_(0),
       outstanding_request_(NULL),
       event_(true, false),
@@ -104,7 +102,8 @@ void SyncHostResolverBridge::Core::StartResolve(
     return;
 
   int error = host_resolver_->Resolve(
-      info, addresses, &callback_, &outstanding_request_, BoundNetLog());
+      info, addresses, base::Bind(&Core::OnResolveCompletion, this),
+      &outstanding_request_, BoundNetLog());
   if (error != ERR_IO_PENDING)
     OnResolveCompletion(error);  // Completed synchronously.
 }
diff --git a/net/proxy/sync_host_resolver_bridge_unittest.cc b/net/proxy/sync_host_resolver_bridge_unittest.cc
index 36586d3..d862255 100644
--- a/net/proxy/sync_host_resolver_bridge_unittest.cc
+++ b/net/proxy/sync_host_resolver_bridge_unittest.cc
@@ -32,10 +32,10 @@ class BlockableHostResolver : public HostResolver {
 
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE {
-    EXPECT_TRUE(callback);
+    EXPECT_FALSE(callback.is_null());
     EXPECT_TRUE(out_req);
     *out_req = reinterpret_cast<RequestHandle*>(1);  // Magic value.
 
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index 9cd45db..85b07b8 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -67,9 +67,9 @@ void SOCKS5ClientSocketTest::SetUp() {
 
   // Resolve the "localhost" AddressList used by the TCP connection to connect.
   HostResolver::RequestInfo info(HostPortPair("www.socks-proxy.com", 1080));
-  TestOldCompletionCallback callback;
-  int rv = host_resolver_->Resolve(info, &address_list_, &callback, NULL,
-                                   BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = host_resolver_->Resolve(info, &address_list_, callback.callback(),
+                                   NULL, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   ASSERT_EQ(OK, rv);
diff --git a/net/socket/socks_client_socket.cc b/net/socket/socks_client_socket.cc
index d05f1f9..3ce723e 100644
--- a/net/socket/socks_client_socket.cc
+++ b/net/socket/socks_client_socket.cc
@@ -5,6 +5,7 @@
 #include "net/socket/socks_client_socket.h"
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
@@ -280,7 +281,9 @@ int SOCKSClientSocket::DoResolveHost() {
   // addresses for the target host.
   host_request_info_.set_address_family(ADDRESS_FAMILY_IPV4);
   return host_resolver_.Resolve(
-      host_request_info_, &addresses_, &io_callback_, net_log_);
+      host_request_info_, &addresses_,
+      base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)),
+      net_log_);
 }
 
 int SOCKSClientSocket::DoResolveHostComplete(int result) {
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index 2f7645f..6762e1bb 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -87,11 +87,11 @@ class HangingHostResolverWithCancel : public HostResolver {
 
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
-                      OldCompletionCallback* callback,
+                      const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE {
     DCHECK(addresses);
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
     EXPECT_FALSE(HasOutstandingRequest());
     outstanding_request_ = reinterpret_cast<RequestHandle>(1);
     *out_req = outstanding_request_;
diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index e0bca7c..7ade2e8 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -675,8 +675,8 @@ TEST_F(SSLClientSocketPoolTest, IPPooling) {
     // This test requires that the HostResolver cache be populated.  Normal
     // code would have done this already, but we do it manually.
     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
-    host_resolver_.Resolve(info, &test_hosts[i].addresses, NULL, NULL,
-                           BoundNetLog());
+    host_resolver_.Resolve(info, &test_hosts[i].addresses, CompletionCallback(),
+                           NULL, BoundNetLog());
 
     // Setup a HostPortProxyPair
     test_hosts[i].pair = HostPortProxyPair(
@@ -751,7 +751,8 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) {
     { "js.webkit.org",     "192.168.0.4,192.168.0.1,192.0.2.33" },
   };
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
+  TestOldCompletionCallback old_callback;
   int rv;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
     host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name,
@@ -760,8 +761,8 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) {
     // This test requires that the HostResolver cache be populated.  Normal
     // code would have done this already, but we do it manually.
     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
-    rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, &callback,
-                                NULL, BoundNetLog());
+    rv = host_resolver_.Resolve(info, &test_hosts[i].addresses,
+                                callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, callback.GetResult(rv));
 
     // Setup a HostPortProxyPair
@@ -788,12 +789,12 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) {
 
   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
   rv = handle->Init(
-      "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog());
+      "a", params, MEDIUM, &old_callback, pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle->is_initialized());
   EXPECT_FALSE(handle->socket());
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_EQ(OK, old_callback.WaitForResult());
   EXPECT_TRUE(handle->is_initialized());
   EXPECT_TRUE(handle->socket());
 
diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc
index 803e9e9..38ac74e 100644
--- a/net/socket/transport_client_socket_pool.cc
+++ b/net/socket/transport_client_socket_pool.cc
@@ -199,8 +199,10 @@ int TransportConnectJob::DoLoop(int result) {
 
 int TransportConnectJob::DoResolveHost() {
   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
-  return resolver_.Resolve(params_->destination(), &addresses_, &callback_,
-                           net_log());
+  return resolver_.Resolve(
+      params_->destination(), &addresses_,
+      base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)),
+      net_log());
 }
 
 int TransportConnectJob::DoResolveHostComplete(int result) {
diff --git a/net/socket/transport_client_socket_unittest.cc b/net/socket/transport_client_socket_unittest.cc
index 62473fe..d661e02 100644
--- a/net/socket/transport_client_socket_unittest.cc
+++ b/net/socket/transport_client_socket_unittest.cc
@@ -122,8 +122,9 @@ void TransportClientSocketTest::SetUp() {
                                HostResolver::kDefaultRetryAttempts,
                                NULL));
   HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_));
-  TestOldCompletionCallback callback;
-  int rv = resolver->Resolve(info, &addr, &callback, NULL, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = resolver->Resolve(info, &addr, callback.callback(), NULL,
+                             BoundNetLog());
   CHECK_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   CHECK_EQ(rv, OK);
diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc
index 5051b64..89cfd8f 100644
--- a/net/socket_stream/socket_stream.cc
+++ b/net/socket_stream/socket_stream.cc
@@ -608,8 +608,9 @@ int SocketStream::DoResolveHost() {
 
   DCHECK(host_resolver_);
   resolver_.reset(new SingleRequestHostResolver(host_resolver_));
-  return resolver_->Resolve(resolve_info, &addresses_, &io_callback_,
-                            net_log_);
+  return resolver_->Resolve(
+      resolve_info, &addresses_, base::Bind(&SocketStream::OnIOCompleted, this),
+      net_log_);
 }
 
 int SocketStream::DoResolveHostComplete(int result) {
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index 8e8125a..17eef50 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -771,7 +771,8 @@ void IPPoolingTest(bool clean_via_close_current_sessions) {
     // code would have done this already, but we do it manually.
     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
     session_deps.host_resolver->Resolve(
-        info, &test_hosts[i].addresses, NULL, NULL, BoundNetLog());
+        info, &test_hosts[i].addresses, CompletionCallback(), NULL,
+        BoundNetLog());
 
     // Setup a HostPortProxyPair
     test_hosts[i].pair = HostPortProxyPair(
diff --git a/net/test/test_server.cc b/net/test/test_server.cc
index 4850f4f..c27f73b 100644
--- a/net/test/test_server.cc
+++ b/net/test/test_server.cc
@@ -196,8 +196,8 @@ bool TestServer::GetAddressList(AddressList* address_list) const {
                                HostResolver::kDefaultRetryAttempts,
                                NULL));
   HostResolver::RequestInfo info(host_port_pair_);
-  TestOldCompletionCallback callback;
-  int rv = resolver->Resolve(info, address_list, &callback, NULL,
+  TestCompletionCallback callback;
+  int rv = resolver->Resolve(info, address_list, callback.callback(), NULL,
                              BoundNetLog());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();