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

12 files changed, 148 insertions, 128 deletions

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());
   }