base::Bind: Convert proxy_resolving_client_socket.[cc,h] and deps.

net/socket/client_socket_pool_base_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/client_socket_pool_base.h"
 
 #include "base/callback.h"

[csilv, 2011/12/14 20:10:19]

#include base/bind.h ,base/bind_helpers.h

[James Hawkins, 2011/12/14 20:59:05]

Done.

 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
@@ skipping 760 matching lines @@
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
   EXPECT_EQ(OK,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         log.bound()));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
       entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   // Set the additional error state members to ensure that they get cleared.
   handle.set_is_ssl_error(true);
   HttpResponseInfo info;
   info.headers = new HttpResponseHeaders("");
   handle.set_ssl_error_response_info(info);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         log.bound()));
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
@@ skipping 213 matching lines @@
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
 }
 
 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
 
   ClientSocketHandle handles[4];
   for (size_t i = 0; i < arraysize(handles); ++i) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     EXPECT_EQ(ERR_IO_PENDING,
               handles[i].Init("b",
                               params_,
                               kDefaultPriority,
-                              &callback,
+                              callback.callback(),
                               pool_.get(),
                               BoundNetLog()));
   }
 
   // One will be stalled, cancel all the handles now.
   // This should hit the OnAvailableSocketSlot() code where we previously had
   // stalled groups, but no longer have any.
   for (size_t i = 0; i < arraysize(handles); ++i)
     handles[i].Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   {
     ClientSocketHandle handles[kDefaultMaxSockets];
-    TestOldCompletionCallback callbacks[kDefaultMaxSockets];
+    TestCompletionCallback callbacks[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
       EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
                                     params_,
                                     kDefaultPriority,
-                                    &callbacks[i],
+                                    callbacks[i].callback(),
                                     pool_.get(),
                                     BoundNetLog()));
     }
 
     // Force a stalled group.
     ClientSocketHandle stalled_handle;
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
                                                   params_,
                                                   kDefaultPriority,
-                                                  &callback,
+                                                  callback.callback(),
                                                   pool_.get(),
                                                   BoundNetLog()));
 
     // Cancel the stalled request.
     stalled_handle.Reset();
 
     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
     EXPECT_EQ(0, pool_->IdleSocketCount());
 
     // Dropping out of scope will close all handles and return them to idle.
   }
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
   EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   {
     ClientSocketHandle handles[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
-      TestOldCompletionCallback callback;
+      TestCompletionCallback callback;
       EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
                                                 params_,
                                                 kDefaultPriority,
-                                                &callback,
+                                                callback.callback(),
                                                 pool_.get(),
                                                 BoundNetLog()));
     }
 
     // Force a stalled group.
     connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
     ClientSocketHandle stalled_handle;
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
                                                   params_,
                                                   kDefaultPriority,
-                                                  &callback,
+                                                  callback.callback(),
                                                   pool_.get(),
                                                   BoundNetLog()));
 
     // Since it is stalled, it should have no connect jobs.
     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
 
     // Cancel the stalled request.
     handles[0].Reset();
 
     // Now we should have a connect job.
@@ skipping 11 matching lines @@
   }
 
   EXPECT_EQ(1, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   ClientSocketHandle stalled_handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   {
     EXPECT_FALSE(pool_->IsStalled());
     ClientSocketHandle handles[kDefaultMaxSockets];
     for (int i = 0; i < kDefaultMaxSockets; ++i) {
-      TestOldCompletionCallback callback;
+      TestCompletionCallback callback;
       EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
           "Take 2: %d", i),
           params_,
           kDefaultPriority,
-          &callback,
+          callback.callback(),
           pool_.get(),
           BoundNetLog()));
     }
 
     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
     EXPECT_EQ(0, pool_->IdleSocketCount());
     EXPECT_FALSE(pool_->IsStalled());
 
     // Now we will hit the socket limit.
     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
                                                   params_,
                                                   kDefaultPriority,
-                                                  &callback,
+                                                  callback.callback(),
                                                   pool_.get(),
                                                   BoundNetLog()));
     EXPECT_TRUE(pool_->IsStalled());
 
     // Dropping out of scope will close all handles and return them to idle.
   }
 
   // But if we wait for it, the released idle sockets will be closed in
   // preference of the waiting request.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
   EXPECT_EQ(3, pool_->IdleSocketCount());
 }
 
 // Regression test for http://crbug.com/40952.
 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   pool_->EnableConnectBackupJobs();
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   for (int i = 0; i < kDefaultMaxSockets; ++i) {
     ClientSocketHandle handle;
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     EXPECT_EQ(OK, handle.Init(base::IntToString(i),
                               params_,
                               kDefaultPriority,
-                              &callback,
+                              callback.callback(),
                               pool_.get(),
                               BoundNetLog()));
   }
 
   // Flush all the DoReleaseSocket tasks.
   MessageLoop::current()->RunAllPending();
 
   // Stall a group.  Set a pending job so it'll trigger a backup job if we don't
   // reuse a socket.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   // "0" is special here, since it should be the first entry in the sorted map,
   // which is the one which we would close an idle socket for.  We shouldn't
   // close an idle socket though, since we should reuse the idle socket.
   EXPECT_EQ(OK, handle.Init("0",
                             params_,
                             kDefaultPriority,
-                            &callback,
+                            callback.callback(),
                             pool_.get(),
                             BoundNetLog()));
 
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
   EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
@@ skipping 49 matching lines @@
 }
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending connect job will be cancelled and should not call back into
 // ClientSocketPoolBase.
 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   handle.Reset();
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback2,
+                        callback2.callback(),
                         pool_.get(),
                         BoundNetLog()));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
 
   handle.Reset();
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
@@ skipping 25 matching lines @@
   EXPECT_EQ(3, GetOrderOfRequest(4));
   EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
             GetOrderOfRequest(5));  // Canceled request.
   EXPECT_EQ(4, GetOrderOfRequest(6));
   EXPECT_EQ(6, GetOrderOfRequest(7));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
 }
 
-class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
+class RequestSocketCallback : public TestCompletionCallbackBase {
  public:
   RequestSocketCallback(ClientSocketHandle* handle,
                         TestClientSocketPool* pool,
                         TestConnectJobFactory* test_connect_job_factory,
                         TestConnectJob::JobType next_job_type)
       : handle_(handle),
         pool_(pool),
         within_callback_(false),
         test_connect_job_factory_(test_connect_job_factory),
-        next_job_type_(next_job_type) {}
+        next_job_type_(next_job_type),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&RequestSocketCallback::OnComplete,
+                       base::Unretained(this)))) {
+  }
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    callback_.RunWithParams(params);
-    ASSERT_EQ(OK, params.a);
+  virtual ~RequestSocketCallback() {}
+
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void OnComplete(int result) {
+    ASSERT_EQ(OK, result);
 
     if (!within_callback_) {
       test_connect_job_factory_->set_job_type(next_job_type_);
 
       // Don't allow reuse of the socket.  Disconnect it and then release it and
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         MessageLoop::ScopedNestableTaskAllower nestable(
             MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;
-      TestOldCompletionCallback next_job_callback;
+      TestCompletionCallback next_job_callback;
       scoped_refptr<TestSocketParams> params(new TestSocketParams());
       int rv = handle_->Init("a",
                              params,
                              kDefaultPriority,
-                             &next_job_callback,
+                             next_job_callback.callback(),
                              pool_,
                              BoundNetLog());
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
           break;
         case TestConnectJob::kMockPendingJob:
           EXPECT_EQ(ERR_IO_PENDING, rv);
 
           // For pending jobs, wait for new socket to be created. This makes
           // sure there are no more pending operations nor any unclosed sockets
           // when the test finishes.
           // We need to give it a little bit of time to run, so that all the
           // operations that happen on timers (e.g. cleanup of idle
           // connections) can execute.
           {
             MessageLoop::ScopedNestableTaskAllower nestable(
                 MessageLoop::current());
             base::PlatformThread::Sleep(10);
             EXPECT_EQ(OK, next_job_callback.WaitForResult());
           }
           break;
         default:
           FAIL() << "Unexpected job type: " << next_job_type_;
           break;
       }
     }
   }
 
-  int WaitForResult() {
-    return callback_.WaitForResult();
-  }
-
- private:
   ClientSocketHandle* const handle_;
   TestClientSocketPool* const pool_;
   bool within_callback_;
   TestConnectJobFactory* const test_connect_job_factory_;
   TestConnectJob::JobType next_job_type_;
-  TestOldCompletionCallback callback_;
+  CompletionCallback callback_;
 };
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_,
       TestConnectJob::kMockPendingJob);
   int rv = handle.Init("a",
                        params_,
                        kDefaultPriority,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
   int rv = handle.Init("a",
                        params_,
                        kDefaultPriority,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Make sure that pending requests get serviced after active requests get
 // cancelled.
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
@@ skipping 43 matching lines @@
   for (size_t i = 0; i < kNumberOfRequests; ++i)
     EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   int rv = handle.Init("a",
                        params_,
                        kDefaultPriority,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   handle.Reset();
 
   rv = handle.Init("a",
                    params_,
                    kDefaultPriority,
-                   &callback,
+                   callback.callback(),
                    pool_.get(),
                    BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_FALSE(handle.is_reused());
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 // Regression test for http://crbug.com/17985.
@@ skipping 30 matching lines @@
   pool_->CloseIdleSockets();
 
   MessageLoop::current()->RunAllPending();  // Run the released socket wakeups
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int rv = handle.Init("a",
                        params_,
                        LOWEST,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
 
   net::CapturingNetLog::EntryList entries;
@@ skipping 11 matching lines @@
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        InitConnectionAsynchronousFailure) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   // Set the additional error state members to ensure that they get cleared.
   handle.set_is_ssl_error(true);
   HttpResponseInfo info;
   info.headers = new HttpResponseHeaders("");
   handle.set_ssl_error_response_info(info);
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         log.bound()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   // TODO(eroman): Add back the log expectations! Removed them because the
   //               ordering is difficult, and some may fire during destructor.
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
   CapturingBoundNetLog log2(CapturingNetLog::kUnbounded);
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback2,
+                         callback2.callback(),
                          pool_.get(),
                          BoundNetLog()));
 
   handle.Reset();
 
 
   // At this point, request 2 is just waiting for the connect job to finish.
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle2.Reset();
@@ skipping 31 matching lines @@
 
   // Start job 1 (async OK)
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   std::vector<TestSocketRequest*> request_order;
   size_t completion_count;  // unused
   TestSocketRequest req1(&request_order, &completion_count);
   int rv = req1.handle()->Init("a",
                                params_,
                                kDefaultPriority,
-                               &req1, pool_.get(),
+                               req1.callback(), pool_.get(),
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
   // Job 1 finished OK.  Start job 2 (also async OK).  Request 3 is pending
   // without a job.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(&request_order, &completion_count);
   rv = req2.handle()->Init("a",
                            params_,
                            kDefaultPriority,
-                           &req2,
+                           req2.callback(),
                            pool_.get(),
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(&request_order, &completion_count);
   rv = req3.handle()->Init("a",
                            params_,
                            kDefaultPriority,
-                           &req3,
+                           req3.callback(),
                            pool_.get(),
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Both Requests 2 and 3 are pending.  We release socket 1 which should
   // service request 2.  Request 3 should still be waiting.
   req1.handle()->Reset();
   MessageLoop::current()->RunAllPending();  // Run the released socket wakeups
   ASSERT_TRUE(req2.handle()->socket());
   EXPECT_EQ(OK, req2.WaitForResult());
@@ skipping 17 matching lines @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   // First two jobs are async.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   std::vector<TestSocketRequest*> request_order;
   size_t completion_count;  // unused
   TestSocketRequest req1(&request_order, &completion_count);
   int rv = req1.handle()->Init("a",
                                params_,
                                kDefaultPriority,
-                               &req1,
+                               req1.callback(),
                                pool_.get(),
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(&request_order, &completion_count);
   rv = req2.handle()->Init("a",
                            params_,
                            kDefaultPriority,
-                           &req2,
+                           req2.callback(),
                            pool_.get(),
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   TestSocketRequest req3(&request_order, &completion_count);
   rv = req3.handle()->Init("a",
                            params_,
                            kDefaultPriority,
-                           &req3,
+                           req3.callback(),
                            pool_.get(),
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
   EXPECT_EQ(OK, req2.WaitForResult());
   EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult());
 
   ASSERT_EQ(3U, request_order.size());
   EXPECT_EQ(&req1, request_order[0]);
   EXPECT_EQ(&req2, request_order[1]);
   EXPECT_EQ(&req3, request_order[2]);
 }
 
 TEST_F(ClientSocketPoolBaseTest, LoadState) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockAdvancingLoadStateJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   int rv = handle.Init("a",
                        params_,
                        kDefaultPriority,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_IDLE, handle.GetLoadState());
 
   MessageLoop::current()->RunAllPending();
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   rv = handle2.Init("a",
                     params_,
                     kDefaultPriority,
-                    &callback2, pool_.get(),
+                    callback2.callback(), pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_NE(LOAD_STATE_IDLE, handle.GetLoadState());
   EXPECT_NE(LOAD_STATE_IDLE, handle2.GetLoadState());
 }
 
 TEST_F(ClientSocketPoolBaseTest, Recoverable) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, handle.Init("a",
                                                   params_,
                                                   kDefaultPriority,
-                                                  &callback, pool_.get(),
+                                                  callback.callback(), pool_.get(),
                                                   BoundNetLog()));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 }
 
 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingRecoverableJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 }
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockAdditionalErrorStateJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_CONNECTION_FAILED,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
 }
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingAdditionalErrorStateJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback,
+                        callback.callback(),
                         pool_.get(),
                         BoundNetLog()));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
 }
 
 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimer) {
   // Disable cleanup timer.
   internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
 
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta::FromMilliseconds(10),  // Time out unused sockets
       base::TimeDelta::FromMilliseconds(10));  // Time out used sockets
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   int rv = handle.Init("a",
                        params_,
                        LOWEST,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   rv = handle2.Init("a",
                     params_,
                     LOWEST,
-                    &callback2,
+                    callback2.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Use the socket.
   EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
   handle2.Reset();
 
   // The idle socket timeout value was set to 10 milliseconds. Wait 100
   // milliseconds so the sockets timeout.
   base::PlatformThread::Sleep(100);
   MessageLoop::current()->RunAllPending();
 
   ASSERT_EQ(2, pool_->IdleSocketCount());
 
   // Request a new socket. This should cleanup the unused and timed out ones.
   // A new socket will be created rather than reusing the idle one.
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   rv = handle.Init("a",
                    params_,
                    LOWEST,
-                   &callback,
+                   callback.callback(),
                    pool_.get(),
                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(handle.is_reused());
 
   // Make sure the idle socket is closed
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_FALSE(LogContainsEntryWithType(
       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   int rv = handle.Init("a",
                        params_,
                        LOWEST,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   rv = handle2.Init("a",
                     params_,
                     LOWEST,
-                    &callback2,
+                    callback2.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
 
   // Cancel one of the requests.  Wait for the other, which will get the first
   // job.  Release the socket.  Run the loop again to make sure the second
   // socket is sitting idle and the first one is released (since ReleaseSocket()
   // just posts a DoReleaseSocket() task).
 
@@ skipping 13 matching lines @@
   ASSERT_EQ(2, pool_->IdleSocketCount());
 
   // Invoke the idle socket cleanup check.  Only one socket should be left, the
   // used socket.  Request it to make sure that it's used.
 
   pool_->CleanupTimedOutIdleSockets();
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   rv = handle.Init("a",
                    params_,
                    LOWEST,
-                   &callback,
+                   callback.callback(),
                    pool_.get(),
                    log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_reused());
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEntryWithType(
       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 // Make sure that we process all pending requests even when we're stalling
 // because of multiple releasing disconnected sockets.
 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
   CreatePoolWithIdleTimeouts(
       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Startup 4 connect jobs.  Two of them will be pending.
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   int rv = handle.Init("a",
                        params_,
                        LOWEST,
-                       &callback,
+                       callback.callback(),
                        pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   rv = handle2.Init("a",
                     params_,
                     LOWEST,
-                    &callback2,
+                    callback2.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   ClientSocketHandle handle3;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   rv = handle3.Init("a",
                     params_,
                     LOWEST,
-                    &callback3,
+                    callback3.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ClientSocketHandle handle4;
-  TestOldCompletionCallback callback4;
+  TestCompletionCallback callback4;
   rv = handle4.Init("a",
                     params_,
                     LOWEST,
-                    &callback4,
+                    callback4.callback(),
                     pool_.get(),
                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Release two disconnected sockets.
 
   handle.socket()->Disconnect();
   handle.Reset();
   handle2.socket()->Disconnect();
   handle2.Reset();
@@ skipping 11 matching lines @@
   CreatePoolWithIdleTimeouts(
       4 /* socket limit */, 4 /* socket limit per group */,
       base::TimeDelta(),  // Time out unused sockets immediately.
       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   // Max out the socket limit with 2 per group.
 
   ClientSocketHandle handle_a[4];
-  TestOldCompletionCallback callback_a[4];
+  TestCompletionCallback callback_a[4];
   ClientSocketHandle handle_b[4];
-  TestOldCompletionCallback callback_b[4];
+  TestCompletionCallback callback_b[4];
 
   for (int i = 0; i < 2; ++i) {
     EXPECT_EQ(OK, handle_a[i].Init("a",
                                    params_,
                                    LOWEST,
-                                   &callback_a[i],
+                                   callback_a[i].callback(),
                                    pool_.get(),
                                    BoundNetLog()));
     EXPECT_EQ(OK, handle_b[i].Init("b",
                                    params_,
                                    LOWEST,
-                                   &callback_b[i],
+                                   callback_b[i].callback(),
                                    pool_.get(),
                                    BoundNetLog()));
   }
 
   // Make 4 pending requests, 2 per group.
 
   for (int i = 2; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING,
               handle_a[i].Init("a",
                                params_,
                                LOWEST,
-                               &callback_a[i],
+                               callback_a[i].callback(),
                                pool_.get(),
                                BoundNetLog()));
     EXPECT_EQ(ERR_IO_PENDING,
               handle_b[i].Init("b",
                                params_,
                                LOWEST,
-                               &callback_b[i],
+                               callback_b[i].callback(),
                                pool_.get(),
                                BoundNetLog()));
   }
 
   // Release b's socket first.  The order is important, because in
   // DoReleaseSocket(), we'll process b's released socket, and since both b and
   // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
   // first, which has a releasing socket, so it refuses to start up another
   // ConnectJob.  So, we used to infinite loop on this.
   handle_b[0].socket()->Disconnect();
@@ skipping 40 matching lines @@
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5));
 }
 
-class TestReleasingSocketRequest : public CallbackRunner< Tuple1<int> > {
+class TestReleasingSocketRequest : public TestCompletionCallbackBase {
  public:
   TestReleasingSocketRequest(TestClientSocketPool* pool,
                              int expected_result,
                              bool reset_releasing_handle)
       : pool_(pool),
         expected_result_(expected_result),
-        reset_releasing_handle_(reset_releasing_handle) {}
+        reset_releasing_handle_(reset_releasing_handle),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&TestReleasingSocketRequest::OnComplete,
+                       base::Unretained(this)))) {
+  }
+
+  virtual ~TestReleasingSocketRequest() {}
 
   ClientSocketHandle* handle() { return &handle_; }
 
-  int WaitForResult() {
-    return callback_.WaitForResult();
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void OnComplete(int result) {
+    if (reset_releasing_handle_)
+      handle_.Reset();
+
+    scoped_refptr<TestSocketParams> con_params(new TestSocketParams());
+    EXPECT_EQ(expected_result_,
+              handle2_.Init("a", con_params, kDefaultPriority,
+                            callback2_.callback(), pool_, BoundNetLog()));
   }
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    callback_.RunWithParams(params);
-    if (reset_releasing_handle_)
-                      handle_.Reset();
-    scoped_refptr<TestSocketParams> con_params(new TestSocketParams());
-    EXPECT_EQ(expected_result_, handle2_.Init("a",
-                                              con_params,
-                                              kDefaultPriority,
-                                              &callback2_,
-                                              pool_,
-                                              BoundNetLog()));
-  }
-
- private:
   TestClientSocketPool* const pool_;
   int expected_result_;
   bool reset_releasing_handle_;
   ClientSocketHandle handle_;
   ClientSocketHandle handle2_;
-  TestOldCompletionCallback callback_;
-  TestOldCompletionCallback callback2_;
+  CompletionCallback callback_;
+  TestCompletionCallback callback2_;
 };
 
 
 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockPendingAdditionalErrorStateJob);
   TestReleasingSocketRequest req(pool_.get(), OK, false);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a",
-                               params_,
-                               kDefaultPriority,
-                               &req,
-                               pool_.get(),
-                               BoundNetLog()));
+            req.handle()->Init("a", params_, kDefaultPriority, req.callback(),
+                               pool_.get(), BoundNetLog()));
   // The next job should complete synchronously
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
   EXPECT_FALSE(req.handle()->is_initialized());
   EXPECT_FALSE(req.handle()->socket());
   EXPECT_TRUE(req.handle()->is_ssl_error());
   EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL);
 }
 
 // http://crbug.com/44724 regression test.
 // We start releasing the pool when we flush on network change.  When that
 // happens, the only active references are in the ClientSocketHandles.  When a
 // ConnectJob completes and calls back into the last ClientSocketHandle, that
 // callback can release the last reference and delete the pool.  After the
 // callback finishes, we go back to the stack frame within the now-deleted pool.
 // Executing any code that refers to members of the now-deleted pool can cause
 // crashes.
 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   pool_->Flush();
 
   // We'll call back into this now.
   callback.WaitForResult();
 }
 
 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 
   pool_->Flush();
 
   handle.Reset();
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
 }
 
-class ConnectWithinCallback : public CallbackRunner< Tuple1<int> > {
+class ConnectWithinCallback : public TestCompletionCallbackBase {
  public:
   ConnectWithinCallback(
       const std::string& group_name,
       const scoped_refptr<TestSocketParams>& params,
       TestClientSocketPool* pool)
-      : group_name_(group_name), params_(params), pool_(pool) {}
-
-  ~ConnectWithinCallback() {}
-
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    callback_.RunWithParams(params);
-    EXPECT_EQ(ERR_IO_PENDING,
-              handle_.Init(group_name_,
-                           params_,
-                           kDefaultPriority,
-                           &nested_callback_,
-                           pool_,
-                           BoundNetLog()));
+      : group_name_(group_name),
+        params_(params),
+        pool_(pool),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&ConnectWithinCallback::OnComplete,
+                       base::Unretained(this)))) {
   }
 
-  int WaitForResult() {
-    return callback_.WaitForResult();
-  }
+  virtual ~ConnectWithinCallback() {}
 
   int WaitForNestedResult() {
     return nested_callback_.WaitForResult();
   }
 
+  const CompletionCallback& callback() const { return callback_; }
+
  private:
+  void OnComplete(int result) {
+    EXPECT_EQ(ERR_IO_PENDING,
+              handle_.Init(group_name_,
+                           params_,
+                           kDefaultPriority,
+                           nested_callback_.callback(),
+                           pool_,
+                           BoundNetLog()));
+  }
+
   const std::string group_name_;
   const scoped_refptr<TestSocketParams> params_;
   TestClientSocketPool* const pool_;
   ClientSocketHandle handle_;
-  TestOldCompletionCallback callback_;
-  TestOldCompletionCallback nested_callback_;
+  CompletionCallback callback_;
+  TestCompletionCallback nested_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
 };
 
 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   // First job will be waiting until it gets aborted.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   ClientSocketHandle handle;
   ConnectWithinCallback callback("a", params_, pool_.get());
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   // Second job will be started during the first callback, and will
   // asynchronously complete with OK.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   pool_->Flush();
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
   EXPECT_EQ(OK, callback.WaitForNestedResult());
 }
 
 // Cancel a pending socket request while we're at max sockets,
 // and verify that the backup socket firing doesn't cause a crash.
 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
   // Max 4 sockets globally, max 4 sockets per group.
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
 
   // Start (MaxSockets - 1) connected sockets to reach max sockets.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   ClientSocketHandle handles[kDefaultMaxSockets];
   for (int i = 1; i < kDefaultMaxSockets; ++i) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     EXPECT_EQ(OK, handles[i].Init("bar",
                                   params_,
                                   kDefaultPriority,
-                                  &callback,
+                                  callback.callback(),
                                   pool_.get(),
                                   BoundNetLog()));
   }
 
   MessageLoop::current()->RunAllPending();
 
   // Cancel the pending request.
   handle.Reset();
 
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3);
 
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
 
   // Cancel the socket request.  This should cancel the backup timer.  Wait for
   // the backup time to see if it indeed got canceled.
   handle.Reset();
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3);
   MessageLoop::current()->RunAllPending();
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   pool_->EnableConnectBackupJobs();
 
   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
   // timer.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ASSERT_TRUE(pool_->HasGroup("bar"));
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
 
   // Cancel request 1 and then complete request 2.  With the requests finished,
   // the backup timer should be cancelled.
   handle.Reset();
   EXPECT_EQ(OK, callback2.WaitForResult());
   // Wait for the backup timer to fire (add some slop to ensure it fires)
   base::PlatformThread::Sleep(
       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3);
   MessageLoop::current()->RunAllPending();
 }
 
 // Test delayed socket binding for the case where we have two connects,
 // and while one is waiting on a connect, the other frees up.
 // The socket waiting on a connect should switch immediately to the freed
 // up socket.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle1.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
@@ skipping 16 matching lines @@
   MessageLoop::current()->RunAllPending();
 }
 
 // Test delayed socket binding when a group is at capacity and one
 // of the group's sockets frees up.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle1.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
@@ skipping 18 matching lines @@
 
 // Test out the case where we have one socket connected, one
 // connecting, when the first socket finishes and goes idle.
 // Although the second connection is pending, the second request
 // should complete, by taking the first socket's idle socket.
 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle1.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // No idle sockets, no pending jobs.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
 
   // Create a second socket to the same host, but this one will wait.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   ClientSocketHandle handle2;
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback,
+                         callback.callback(),
                          pool_.get(),
                          BoundNetLog()));
   // No idle sockets, and one connecting job.
   EXPECT_EQ(0, pool_->IdleSocketCount());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Return the first handle to the pool.  This will initiate the delayed
   // binding.
   handle1.Reset();
 
@@ skipping 21 matching lines @@
 TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
   const int kUnlimitedSockets = 100;
   const int kOneSocketPerGroup = 1;
   CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
 
   // Make the first request asynchronous fail.
   // This will free up a socket slot later.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING,
             handle1.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback1,
+                         callback1.callback(),
                          pool_.get(),
                          BoundNetLog()));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   // Make the second request synchronously fail.  This should make the Group
   // empty.
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
   // when created.
   EXPECT_EQ(ERR_IO_PENDING,
             handle2.Init("a",
                          params_,
                          kDefaultPriority,
-                         &callback2,
+                         callback2.callback(),
                          pool_.get(),
                          BoundNetLog()));
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult());
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult());
   EXPECT_FALSE(pool_->HasGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ClientSocketHandle handle3;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback3,
+                                         callback3.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   // Use the socket.
   EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
   EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
 
   handle1.Reset();
   handle2.Reset();
   handle3.Reset();
 
   EXPECT_EQ(OK, handle1.Init("a",
                              params_,
                              kDefaultPriority,
-                             &callback1,
+                             callback1.callback(),
                              pool_.get(),
                              BoundNetLog()));
   EXPECT_EQ(OK, handle2.Init("a",
                              params_,
                              kDefaultPriority,
-                             &callback2,
+                             callback2.callback(),
                              pool_.get(),
                              BoundNetLog()));
   EXPECT_EQ(OK, handle3.Init("a",
                              params_,
                              kDefaultPriority,
-                             &callback3,
+                             callback3.callback(),
                              pool_.get(),
                              BoundNetLog()));
 
   EXPECT_TRUE(handle1.socket()->WasEverUsed());
   EXPECT_TRUE(handle2.socket()->WasEverUsed());
   EXPECT_FALSE(handle3.socket()->WasEverUsed());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle1.Reset();
   handle2.Reset();
 
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ(OK, callback2.WaitForResult());
   handle1.Reset();
   handle2.Reset();
 
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ClientSocketHandle handle3;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback3,
+                                         callback3.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
@@ skipping 51 matching lines @@
   ASSERT_TRUE(pool_->HasGroup("b"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
   EXPECT_FALSE(pool_->IsStalled());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
   handle1.Reset();
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
@@ skipping 46 matching lines @@
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   int rv = handle2.Init("a",
                         params_,
                         kDefaultPriority,
-                        &callback2,
+                        callback2.callback(),
                         pool_.get(),
                         BoundNetLog());
   if (rv != OK) {
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_EQ(OK, callback2.WaitForResult());
   }
 
   handle1.Reset();
   handle2.Reset();
 
@@ skipping 31 matching lines @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
 
   handle1.Reset();
 
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 }
 
 // http://crbug.com/64940 regression test.
 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
   const int kMaxTotalSockets = 3;
   const int kMaxSocketsPerGroup = 2;
   CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   // Note that group name ordering matters here.  "a" comes before "b", so
   // CloseOneIdleSocket() will try to close "a"'s idle socket.
 
   // Set up one idle socket in "a".
   ClientSocketHandle handle1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
   handle1.Reset();
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
 
   // Set up two active sockets in "b".
   ClientSocketHandle handle2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
                                          params_,
                                          kDefaultPriority,
-                                         &callback1,
+                                         callback1.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
                                          params_,
                                          kDefaultPriority,
-                                         &callback2,
+                                         callback2.callback(),
                                          pool_.get(),
                                          BoundNetLog()));
 
   ASSERT_EQ(OK, callback1.WaitForResult());
   ASSERT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
 
   // Now we have 1 idle socket in "a" and 2 active sockets in "b".  This means
   // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
@@ skipping 54 matching lines @@
   // Make the ConnectJob hang forever.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   MessageLoop::current()->RunAllPending();
 
   // Make the backup job be a pending job, so it completes normally.
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
                                         params_,
                                         kDefaultPriority,
-                                        &callback,
+                                        callback.callback(),
                                         pool_.get(),
                                         BoundNetLog()));
   // Timer has started, but the backup connect job shouldn't be created yet.
   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // The hung connect job should still be there, but everything else should be
   // complete.
@@ skipping 10 matching lines @@
         params_(new TestSocketParams),
         group_name_(group_name) {
     pool_->AddLayeredPool(this);
   }
 
   ~MockLayeredPool() {
     pool_->RemoveLayeredPool(this);
   }
 
   int RequestSocket(TestClientSocketPool* pool) {
-    return handle_.Init(group_name_, params_, kDefaultPriority, &callback_,
-                        pool, BoundNetLog());
+    return handle_.Init(group_name_, params_, kDefaultPriority,
+                        callback_.callback(), pool, BoundNetLog());
   }
 
   int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
     params_->set_ignore_limits(true);
-    return handle_.Init(group_name_, params_, kDefaultPriority, &callback_,
-                        pool, BoundNetLog());
+    return handle_.Init(group_name_, params_, kDefaultPriority,
+                        callback_.callback(), pool, BoundNetLog());
   }
 
   bool ReleaseOneConnection() {
     if (!handle_.is_initialized()) {
       return false;
     }
     handle_.socket()->Disconnect();
     handle_.Reset();
     return true;
   }
 
   MOCK_METHOD0(CloseOneIdleConnection, bool());
 
  private:
   TestClientSocketPool* const pool_;
   scoped_refptr<TestSocketParams> params_;
   ClientSocketHandle handle_;
-  TestOldCompletionCallback callback_;
+  TestCompletionCallback callback_;
   const std::string group_name_;
 };
 
 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillOnce(Return(false));
@@ skipping 16 matching lines @@
 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
   CreatePool(1, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillOnce(Invoke(&mock_layered_pool,
                        &MockLayeredPool::ReleaseOneConnection));
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(OK, handle.Init("a",
                             params_,
                             kDefaultPriority,
-                            &callback,
+                            callback.callback(),
                             pool_.get(),
                             BoundNetLog()));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
        CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
   CreatePool(1, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
   EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get()));
   EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool1,
                              &MockLayeredPool::ReleaseOneConnection));
   MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
   EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()));
   EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
       .WillRepeatedly(Invoke(&mock_layered_pool2,
                              &MockLayeredPool::ReleaseOneConnection));
   ClientSocketHandle handle;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   EXPECT_EQ(OK, handle.Init("a",
                             params_,
                             kDefaultPriority,
-                            &callback,
+                            callback.callback(),
                             pool_.get(),
                             BoundNetLog()));
 }
 
 }  // namespace
 
 }  // namespace net