base::Bind: Convert most of net/http.

net/http/http_network_transaction_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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 180 matching lines @@
     request.load_flags = 0;
 
     SessionDependencies session_deps;
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(CreateSession(&session_deps)));
 
     for (size_t i = 0; i < data_count; ++i) {
       session_deps.socket_factory.AddSocketDataProvider(data[i]);
     }
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
     EXPECT_TRUE(log.bound().IsLoggingAllEvents());
-    int rv = trans->Start(&request, &callback, log.bound());
+    int rv = trans->Start(&request, callback.callback(), log.bound());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     out.rv = callback.WaitForResult();
     if (out.rv != OK)
       return out;
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     // Can't use ASSERT_* inside helper functions like this, so
     // return an error.
     if (response == NULL || response->headers == NULL) {
@@ skipping 93 matching lines @@
                              CertVerifier* cert_verifier);
 
   const std::string last_group_name_received() const {
     return last_group_name_;
   }
 
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
-                            OldCompletionCallback* callback,
+                            const CompletionCallback& callback,
                             const BoundNetLog& net_log) {
     last_group_name_ = group_name;
     return ERR_IO_PENDING;
   }
   virtual void CancelRequest(const std::string& group_name,
                              ClientSocketHandle* handle) {}
   virtual void ReleaseSocket(const std::string& group_name,
                              StreamSocket* socket,
                              int id) {}
   virtual void CloseIdleSockets() {}
@@ skipping 383 matching lines @@
   request.url = GURL("http://redirect.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL && response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine());
   std::string url;
   EXPECT_TRUE(response->headers->IsRedirect(&url));
   EXPECT_EQ("http://good.com/", url);
@@ skipping 51 matching lines @@
     MockRead("Content-Length: 1234\r\n\r\n"),
 
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   // Check that the headers got parsed.
   EXPECT_TRUE(response->headers != NULL);
@@ skipping 34 matching lines @@
   };
 
   for (int i = 0; i < 2; ++i) {
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
-    int rv = trans->Start(&request, &callback, BoundNetLog());
+    int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 19 matching lines @@
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 100 Continue\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
@@ skipping 19 matching lines @@
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n"
              "HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 14 matching lines @@
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead(false, "HTTP/1.0 100 Continue\r\n"),
     MockRead(true, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
 TEST_F(HttpNetworkTransactionTest, EmptyResponse) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead(true, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_EMPTY_RESPONSE, rv);
 }
 
 void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
     const MockWrite* write_failure,
     const MockRead* read_failure) {
   HttpRequestInfo request;
@@ skipping 39 matching lines @@
     MockRead(true, OK),
   };
   StaticSocketDataProvider data2(data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-    int rv = trans->Start(&request, &callback, BoundNetLog());
+    int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 32 matching lines @@
 
   MockRead data_reads[] = {
     MockRead(true, ERR_CONNECTION_RESET),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // What do various browsers do when the server closes a non-keepalive
@@ skipping 54 matching lines @@
   MockRead data2_reads[] = {
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
   StaticSocketDataProvider data2(data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const int kNumUnreadBodies = arraysize(data1_reads) - 2;
   std::string response_lines[kNumUnreadBodies];
 
   for (size_t i = 0; i < arraysize(data1_reads) - 2; ++i) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-    int rv = trans->Start(&request, &callback, BoundNetLog());
+    int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
     ASSERT_TRUE(response->headers != NULL);
     response_lines[i] = response->headers->GetStatusLine();
@@ skipping 10 matching lines @@
     "HTTP/1.1 301 Moved Permanently",
     "HTTP/1.1 301 Moved Permanently",
   };
 
   COMPILE_ASSERT(kNumUnreadBodies == arraysize(kStatusLines),
                  forgot_to_update_kStatusLines);
 
   for (int i = 0; i < kNumUnreadBodies; ++i)
     EXPECT_EQ(kStatusLines[i], response_lines[i]);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
@@ skipping 48 matching lines @@
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
@@ skipping 19 matching lines @@
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
     MockRead(false, ERR_FAILED),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
@@ skipping 41 matching lines @@
     MockRead(false, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
@@ skipping 39 matching lines @@
     MockRead(false, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
@@ skipping 47 matching lines @@
     MockRead(false, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
@@ skipping 49 matching lines @@
     MockRead("hello"),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
@@ skipping 46 matching lines @@
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead(false, "hello"),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
       entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_FALSE(response->headers == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(200, response->headers->response_code());
@@ skipping 53 matching lines @@
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
       entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_FALSE(response->headers == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
   // Wrong password (should be "bar").
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBaz), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBaz), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_FALSE(response->headers == NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 33 matching lines @@
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 32 matching lines @@
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
     MockRead(false, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_UNEXPECTED_PROXY_AUTH, rv);
 }
 
 // Tests when an HTTPS server (non-proxy) returns a 407 (proxy-authentication)
 // through a non-authenticating proxy. The request should fail with
 // ERR_UNEXPECTED_PROXY_AUTH.
 // Note that it is impossible to detect if an HTTP server returns a 407 through
@@ skipping 29 matching lines @@
     MockRead("\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_UNEXPECTED_PROXY_AUTH, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
@@ skipping 28 matching lines @@
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(200, response->headers->response_code());
@@ skipping 37 matching lines @@
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
@@ skipping 61 matching lines @@
       new OrderedSocketData(spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* const response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
 
   ASSERT_TRUE(response_restart != NULL);
   ASSERT_TRUE(response_restart->headers != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
@@ skipping 55 matching lines @@
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.was_npn_negotiated = false;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
@@ skipping 52 matching lines @@
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl2.next_proto = "spdy/2";
   ssl2.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
@@ skipping 44 matching lines @@
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl2.next_proto = "spdy/2";
   ssl2.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_EQ(500, response->headers->response_code());
 }
 
@@ skipping 40 matching lines @@
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_FALSE(response->headers == NULL);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(200, response->headers->response_code());
@@ skipping 27 matching lines @@
     status,
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(expected_status, rv);
 }
 
 void HttpNetworkTransactionTest::ConnectStatusHelper(const MockRead& status) {
   ConnectStatusHelperWithExpectedStatus(
       status, ERR_TUNNEL_CONNECTION_FAILED);
 }
@@ skipping 239 matching lines @@
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo2, kBar2), &callback3);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo2, kBar2), callback3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
@@ skipping 82 matching lines @@
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_FALSE(response == NULL);
   EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(AuthCredentials(kTestingNTLM, kTestingNTLM),
-                              &callback2);
+                              callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
 
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback3);
+  rv = trans->RestartWithAuth(AuthCredentials(), callback3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
@@ skipping 126 matching lines @@
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
   // Enter the wrong password.
   rv = trans->RestartWithAuth(AuthCredentials(kTestingNTLM, kWrongPassword),
-                              &callback2);
+                              callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
-  TestOldCompletionCallback callback3;
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback3);
+  TestCompletionCallback callback3;
+  rv = trans->RestartWithAuth(AuthCredentials(), callback3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   response = trans->GetResponseInfo();
   ASSERT_FALSE(response == NULL);
   EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback4;
+  TestCompletionCallback callback4;
 
   // Now enter the right password.
   rv = trans->RestartWithAuth(AuthCredentials(kTestingNTLM, kTestingNTLM),
-                              &callback4);
+                              callback4.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback4.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
 
-  TestOldCompletionCallback callback5;
+  TestCompletionCallback callback5;
 
   // One more roundtrip
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback5);
+  rv = trans->RestartWithAuth(AuthCredentials(), callback5.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback5.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 #endif  // NTLM_PORTABLE
@@ skipping 17 matching lines @@
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead(true, large_headers_string.data(), large_headers_string.size()),
     MockRead("\r\nBODY"),
     MockRead(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // Make sure that we don't try to reuse a TCPClientSocket when failing to
@@ skipping 25 matching lines @@
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
@@ skipping 26 matching lines @@
     // The rest of the response body is received in two parts.
     MockRead("lo"),
     MockRead(" world"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
@@ skipping 36 matching lines @@
     MockRead(false, OK),
   };
 
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   EXPECT_EQ(0, session->GetTransportSocketPool()->IdleSocketCount());
@@ skipping 42 matching lines @@
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   StaticSocketDataProvider data2(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   EXPECT_EQ(0, session->GetTransportSocketPool()->IdleSocketCount());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, session->GetSSLSocketPool()->IdleSocketCount());
 
   // Now start the second transaction, which should reuse the previous socket.
 
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   EXPECT_EQ(0, session->GetTransportSocketPool()->IdleSocketCount());
@@ skipping 30 matching lines @@
     MockRead("HTTP/1.1 204 No Content\r\n"
              "Content-Length: 0\r\n"
              "Content-Type: text/html\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
@@ skipping 73 matching lines @@
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello world", "welcome"
   };
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(session));
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
-    int rv = trans->Start(&request[i], &callback, BoundNetLog());
+    int rv = trans->Start(&request[i], callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 52 matching lines @@
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
-  TestOldCompletionCallback callback2;
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback2);
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(AuthCredentials(), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   // There is no challenge info, since the identity in URL worked.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
@@ skipping 67 matching lines @@
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
-  TestOldCompletionCallback callback2;
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback2);
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(AuthCredentials(), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback3;
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback3);
+  TestCompletionCallback callback3;
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   // There is no challenge info, since the identity worked.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
@@ skipping 46 matching lines @@
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-    TestOldCompletionCallback callback2;
+    TestCompletionCallback callback2;
 
-    rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+    rv = trans->RestartWithAuth(
+        AuthCredentials(kFoo, kBar), callback2.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback2.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
@@ skipping 43 matching lines @@
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     ASSERT_TRUE(response->auth_challenge.get());
     EXPECT_FALSE(response->auth_challenge->is_proxy);
     EXPECT_EQ("www.google.com:80",
               response->auth_challenge->challenger.ToString());
     EXPECT_EQ("MyRealm2", response->auth_challenge->realm);
     EXPECT_EQ("basic", response->auth_challenge->scheme);
 
-    TestOldCompletionCallback callback2;
+    TestCompletionCallback callback2;
 
-    rv = trans->RestartWithAuth(AuthCredentials(kFoo2, kBar2), &callback2);
+    rv = trans->RestartWithAuth(
+        AuthCredentials(kFoo2, kBar2), callback2.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback2.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
@@ skipping 23 matching lines @@
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
@@ skipping 39 matching lines @@
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
-    TestOldCompletionCallback callback2;
-    rv = trans->RestartWithAuth(AuthCredentials(), &callback2);
+    TestCompletionCallback callback2;
+    rv = trans->RestartWithAuth(AuthCredentials(), callback2.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
@@ skipping 58 matching lines @@
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                    data_writes3, arraysize(data_writes3));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
     session_deps.socket_factory.AddSocketDataProvider(&data3);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
-    TestOldCompletionCallback callback2;
-    rv = trans->RestartWithAuth(AuthCredentials(), &callback2);
+    TestCompletionCallback callback2;
+    rv = trans->RestartWithAuth(AuthCredentials(), callback2.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-    TestOldCompletionCallback callback3;
+    TestCompletionCallback callback3;
 
-    rv = trans->RestartWithAuth(AuthCredentials(kFoo3, kBar3), &callback3);
+    rv = trans->RestartWithAuth(
+        AuthCredentials(kFoo3, kBar3), callback3.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback3.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
@@ skipping 50 matching lines @@
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(CheckDigestServerAuth(response->auth_challenge.get()));
 
-    TestOldCompletionCallback callback2;
+    TestCompletionCallback callback2;
 
-    rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+    rv = trans->RestartWithAuth(
+        AuthCredentials(kFoo, kBar), callback2.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback2.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
   }
 
@@ skipping 26 matching lines @@
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-    TestOldCompletionCallback callback1;
+    TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1, BoundNetLog());
+    int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
   }
 }
@@ skipping 69 matching lines @@
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
   SSLSocketDataProvider ssl(true, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
-  rv = trans->RestartIgnoringLastError(&callback);
+  rv = trans->RestartIgnoringLastError(callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
@@ skipping 42 matching lines @@
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
   SSLSocketDataProvider ssl(true, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   for (int i = 0; i < 2; i++) {
     session_deps.socket_factory.ResetNextMockIndexes();
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-    int rv = trans->Start(&request, &callback, BoundNetLog());
+    int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
-    rv = trans->RestartIgnoringLastError(&callback);
+    rv = trans->RestartIgnoringLastError(callback.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
 
     ASSERT_TRUE(response != NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
@@ skipping 29 matching lines @@
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
   SSLSocketDataProvider tunnel_ssl(true, OK);  // SSL through the tunnel
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
   session_deps.socket_factory.AddSSLSocketDataProvider(&tunnel_ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(200, response->headers->response_code());
@@ skipping 24 matching lines @@
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_EQ(302, response->headers->response_code());
   std::string url;
@@ skipping 35 matching lines @@
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
   proxy_ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   proxy_ssl.next_proto = "spdy/2";
   proxy_ssl.was_npn_negotiated = true;
 
   session_deps.socket_factory.AddSocketDataProvider(data.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_EQ(302, response->headers->response_code());
   std::string url;
@@ skipping 24 matching lines @@
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_EQ(404, response->headers->response_code());
   EXPECT_EQ(23, response->headers->GetContentLength());
@@ skipping 43 matching lines @@
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
   proxy_ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   proxy_ssl.next_proto = "spdy/2";
   proxy_ssl.was_npn_negotiated = true;
 
   session_deps.socket_factory.AddSocketDataProvider(data.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_EQ(404, response->headers->response_code());
   EXPECT_FALSE(response->ssl_info.is_valid());
@@ skipping 55 matching lines @@
   // SSL to the proxy, then CONNECT request, then SSL with bad certificate
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
 
   // SSL to the proxy, then CONNECT request, then valid SSL certificate
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
-  rv = trans->RestartIgnoringLastError(&callback);
+  rv = trans->RestartIgnoringLastError(callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
@@ skipping 21 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_UserAgentOverTunnel) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
@@ skipping 15 matching lines @@
     // interested in the rest).
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Proxy-Connection: close\r\n\r\n"),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_Referer) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 17 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
@@ skipping 14 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) {
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL("http://www.google.com/");
@@ skipping 14 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) {
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
@@ skipping 14 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 16 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest,
        BuildRequest_CacheControlValidateCache) {
   HttpRequestInfo request;
   request.method = "GET";
@@ skipping 16 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 15 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeadersStripped) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 19 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
@@ skipping 20 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 33 matching lines @@
     MockRead(false, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 42 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 47 matching lines @@
     MockRead(false, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 26 matching lines @@
 int GroupNameTransactionHelper(
     const std::string& url,
     const scoped_refptr<HttpNetworkSession>& session) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(url);
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   // We do not complete this request, the dtor will clean the transaction up.
-  return trans->Start(&request, &callback, BoundNetLog());
+  return trans->Start(&request, callback.callback(), BoundNetLog());
 }
 
 TEST_F(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
   const GroupNameTest tests[] = {
     {
       "",  // unused
       "http://www.google.com/direct",
       "www.google.com:80",
       false,
     },
@@ skipping 199 matching lines @@
   SessionDependencies session_deps(
       ProxyService::CreateFixed("myproxy:70;foobar:80"));
 
   // This simulates failure resolving all hostnames; that means we will fail
   // connecting to both proxies (myproxy:70 and foobar:80).
   session_deps.host_resolver->rules()->AddSimulatedFailure("*");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
 }
 
 // Base test to make sure that when the load flags for a request specify to
 // bypass the cache, the DNS cache is not used.
 void BypassHostCacheOnRefreshHelper(int load_flags) {
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = load_flags;
   request.url = GURL("http://www.google.com/");
 
   SessionDependencies session_deps;
 
   // Select a host resolver that does caching.
   session_deps.host_resolver.reset(new MockCachingHostResolver);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(&session_deps)));
 
   // Warm up the host cache so it has an entry for "www.google.com".
   AddressList addrlist;
   TestCompletionCallback callback;
-  TestOldCompletionCallback old_callback;
   int rv = session_deps.host_resolver->Resolve(
       HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist,
       callback.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that it was added to host cache, by doing a subsequent async lookup
   // and confirming it completes synchronously.
   rv = session_deps.host_resolver->Resolve(
       HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), &addrlist,
       callback.callback(), NULL, BoundNetLog());
   ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
   // we can tell if the next lookup hit the cache, or the "network".
   // (cache --> success, "network" --> failure).
   session_deps.host_resolver->rules()->AddSimulatedFailure("www.google.com");
 
   // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
   // first read -- this won't be reached as the host resolution will fail first.
   MockRead data_reads[] = { MockRead(false, ERR_UNEXPECTED) };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Run the request.
-  rv = trans->Start(&request, &old_callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
-  rv = old_callback.WaitForResult();
+  rv = callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 // There are multiple load flags that should trigger the host cache bypass.
 // Test each in isolation:
 TEST_F(HttpNetworkTransactionTest, BypassHostCacheOnRefresh1) {
   BypassHostCacheOnRefreshHelper(LOAD_BYPASS_CACHE);
@@ skipping 17 matching lines @@
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockWrite write_failure[] = {
     MockWrite(true, ERR_CONNECTION_RESET),
   };
   StaticSocketDataProvider data(NULL, 0,
                                 write_failure, arraysize(write_failure));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 }
 
 // Check that a connection closed after the start of the headers finishes ok.
 TEST_F(HttpNetworkTransactionTest, ConnectionClosedAfterStartOfHeaders) {
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1."),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
@@ skipping 48 matching lines @@
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
@@ skipping 11 matching lines @@
     MockRead("HTTP/1.0 200 Connected\r\n\r\nExtra data"),
     MockRead(false, OK)
   };
 
   StaticSocketDataProvider data(proxy_reads, arraysize(proxy_reads), NULL, 0);
   SSLSocketDataProvider ssl(true, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   session_deps.socket_factory.ResetNextMockIndexes();
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, LargeContentLengthThenClose) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\nContent-Length:6719476739\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
@@ skipping 26 matching lines @@
   EXPECT_EQ(kFakeSize, request.upload_data->GetContentLength());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
@@ skipping 40 matching lines @@
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
     MockWrite(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
@@ skipping 45 matching lines @@
               "Connection: keep-alive\r\n"
               "Content-Length: 16\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     MockWrite(false, unreadable_contents.c_str(), temp_file_contents.length()),
     MockWrite(false, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 401 Unauthorized", response->headers->GetStatusLine());
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
   // Now make the file unreadable and try again.
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
 
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback2);
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 77 matching lines @@
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   StaticSocketDataProvider data4(data_reads4, arraysize(data_reads4),
                                  data_writes4, arraysize(data_writes4));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
   session_deps.socket_factory.AddSocketDataProvider(&data4);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   // Issue the first request with Authorize headers. There should be a
   // password prompt for first_realm waiting to be filled in after the
   // transaction completes.
-  int rv = trans->Start(&request, &callback1, BoundNetLog());
+  int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   const AuthChallengeInfo* challenge = response->auth_challenge.get();
   ASSERT_FALSE(challenge == NULL);
   EXPECT_FALSE(challenge->is_proxy);
   EXPECT_EQ("www.google.com:80", challenge->challenger.ToString());
   EXPECT_EQ("first_realm", challenge->realm);
   EXPECT_EQ("basic", challenge->scheme);
 
   // Issue the second request with an incorrect password. There should be a
   // password prompt for second_realm waiting to be filled in after the
   // transaction completes.
-  TestOldCompletionCallback callback2;
-  rv = trans->RestartWithAuth(AuthCredentials(kFirst, kBaz), &callback2);
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFirst, kBaz), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   challenge = response->auth_challenge.get();
   ASSERT_FALSE(challenge == NULL);
   EXPECT_FALSE(challenge->is_proxy);
   EXPECT_EQ("www.google.com:80", challenge->challenger.ToString());
   EXPECT_EQ("second_realm", challenge->realm);
   EXPECT_EQ("basic", challenge->scheme);
 
   // Issue the third request with another incorrect password. There should be
   // a password prompt for first_realm waiting to be filled in. If the password
   // prompt is not present, it indicates that the HttpAuthCacheEntry for
   // first_realm was not correctly removed.
-  TestOldCompletionCallback callback3;
-  rv = trans->RestartWithAuth(AuthCredentials(kSecond, kFou), &callback3);
+  TestCompletionCallback callback3;
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kSecond, kFou), callback3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   challenge = response->auth_challenge.get();
   ASSERT_FALSE(challenge == NULL);
   EXPECT_FALSE(challenge->is_proxy);
   EXPECT_EQ("www.google.com:80", challenge->challenger.ToString());
   EXPECT_EQ("first_realm", challenge->realm);
   EXPECT_EQ("basic", challenge->scheme);
 
   // Issue the fourth request with the correct password and username.
-  TestOldCompletionCallback callback4;
-  rv = trans->RestartWithAuth(AuthCredentials(kFirst, kBar), &callback4);
+  TestCompletionCallback callback4;
+  rv = trans->RestartWithAuth(
+      AuthCredentials(kFirst, kBar), callback4.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback4.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 TEST_F(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
   HttpStreamFactory::set_next_protos(MakeNextProtos("foo", "bar", NULL));
@@ skipping 10 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   HostPortPair http_host_port_pair("www.google.com", 80);
   const HttpServerProperties& http_server_properties =
       *session->http_server_properties();
   EXPECT_FALSE(
       http_server_properties.HasAlternateProtocol(http_host_port_pair));
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 48 matching lines @@
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   // Port must be < 1024, or the header will be ignored (since initial port was
   // port 80 (another restricted port).
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(request.url),
       666 /* port is ignored by MockConnect anyway */,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
@@ skipping 39 matching lines @@
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(restricted_port_request.url),
       kUnrestrictedAlternatePort,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&restricted_port_request, &callback, BoundNetLog());
+  int rv = trans->Start(
+      &restricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Invalid change to unrestricted port should fail.
   EXPECT_EQ(ERR_CONNECTION_REFUSED, callback.WaitForResult());
 
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortRestrictedAllowed) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
@@ skipping 25 matching lines @@
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(restricted_port_request.url),
       kRestrictedAlternatePort,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&restricted_port_request, &callback, BoundNetLog());
+  int rv = trans->Start(
+      &restricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed1) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
@@ skipping 25 matching lines @@
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(unrestricted_port_request.url),
       kRestrictedAlternatePort,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&unrestricted_port_request, &callback, BoundNetLog());
+  int rv = trans->Start(
+      &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed2) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
@@ skipping 25 matching lines @@
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(unrestricted_port_request.url),
       kUnrestrictedAlternatePort,
       NPN_SPDY_2);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&unrestricted_port_request, &callback, BoundNetLog());
+  int rv = trans->Start(
+      &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to an unrestricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::set_next_protos(SpdyNextProtos());
@@ skipping 40 matching lines @@
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
@@ skipping 64 matching lines @@
           2,  // wait for writes to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   // Socket 4 is the successful Alternate-Protocol for transaction 3.
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   // Socket 5 is the unsuccessful non-Alternate-Protocol for transaction 3.
   session_deps.socket_factory.AddSocketDataProvider(&hanging_socket);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   HttpNetworkTransaction trans1(session);
 
-  int rv = trans1.Start(&request, &callback1, BoundNetLog());
+  int rv = trans1.Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback1.WaitForResult());
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(&trans1, &response_data));
   EXPECT_EQ("hello world", response_data);
 
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   HttpNetworkTransaction trans2(session);
-  rv = trans2.Start(&request, &callback2, BoundNetLog());
+  rv = trans2.Start(&request, callback2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   HttpNetworkTransaction trans3(session);
-  rv = trans3.Start(&request, &callback3, BoundNetLog());
+  rv = trans3.Start(&request, callback3.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
@@ skipping 45 matching lines @@
   StaticSocketDataProvider hanging_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_alternate_protocol_socket);
 
   // 2nd request is just a copy of the first one, over HTTP again.
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
 
@@ skipping 115 matching lines @@
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
@@ skipping 50 matching lines @@
     MockRead(true, 0, 0),
   };
 
   scoped_refptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
-  TestOldCompletionCallback callback_old;
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback_old, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback_old.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
@@ skipping 25 matching lines @@
       NULL /* ssl_host_info */, context));
   EXPECT_EQ(ERR_IO_PENDING,
             ssl_connection->socket()->Connect(callback.callback()));
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(OK, spdy_session->InitializeWithSocket(ssl_connection.release(),
                                                    true, OK));
 
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request, &callback_old, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback_old.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
@@ skipping 379 matching lines @@
           reads, length_reads, writes, length_writes);
       session_deps.socket_factory.AddSocketDataProvider(&data_provider);
 
       // Add an SSL sequence if necessary.
       SSLSocketDataProvider ssl_socket_data_provider(false, OK);
       if (round >= test_config.first_ssl_round)
         session_deps.socket_factory.AddSSLSocketDataProvider(
             &ssl_socket_data_provider);
 
       // Start or restart the transaction.
-      TestOldCompletionCallback callback;
+      TestCompletionCallback callback;
       int rv;
       if (round == 0) {
-        rv = trans.Start(&request, &callback, BoundNetLog());
+        rv = trans.Start(&request, callback.callback(), BoundNetLog());
       } else {
-        rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBar), &callback);
+        rv = trans.RestartWithAuth(
+            AuthCredentials(kFoo, kBar), callback.callback());
       }
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
 
       // Compare results with expected data.
       EXPECT_EQ(read_write_round.expected_rv, rv);
       const HttpResponseInfo* response = trans.GetResponseInfo();
       if (read_write_round.expected_rv == OK) {
         ASSERT_TRUE(response != NULL);
       } else {
@@ skipping 50 matching lines @@
       &transport_pool_histograms,
       session_deps.host_resolver.get(),
       &session_deps.socket_factory,
       session_deps.net_log);
   MockClientSocketPoolManager* mock_pool_manager =
       new MockClientSocketPoolManager;
   mock_pool_manager->SetTransportSocketPool(transport_pool);
   session_peer.SetClientSocketPoolManager(mock_pool_manager);
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   const MockWrite kGet(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n\r\n");
   const MockWrite kGetAuth(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n"
       "Authorization: auth_token\r\n\r\n");
@@ skipping 35 matching lines @@
     kSuccess,
   };
   StaticSocketDataProvider data_provider(reads, arraysize(reads),
                                          writes, arraysize(writes));
   session_deps.socket_factory.AddSocketDataProvider(&data_provider);
 
   const char* const kSocketGroup = "www.example.com:80";
 
   // First round of authentication.
   auth_handler->SetGenerateExpectation(false, OK);
-  rv = trans->Start(&request, &callback, BoundNetLog());
+  rv = trans->Start(&request, callback.callback(), BoundNetLog());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // In between rounds, another request comes in for the same domain.
   // It should not be able to grab the TCP socket that trans has already
   // claimed.
   scoped_ptr<HttpTransaction> trans_compete(
       new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback_compete;
-  rv = trans_compete->Start(&request, &callback_compete, BoundNetLog());
+  TestCompletionCallback callback_compete;
+  rv = trans_compete->Start(
+      &request, callback_compete.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // callback_compete.WaitForResult at this point would stall forever,
   // since the HttpNetworkTransaction does not release the request back to
   // the pool until after authentication completes.
 
   // Second round of authentication.
   auth_handler->SetGenerateExpectation(false, OK);
-  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback);
+  rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Third round of authentication.
   auth_handler->SetGenerateExpectation(false, OK);
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback);
+  rv = trans->RestartWithAuth(AuthCredentials(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Fourth round of authentication, which completes successfully.
   auth_handler->SetGenerateExpectation(false, OK);
-  rv = trans->RestartWithAuth(AuthCredentials(), &callback);
+  rv = trans->RestartWithAuth(AuthCredentials(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Read the body since the fourth round was successful. This will also
   // release the socket back to the pool.
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(50));
-  rv = trans->Read(io_buf, io_buf->size(), &callback);
+  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans->Read(io_buf, io_buf->size(), &callback);
+  rv = trans->Read(io_buf, io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
   // There are still 0 idle sockets, since the trans_compete transaction
   // will be handed it immediately after trans releases it to the group.
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // The competing request can now finish. Wait for the headers and then
   // read the body.
   rv = callback_compete.WaitForResult();
   EXPECT_EQ(OK, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), &callback);
+  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(3, rv);
-  rv = trans_compete->Read(io_buf, io_buf->size(), &callback);
+  rv = trans_compete->Read(io_buf, io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
   EXPECT_EQ(1, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 }
 
 class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
  public:
   explicit TLSDecompressionFailureSocketDataProvider(bool fail_all)
       : fail_all_(fail_all) {
@@ skipping 41 matching lines @@
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider2);
 
   // Work around http://crbug.com/37454
   StaticSocketDataProvider bug37454_connection;
   bug37454_connection.set_connect_data(MockConnect(true, ERR_UNEXPECTED));
   session_deps.socket_factory.AddSocketDataProvider(&bug37454_connection);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
@@ skipping 19 matching lines @@
   SSLSocketDataProvider ssl_socket_data_provider2(false, OK);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider1);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider2);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider1);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider2);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
@@ skipping 28 matching lines @@
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "http/1.1";
 
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
@@ skipping 33 matching lines @@
     MockRead(false, 0, 0)   // Not async - return 0 immediately.
   };
 
   scoped_refptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           0,  // don't wait in this case, immediate hangup.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
   // This test ensures that the URL passed into the proxy is upgraded
   // to https when doing an Alternate Protocol upgrade.
@@ skipping 106 matching lines @@
       never_finishing_connect);
 
   session_deps.socket_factory.AddSocketDataProvider(&data_1);
   session_deps.socket_factory.AddSocketDataProvider(data_2.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   // First round should work and provide the Alternate-Protocol state.
-  TestOldCompletionCallback callback_1;
+  TestCompletionCallback callback_1;
   scoped_ptr<HttpTransaction> trans_1(new HttpNetworkTransaction(session));
-  int rv = trans_1->Start(&request, &callback_1, BoundNetLog());
+  int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_1.WaitForResult());
 
   // Second round should attempt a tunnel connect and get an auth challenge.
-  TestOldCompletionCallback callback_2;
+  TestCompletionCallback callback_2;
   scoped_ptr<HttpTransaction> trans_2(new HttpNetworkTransaction(session));
-  rv = trans_2->Start(&request, &callback_2, BoundNetLog());
+  rv = trans_2->Start(&request, callback_2.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_2.WaitForResult());
   const HttpResponseInfo* response = trans_2->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_FALSE(response->auth_challenge.get() == NULL);
 
   // Restart with auth. Tunnel should work and response received.
-  TestOldCompletionCallback callback_3;
-  rv = trans_2->RestartWithAuth(AuthCredentials(kFoo, kBar), &callback_3);
+  TestCompletionCallback callback_3;
+  rv = trans_2->RestartWithAuth(
+      AuthCredentials(kFoo, kBar), callback_3.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback_3.WaitForResult());
 
   // After all that work, these two lines (or actually, just the scheme) are
   // what this test is all about. Make sure it happens correctly.
   const GURL& request_url = auth_handler->request_url();
   EXPECT_EQ("https", request_url.scheme());
   EXPECT_EQ("www.google.com", request_url.host());
 
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
@@ skipping 22 matching lines @@
 
   SessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  int rv = trans->Start(&request, &callback, log.bound());
+  int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   trans.reset();  // Cancel the transaction here.
 
   MessageLoop::current()->RunAllPending();
 }
 
 // Test a basic GET request through a proxy.
 TEST_F(HttpNetworkTransactionTest, ProxyGet) {
   SessionDependencies session_deps(ProxyService::CreateFixed("myproxy:70"));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
@@ skipping 14 matching lines @@
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(200, response->headers->response_code());
@@ skipping 32 matching lines @@
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
@@ skipping 39 matching lines @@
     MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
     MockRead(true, 0, 0),  // EOF
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(true, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &callback1, log.bound());
+  int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_EMPTY_RESPONSE, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
@@ skipping 33 matching lines @@
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.google.com", 443);
   HostPortProxyPair pair(host_port_pair, ProxyServer::Direct());
   scoped_refptr<SpdySession> spdy_session =
       session->spdy_session_pool()->Get(pair, BoundNetLog());
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(host_port_pair, MEDIUM, false, false));
-  TestOldCompletionCallback old_callback;
   TestCompletionCallback callback;
 
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(ERR_IO_PENDING,
             connection->Init(host_port_pair.ToString(), transport_params,
                              LOWEST, callback.callback(),
                              session->GetTransportSocketPool(), BoundNetLog()));
   EXPECT_EQ(OK, callback.WaitForResult());
   spdy_session->InitializeWithSocket(connection.release(), false, OK);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // This is the important line that marks this as a preconnect.
   request.motivation = HttpRequestInfo::PRECONNECT_MOTIVATED;
 
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request, &old_callback, BoundNetLog());
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, old_callback.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Given a net error, cause that error to be returned from the first Write()
 // call and verify that the HttpTransaction fails with that error.
 static void CheckErrorIsPassedBack(int error, bool async) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   SessionDependencies session_deps;
 
   SSLSocketDataProvider ssl_data(async, OK);
   net::MockWrite data_writes[] = {
     net::MockWrite(async, error),
   };
   net::StaticSocketDataProvider data(NULL, 0,
                                      data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&request_info, &callback, net::BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(error, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, SSLWriteCertError) {
   // Just check a grab bag of cert errors.
   static const int kErrors[] = {
     ERR_CERT_COMMON_NAME_INVALID,
     ERR_CERT_AUTHORITY_INVALID,
@@ skipping 56 matching lines @@
                                   net::ERR_SSL_PROTOCOL_ERROR);
   ssl_data3.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data3);
   net::StaticSocketDataProvider data3(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   // Begin the SSL handshake with the peer. This consumes ssl_data1.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&request_info, &callback, net::BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
   // Complete the SSL handshake, which should abort due to requiring a
   // client certificate.
   rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
 
   // Indicate that no certificate should be supplied. From the perspective
   // of SSLClientCertCache, NULL is just as meaningful as a real
   // certificate, so this is the same as supply a
   // legitimate-but-unacceptable certificate.
-  rv = trans->RestartWithCertificate(NULL, &callback);
+  rv = trans->RestartWithCertificate(NULL, callback.callback());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
   // Ensure the certificate was added to the client auth cache before
   // allowing the connection to continue restarting.
   scoped_refptr<X509Certificate> client_cert;
   ASSERT_TRUE(session->ssl_client_auth_cache()->Lookup("www.example.com:443",
                                                        &client_cert));
   ASSERT_EQ(NULL, client_cert.get());
 
   // Restart the handshake. This will consume ssl_data2, which fails, and
@@ skipping 71 matching lines @@
   ssl_data3.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data3);
   net::StaticSocketDataProvider data3(
       data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   // Begin the initial SSL handshake.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&request_info, &callback, net::BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
   // Complete the SSL handshake, which should abort due to requiring a
   // client certificate.
   rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
 
   // Indicate that no certificate should be supplied. From the perspective
   // of SSLClientCertCache, NULL is just as meaningful as a real
   // certificate, so this is the same as supply a
   // legitimate-but-unacceptable certificate.
-  rv = trans->RestartWithCertificate(NULL, &callback);
+  rv = trans->RestartWithCertificate(NULL, callback.callback());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
   // Ensure the certificate was added to the client auth cache before
   // allowing the connection to continue restarting.
   scoped_refptr<X509Certificate> client_cert;
   ASSERT_TRUE(session->ssl_client_auth_cache()->Lookup("www.example.com:443",
                                                        &client_cert));
   ASSERT_EQ(NULL, client_cert.get());
 
 
@@ skipping 60 matching lines @@
   requests[1].method = "GET";
   requests[1].load_flags = net::LOAD_NORMAL;
 
   for (size_t i = 0; i < arraysize(requests); ++i) {
     session_deps.socket_factory.ResetNextMockIndexes();
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     scoped_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(session));
 
     // Begin the SSL handshake with the proxy.
-    TestOldCompletionCallback callback;
-    int rv = trans->Start(&requests[i], &callback, net::BoundNetLog());
+    TestCompletionCallback callback;
+    int rv = trans->Start(
+        &requests[i], callback.callback(), net::BoundNetLog());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
     // Complete the SSL handshake, which should abort due to requiring a
     // client certificate.
     rv = callback.WaitForResult();
     ASSERT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
 
     // Indicate that no certificate should be supplied. From the perspective
     // of SSLClientCertCache, NULL is just as meaningful as a real
     // certificate, so this is the same as supply a
     // legitimate-but-unacceptable certificate.
-    rv = trans->RestartWithCertificate(NULL, &callback);
+    rv = trans->RestartWithCertificate(NULL, callback.callback());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
     // Ensure the certificate was added to the client auth cache before
     // allowing the connection to continue restarting.
     scoped_refptr<X509Certificate> client_cert;
     ASSERT_TRUE(session->ssl_client_auth_cache()->Lookup("proxy:70",
                                                          &client_cert));
     ASSERT_EQ(NULL, client_cert.get());
     // Ensure the certificate was NOT cached for the endpoint. This only
     // applies to HTTPS requests, but is fine to check for HTTP requests.
@@ skipping 95 matching lines @@
     MockRead(true, 0, 7),
   };
 
   scoped_refptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   TestCompletionCallback callback;
-  TestOldCompletionCallback old_callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
-  int rv = trans1.Start(&request1, &old_callback, BoundNetLog());
+  int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, old_callback.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(&trans1, &response_data));
   EXPECT_EQ("hello!", response_data);
 
@@ skipping 12 matching lines @@
   // (www.google.com, 443).
   IPPoolingAddAlias(&host_resolver, &pool_peer, "www.google.com", 443,
                     "127.0.0.1");
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(session);
 
-  rv = trans2.Start(&request2, &old_callback, BoundNetLog());
+  rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, old_callback.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
@@ skipping 95 matching lines @@
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
-  TestOldCompletionCallback old_callback;
-  int rv = trans1.Start(&request1, &old_callback, BoundNetLog());
+  int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, old_callback.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans1.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(&trans1, &response_data));
   EXPECT_EQ("hello!", response_data);
 
@@ skipping 11 matching lines @@
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(session);
 
   // MockHostResolver returns 127.0.0.1, port 443 for https://www.google.com/
   // and https://www.gmail.com/. Add 127.0.0.1 as alias for host_port_pair:
   // (www.google.com, 443).
   IPPoolingAddAlias(host_resolver.GetMockHostResolver(), &pool_peer,
                     "www.google.com", 443, "127.0.0.1");
 
-  rv = trans2.Start(&request2, &old_callback, BoundNetLog());
+  rv = trans2.Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, old_callback.WaitForResult());
+  EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
@@ skipping 131 matching lines @@
   StaticSocketDataProvider http_data(http_read, arraysize(http_read),
                                      http_write, arraysize(http_write));
   session_deps.socket_factory.AddSocketDataProvider(&http_data);
 
   HostPortPair host_port_pair_a("www.a.com", 443);
   HostPortProxyPair host_port_proxy_pair_a(
       host_port_pair_a, ProxyServer::Direct());
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.a.com/");
   request1.load_flags = 0;
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
-  int rv = trans->Start(&request1, &callback, BoundNetLog());
+  int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
   trans.reset();
   EXPECT_TRUE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
 
   HostPortPair host_port_pair_b("www.b.com", 443);
   HostPortProxyPair host_port_proxy_pair_b(
       host_port_pair_b, ProxyServer::Direct());
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.b.com/");
   request2.load_flags = 0;
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request2, &callback, BoundNetLog());
+  rv = trans->Start(&request2, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
   EXPECT_TRUE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
 
   HostPortPair host_port_pair_a1("www.a.com", 80);
   HostPortProxyPair host_port_proxy_pair_a1(
       host_port_pair_a1, ProxyServer::Direct());
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_a1));
   HttpRequestInfo request3;
   request3.method = "GET";
   request3.url = GURL("http://www.a.com/");
   request3.load_flags = 0;
   trans.reset(new HttpNetworkTransaction(session));
 
-  rv = trans->Start(&request3, &callback, BoundNetLog());
+  rv = trans->Start(&request3, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
 
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
   ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool);
   ClientSocketPoolManager::set_max_sockets_per_proxy_server(
       old_max_sockets_per_proxy_server);
   ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group);
 }
 
 }  // namespace net