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

net/spdy/spdy_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 <string>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util.h"
@@ skipping 30 matching lines @@
     int rv;
     std::string status_line;
     std::string response_data;
     HttpResponseInfo response_info;
   };
 
   void EnableCompression(bool enabled) {
     spdy::SpdyFramer::set_enable_compression_default(enabled);
   }
 
-  class StartTransactionCallback;
-  class DeleteSessionCallback;
-
   // A helper class that handles all the initial npn/ssl setup.
   class NormalSpdyTransactionHelper {
    public:
     NormalSpdyTransactionHelper(const HttpRequestInfo& request,
                                 const BoundNetLog& log,
                                 SpdyNetworkTransactionTestTypes test_type)
         : request_(request),
           session_deps_(new SpdySessionDependencies()),
           session_(SpdySessionDependencies::SpdyCreateSession(
               session_deps_.get())),
@@ skipping 70 matching lines @@
         default:
           NOTREACHED();
       }
 
       // We're now ready to use SSL-npn SPDY.
       trans_.reset(new HttpNetworkTransaction(session_));
     }
 
     // Start the transaction, read some data, finish.
     void RunDefaultTest() {
-      output_.rv = trans_->Start(&request_, &callback, log_);
+      output_.rv = trans_->Start(&request_, callback.callback(), log_);
 
       // We expect an IO Pending or some sort of error.
       EXPECT_LT(output_.rv, 0);
       if (output_.rv != ERR_IO_PENDING)
         return;
 
       output_.rv = callback.WaitForResult();
       if (output_.rv != OK) {
         session_->spdy_session_pool()->CloseCurrentSessions();
         return;
@@ skipping 153 matching lines @@
     typedef std::vector<linked_ptr<SSLSocketDataProvider> > SSLVector;
     typedef std::vector<linked_ptr<StaticSocketDataProvider> > AlternateVector;
     typedef std::vector<scoped_refptr<DeterministicSocketData> >
         AlternateDeterministicVector;
     HttpRequestInfo request_;
     scoped_ptr<SpdySessionDependencies> session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     scoped_ptr<StaticSocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
     AlternateVector alternate_vector_;
     AlternateDeterministicVector alternate_deterministic_vector_;
     const BoundNetLog& log_;
     SpdyNetworkTransactionTestTypes test_type_;
     int port_;
     bool deterministic_;
     bool spdy_enabled_;
@@ skipping 63 matching lines @@
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
   int ReadResult(HttpNetworkTransaction* trans,
                  StaticSocketDataProvider* data,
                  std::string* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
     scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
     while (true) {
-      int rv = trans->Read(buf, kSize, &callback);
+      int rv = trans->Read(buf, kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         // Multiple transactions may be in the data set.  Keep pulling off
         // reads until we complete our callback.
         while (!callback.have_result()) {
           data->CompleteRead();
           MessageLoop::current()->RunAllPending();
         }
         rv = callback.WaitForResult();
       } else if (rv <= 0) {
         break;
@@ skipping 27 matching lines @@
                          HttpResponseInfo* push_response,
                          std::string& expected) {
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
-    TestOldCompletionCallback callback;
-    int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+    TestCompletionCallback callback;
+    int rv = trans->Start(
+        &CreateGetRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback.WaitForResult();
 
     // Request the pushed path.
     scoped_ptr<HttpNetworkTransaction> trans2(
         new HttpNetworkTransaction(helper.session()));
-    rv = trans2->Start(&CreateGetPushRequest(), &callback, BoundNetLog());
+    rv = trans2->Start(
+        &CreateGetPushRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     MessageLoop::current()->RunAllPending();
 
     // The data for the pushed path may be coming in more than 1 packet. Compile
     // the results into a single string.
 
     // Read the server push body.
     std::string result2;
     ReadResult(trans2.get(), data, &result2);
     // Read the response body.
@@ skipping 11 matching lines @@
                                             << expected;
 
     // Verify the SYN_REPLY.
     // Copy the response info, because trans goes away.
     *response = *trans->GetResponseInfo();
     *push_response = *trans2->GetResponseInfo();
 
     VerifyStreamsClosed(helper);
   }
 
+  static void DeleteSessionCallback(NormalSpdyTransactionHelper* helper,
+                                    int result) {
+    helper->ResetTrans();
+  }
+
+  static void StartTransactionCallback(
+      const scoped_refptr<HttpNetworkSession>& session,
+      int result) {
+    scoped_ptr<HttpNetworkTransaction> trans(
+        new HttpNetworkTransaction(session));
+    TestCompletionCallback callback;
+    HttpRequestInfo request;
+    request.method = "GET";
+    request.url = GURL("http://www.google.com/");
+    request.load_flags = 0;
+    int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+    callback.WaitForResult();
+  }
+
  private:
   bool google_get_request_initialized_;
   bool google_post_request_initialized_;
   bool google_chunked_post_request_initialized_;
   HttpRequestInfo google_get_request_;
   HttpRequestInfo google_post_request_;
   HttpRequestInfo google_chunked_post_request_;
   HttpRequestInfo google_get_push_request_;
 };
 
@@ skipping 152 matching lines @@
   // there needs to be three sets of SSL connection data.
   helper.AddData(data_placeholder.get());
   helper.AddData(data_placeholder.get());
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans3(
       new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
-  out.rv = trans1->Start(&httpreq1, &callback1, log);
+  out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans2->Start(&httpreq2, &callback2, log);
+  out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans3->Start(&httpreq3, &callback3, log);
+  out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
@@ skipping 52 matching lines @@
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because two get requests are sent out, so
   // there needs to be two sets of SSL connection data.
   helper.AddData(data_placeholder.get());
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
 
-  out.rv = trans1->Start(&httpreq1, &callback1, log);
+  out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans2->Start(&httpreq2, &callback2, log);
+  out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
@@ skipping 60 matching lines @@
   // We require placeholder data because 3 connections are attempted (first is
   // the preconnect, 2nd and 3rd are the never finished connections.
   helper.AddData(data_placeholder.get());
   helper.AddData(data_placeholder.get());
 
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
 
   HttpRequestInfo httpreq = CreateGetRequest();
 
   // Preconnect the first.
   SSLConfig preconnect_ssl_config;
   helper.session()->ssl_config_service()->GetSSLConfig(&preconnect_ssl_config);
   HttpStreamFactory* http_stream_factory =
       helper.session()->http_stream_factory();
   if (http_stream_factory->has_next_protos()) {
     preconnect_ssl_config.next_protos = http_stream_factory->next_protos();
   }
 
   http_stream_factory->PreconnectStreams(
       1, httpreq, preconnect_ssl_config, preconnect_ssl_config, log);
 
-  out.rv = trans1->Start(&httpreq, &callback1, log);
+  out.rv = trans1->Start(&httpreq, callback1.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans2->Start(&httpreq, &callback2, log);
+  out.rv = trans2->Start(&httpreq, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
@@ skipping 85 matching lines @@
     // there needs to be three sets of SSL connection data.
     helper.AddData(data_placeholder.get());
     helper.AddData(data_placeholder.get());
     scoped_ptr<HttpNetworkTransaction> trans1(
         new HttpNetworkTransaction(helper.session()));
     scoped_ptr<HttpNetworkTransaction> trans2(
         new HttpNetworkTransaction(helper.session()));
     scoped_ptr<HttpNetworkTransaction> trans3(
         new HttpNetworkTransaction(helper.session()));
 
-    TestOldCompletionCallback callback1;
-    TestOldCompletionCallback callback2;
-    TestOldCompletionCallback callback3;
+    TestCompletionCallback callback1;
+    TestCompletionCallback callback2;
+    TestCompletionCallback callback3;
 
     HttpRequestInfo httpreq1 = CreateGetRequest();
     HttpRequestInfo httpreq2 = CreateGetRequest();
     HttpRequestInfo httpreq3 = CreateGetRequest();
 
-    out.rv = trans1->Start(&httpreq1, &callback1, log);
+    out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     // run transaction 1 through quickly to force a read of our SETTINGS
     // frame
     out.rv = callback1.WaitForResult();
     ASSERT_EQ(OK, out.rv);
 
-    out.rv = trans2->Start(&httpreq2, &callback2, log);
+    out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
-    out.rv = trans3->Start(&httpreq3, &callback3, log);
+    out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     out.rv = callback2.WaitForResult();
     ASSERT_EQ(OK, out.rv);
     EXPECT_EQ(7U, data->read_index());  // i.e. the third trans was queued
 
     out.rv = callback3.WaitForResult();
     ASSERT_EQ(OK, out.rv);
 
     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
     ASSERT_TRUE(response1 != NULL);
@@ skipping 104 matching lines @@
   helper.AddData(data_placeholder.get());
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans3(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans4(
       new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
-  TestOldCompletionCallback callback3;
-  TestOldCompletionCallback callback4;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+  TestCompletionCallback callback4;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
   HttpRequestInfo httpreq4 = CreateGetRequest();
   httpreq4.priority = HIGHEST;
 
-  out.rv = trans1->Start(&httpreq1, &callback1, log);
+  out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
   // run transaction 1 through quickly to force a read of our SETTINGS
   // frame
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
-  out.rv = trans2->Start(&httpreq2, &callback2, log);
+  out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans3->Start(&httpreq3, &callback3, log);
+  out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
-  out.rv = trans4->Start(&httpreq4, &callback4, log);
+  out.rv = trans4->Start(&httpreq4, callback4.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
   EXPECT_EQ(data->read_index(), 7U);  // i.e. the third & fourth trans queued
 
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
@@ skipping 91 matching lines @@
   // there needs to be three sets of SSL connection data.
   helper.AddData(data_placeholder.get());
   helper.AddData(data_placeholder.get());
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
   scoped_ptr<HttpNetworkTransaction> trans3(
       new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
-  out.rv = trans1->Start(&httpreq1, &callback1, log);
+  out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   // run transaction 1 through quickly to force a read of our SETTINGS
   // frame
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
-  out.rv = trans2->Start(&httpreq2, &callback2, log);
+  out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
-  out.rv = trans3->Start(&httpreq3, &callback3, log);
+  out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   delete trans3.release();
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   EXPECT_EQ(8U, data->read_index());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
   EXPECT_TRUE(response1->headers != NULL);
@@ skipping 12 matching lines @@
   out.rv = ReadTransaction(trans2.get(), &out.response_data);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
   helper.VerifyDataConsumed();
   EXPECT_EQ(OK, out.rv);
 }
 
 // The KillerCallback will delete the transaction on error as part of the
 // callback.
-class KillerCallback : public TestOldCompletionCallback {
+class KillerCallback : public TestCompletionCallbackBase {
  public:
   explicit KillerCallback(HttpNetworkTransaction* transaction)
-      : transaction_(transaction) {}
-
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    if (params.a < 0)
-      delete transaction_;
-    TestOldCompletionCallback::RunWithParams(params);
+      : transaction_(transaction),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&KillerCallback::OnComplete, base::Unretained(this)))) {
   }
 
+  virtual ~KillerCallback() {}
+
+  const CompletionCallback& callback() const { return callback_; }
+
  private:
+  void OnComplete(int result) {
+    if (result < 0)
+      delete transaction_;
+
+    SetResult(result);
+  }
+
   HttpNetworkTransaction* transaction_;
+  CompletionCallback callback_;
 };
 
 // Similar to ThreeGetsMaxConcurrrentDelete above, however, this test
 // closes the socket while we have a pending transaction waiting for
 // a pending stream creation.  http://crbug.com/52901
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentSocketClose) {
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, false));
@@ skipping 35 matching lines @@
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   // We require placeholder data because three get requests are sent out, so
   // there needs to be three sets of SSL connection data.
   helper.AddData(data_placeholder.get());
   helper.AddData(data_placeholder.get());
   HttpNetworkTransaction trans1(helper.session());
   HttpNetworkTransaction trans2(helper.session());
   HttpNetworkTransaction* trans3(new HttpNetworkTransaction(helper.session()));
 
-  TestOldCompletionCallback callback1;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
   KillerCallback callback3(trans3);
 
   HttpRequestInfo httpreq1 = CreateGetRequest();
   HttpRequestInfo httpreq2 = CreateGetRequest();
   HttpRequestInfo httpreq3 = CreateGetRequest();
 
-  out.rv = trans1.Start(&httpreq1, &callback1, log);
+  out.rv = trans1.Start(&httpreq1, callback1.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   // run transaction 1 through quickly to force a read of our SETTINGS
   // frame
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
-  out.rv = trans2.Start(&httpreq2, &callback2, log);
+  out.rv = trans2.Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
-  out.rv = trans3->Start(&httpreq3, &callback3, log);
+  out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(ERR_ABORTED, out.rv);
 
   EXPECT_EQ(6U, data->read_index());
 
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
   EXPECT_TRUE(response1->headers != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
@@ skipping 356 matching lines @@
   scoped_refptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
                                   writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data->SetStop(2);
   data->Run();
   helper.ResetTrans();
   data->SetStop(20);
   data->Run();
 
   helper.VerifyDataConsumed();
 }
@@ skipping 34 matching lines @@
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.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_TRUE(response->was_fetched_via_spdy);
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
@@ skipping 73 matching lines @@
   request.upload_data = new UploadData();
   for (int i = 0; i < kFrameCount; ++i)
     request.upload_data->AppendBytes(content->c_str(), content->size());
 
   NormalSpdyTransactionHelper helper(request, BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(static_cast<int>(spdy::kSpdyStreamInitialWindowSize) +
             kDeltaWindowSize * kDeltaCount -
@@ skipping 35 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   SpdyHttpStream* stream =
       static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
 
   EXPECT_EQ(
       static_cast<int>(spdy::kSpdyStreamInitialWindowSize) - kUploadDataSize,
       stream->stream()->recv_window_size());
 
   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);
 
   // Issue a read which will cause a WINDOW_UPDATE to be sent and window
   // size increased to default.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kUploadDataSize));
-  rv = trans->Read(buf, kUploadDataSize, NULL);
+  rv = trans->Read(buf, kUploadDataSize, CompletionCallback());
   EXPECT_EQ(kUploadDataSize, rv);
   std::string content(buf->data(), buf->data()+kUploadDataSize);
   EXPECT_STREQ(kUploadData, content.c_str());
 
   // Schedule the reading of empty data frame with FIN
   data->CompleteRead();
 
   // Force write of WINDOW_UPDATE which was scheduled during the above
   // read.
   MessageLoop::current()->RunAllPending();
@@ skipping 60 matching lines @@
   for (int i = 0; i < kFrameCount; ++i)
     request.upload_data->AppendBytes(content->c_str(), content->size());
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
 
   data->CompleteRead();
 
   ASSERT_TRUE(helper.session() != NULL);
   ASSERT_TRUE(helper.session()->spdy_session_pool() != NULL);
   helper.session()->spdy_session_pool()->CloseAllSessions();
@@ skipping 86 matching lines @@
       new std::string(spdy::kSpdyStreamInitialWindowSize, 'a'));
   upload_data->append(kUploadData, kUploadDataSize);
   request.upload_data->AppendBytes(upload_data->c_str(), upload_data->size());
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   MessageLoop::current()->RunAllPending(); // Write as much as we can.
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
   EXPECT_FALSE(stream->request_body_stream_->eof());
 
@@ skipping 23 matching lines @@
 
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   helper.ResetTrans();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataNotConsumed();
 }
 
 // Verify that the client sends a Rst Frame upon cancelling the stream.
@@ skipping 17 matching lines @@
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(),
                                      GetParam());
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data->SetStop(2);
   data->Run();
   helper.ResetTrans();
   data->SetStop(20);
   data->Run();
 
   helper.VerifyDataConsumed();
 }
 
-class SpdyNetworkTransactionTest::StartTransactionCallback
-    : public CallbackRunner< Tuple1<int> > {
- public:
-  explicit StartTransactionCallback(
-      const scoped_refptr<HttpNetworkSession>& session,
-      NormalSpdyTransactionHelper& helper)
-      : session_(session), helper_(helper) {}
-
-  // We try to start another transaction, which should succeed.
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    scoped_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(session_));
-    TestOldCompletionCallback callback;
-    HttpRequestInfo request;
-    request.method = "GET";
-    request.url = GURL("http://www.google.com/");
-    request.load_flags = 0;
-    int rv = trans->Start(&request, &callback, BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
-    rv = callback.WaitForResult();
-  }
-
- private:
-  const scoped_refptr<HttpNetworkSession>& session_;
-  NormalSpdyTransactionHelper& helper_;
-};
-
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
 TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
   MockWrite writes2[] = { CreateMockWrite(*req) };
 
   // The indicated length of this packet is longer than its actual length. When
   // the session receives an empty packet after this one, it shuts down the
@@ skipping 26 matching lines @@
                             writes2, arraysize(writes2)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   helper.AddData(data2.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
-  StartTransactionCallback callback2(helper.session(), helper);
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
-  rv = trans->Read(buf, kSize, &callback2);
+  rv = trans->Read(
+      buf, kSize,
+      base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
+                 helper.session()));
   // This forces an err_IO_pending, which sets the callback.
   data->CompleteRead();
   // This finishes the read.
   data->CompleteRead();
   helper.VerifyDataConsumed();
 }
 
-class SpdyNetworkTransactionTest::DeleteSessionCallback
-    : public CallbackRunner< Tuple1<int> > {
- public:
-  explicit DeleteSessionCallback(NormalSpdyTransactionHelper& helper) :
-      helper_(helper) {}
-
-  // We kill the transaction, which deletes the session and stream.
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    helper_.ResetTrans();
-  }
-
- private:
-  NormalSpdyTransactionHelper& helper_;
-};
-
 // Verify that the client can correctly deal with the user callback deleting the
 // transaction. Failures will usually be valgrind errors. See
 // http://crbug.com/46925
 TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 2),
     MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
     CreateMockRead(*body.get(), 4),
     MockRead(true, 0, 0, 5),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // Setup a user callback which will delete the session, and clear out the
   // memory holding the stream object. Note that the callback deletes trans.
-  DeleteSessionCallback callback2(helper);
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
-  rv = trans->Read(buf, kSize, &callback2);
+  rv = trans->Read(
+      buf, kSize,
+      base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback,
+                 base::Unretained(&helper)));
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data->CompleteRead();
 
   // Finish running rest of tasks.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.google.com that gets redirected to www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) {
@@ skipping 376 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof()) << "Read count: "
                                    << data->read_count()
                                    << " Read index: "
                                    << data->read_index();
   EXPECT_TRUE(data->at_write_eof()) << "Write count: "
@@ skipping 232 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof()) << "Read count: "
                                    << data->read_count()
                                    << " Read index: "
                                    << data->read_index();
   EXPECT_TRUE(data->at_write_eof()) << "Write count: "
@@ skipping 39 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof()) << "Read count: "
                                    << data->read_count()
                                    << " Read index: "
                                    << data->read_index();
   EXPECT_TRUE(data->at_write_eof()) << "Write count: "
@@ skipping 35 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof()) << "Read count: "
                                    << data->read_count()
                                    << " Read index: "
                                    << data->read_index();
   EXPECT_TRUE(data->at_write_eof()) << "Write count: "
                                     << data->write_count()
@@ skipping 569 matching lines @@
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     CreateMockRead(*last_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
 
   std::string content;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, &read_callback);
+    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       NOTREACHED();
     }
   } while (rv > 0);
@@ skipping 48 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, &read_callback);
+    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
@@ skipping 51 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, &read_callback);
+    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
   } while (rv > 0);
 
   EXPECT_EQ(3, reads_completed);
@@ skipping 44 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
-    rv = trans->Read(buf, kSmallReadSize, &read_callback);
+    rv = trans->Read(buf, kSmallReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       data->CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       // This test intentionally closes the connection, and will get an error.
       EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
       break;
@@ skipping 34 matching lines @@
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
 
   do {
     const int kReadSize = 256;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
-    rv = trans->Read(buf, kReadSize, &read_callback);
+    rv = trans->Read(buf, kReadSize, read_callback.callback());
     if (rv == net::ERR_IO_PENDING) {
       // Complete the read now, which causes buffering to start.
       data->CompleteRead();
       // Destroy the transaction, causing the stream to get cancelled
       // and orphaning the buffered IO task.
       helper.ResetTrans();
       break;
     }
     // We shouldn't get here in this test.
     FAIL() << "Unexpected read: " << rv;
@@ skipping 270 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      log, GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   TransactionHelperResult out;
-  out.rv = trans->Start(&CreateGetRequest(), &callback, log);
+  out.rv = trans->Start(&CreateGetRequest(), callback.callback(), log);
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
@@ skipping 70 matching lines @@
       break;
     case SPDYNPN:
       data = new OrderedSocketData(reads_SPDYNPN, arraysize(reads_SPDYNPN),
                                    writes_SPDYNPN, arraysize(writes_SPDYNPN));
       break;
     default:
       NOTREACHED();
   }
 
   helper.AddData(data.get());
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
@@ skipping 37 matching lines @@
     CreateMockRead(*body, 3),
     MockRead(true, ERR_IO_PENDING, 4),  // Force a pause
     MockRead(true, 0, 5)  // EOF
   };
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   TransactionHelperResult out;
-  out.rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  out.rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(OK, out.rv);
@@ skipping 93 matching lines @@
   HttpNetworkSessionPeer session_peer(session_proxy);
   scoped_ptr<net::ProxyService> proxy_service(
           ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   session_peer.SetProxyService(proxy_service.get());
   helper_proxy.session_deps().swap(ssd_proxy);
   helper_proxy.SetSession(session_proxy);
   helper_proxy.RunPreTestSetup();
   helper_proxy.AddData(data_proxy.get());
 
   HttpNetworkTransaction* trans_proxy = helper_proxy.trans();
-  TestOldCompletionCallback callback_proxy;
-  int rv = trans_proxy->Start(&request_proxy, &callback_proxy, BoundNetLog());
+  TestCompletionCallback callback_proxy;
+  int rv = trans_proxy->Start(
+      &request_proxy, callback_proxy.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_proxy.WaitForResult();
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
   EXPECT_TRUE(response_proxy.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data));
@@ skipping 46 matching lines @@
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.AddData(data1.get());
     helper.AddData(data2.get());
     helper.RunPreTestSetup();
 
     for (int i = 0; i < 2; ++i) {
       scoped_ptr<HttpNetworkTransaction> trans(
           new HttpNetworkTransaction(helper.session()));
 
-      TestOldCompletionCallback callback;
-      int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
+      TestCompletionCallback callback;
+      int rv = trans->Start(
+          &helper.request(), callback.callback(), BoundNetLog());
       EXPECT_EQ(ERR_IO_PENDING, rv);
       // On the second transaction, we trigger the RST.
       if (i == 1) {
         if (variant == VARIANT_RST_DURING_READ_COMPLETION) {
           // Writes to the socket complete asynchronously on SPDY by running
           // through the message loop.  Complete the write here.
           MessageLoop::current()->RunAllPending();
         }
 
         // Now schedule the ERR_CONNECTION_RESET.
@@ skipping 116 matching lines @@
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   HttpRequestInfo request(CreateGetRequest());
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(request, net_log, GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
-  TestOldCompletionCallback callback_start;
-  const int rv_start = trans->Start(&request, &callback_start, net_log);
+  TestCompletionCallback callback;
+  const int rv_start = trans->Start(&request, callback.callback(), net_log);
   EXPECT_EQ(ERR_IO_PENDING, rv_start);
-  const int rv_start_complete = callback_start.WaitForResult();
+  const int rv_start_complete = callback.WaitForResult();
   EXPECT_EQ(OK, rv_start_complete);
 
   // Make sure the response has an auth challenge.
   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
   ASSERT_TRUE(response_start != NULL);
   ASSERT_TRUE(response_start->headers != NULL);
   EXPECT_EQ(401, response_start->headers->response_code());
   EXPECT_TRUE(response_start->was_fetched_via_spdy);
   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
   ASSERT_TRUE(auth_challenge != NULL);
   EXPECT_FALSE(auth_challenge->is_proxy);
   EXPECT_EQ("basic", auth_challenge->scheme);
   EXPECT_EQ("MyRealm", auth_challenge->realm);
 
   // Restart with a username/password.
   AuthCredentials credentials(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"));
-  TestOldCompletionCallback callback_restart;
-  const int rv_restart = trans->RestartWithAuth(credentials, &callback_restart);
+  TestCompletionCallback callback_restart;
+  const int rv_restart = trans->RestartWithAuth(
+      credentials, callback_restart.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv_restart);
   const int rv_restart_complete = callback_restart.WaitForResult();
   EXPECT_EQ(OK, rv_restart_complete);
   // TODO(cbentzel): This is actually the same response object as before, but
   // data has changed.
   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());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
@@ skipping 160 matching lines @@
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // and the body of the primary stream, but before we've received the HEADERS
   // for the pushed stream.
   data->SetStop(3);
 
   // Start the transaction.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data->Run();
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
-  rv = trans2->Start(&CreateGetPushRequest(), &callback, BoundNetLog());
+  rv = trans2->Start(
+      &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data->RunFor(3);
   MessageLoop::current()->RunAllPending();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), data.get(), &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, data, &result);
@@ skipping 117 matching lines @@
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
   // the first HEADERS frame, and the body of the primary stream, but before
   // we've received the final HEADERS for the pushed stream.
   data->SetStop(4);
 
   // Start the transaction.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data->Run();
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   // Request the pushed path.  At this point, we've received the push, but the
   // headers are not yet complete.
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(helper.session()));
-  rv = trans2->Start(&CreateGetPushRequest(), &callback, BoundNetLog());
+  rv = trans2->Start(
+      &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data->RunFor(3);
   MessageLoop::current()->RunAllPending();
 
   // Read the server push body.
   std::string result2;
   ReadResult(trans2.get(), data, &result2);
   // Read the response body.
   std::string result;
   ReadResult(trans, data, &result);
@@ skipping 282 matching lines @@
     request.url = GURL(url_to_fetch);
     request.load_flags = 0;
     NormalSpdyTransactionHelper helper(request,
                                        BoundNetLog(), GetParam());
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
     // Start the transaction with basic parameters.
-    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();
 
     // Read the response body.
     std::string result;
     ReadResult(trans, data, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data->at_read_eof());
     EXPECT_TRUE(data->at_write_eof());
@@ skipping 35 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
-  TestOldCompletionCallback callback;
-  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  TestCompletionCallback callback;
+  int rv = trans->Start(
+      &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
   EXPECT_TRUE(data->at_read_eof()) << "Read count: "
                                    << data->read_count()
                                    << " Read index: "
                                    << data->read_index();
   EXPECT_TRUE(data->at_write_eof()) << "Write count: "
                                     << data->write_count()
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net