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

net/http/http_pipelined_connection_impl_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_pipelined_connection_impl.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 86 matching lines @@
     HttpRequestInfo* request_info = new HttpRequestInfo;
     request_info->url = GURL("http://localhost/" + filename);
     request_info->method = "GET";
     request_info_vector_.push_back(request_info);
     return request_info;
   }
 
   HttpStream* NewTestStream(const std::string& filename) {
     HttpStream* stream = pipeline_->CreateNewStream();
     HttpRequestInfo* request_info = GetRequestInfo(filename);
-    int rv = stream->InitializeStream(request_info, BoundNetLog(), NULL);
+    int rv = stream->InitializeStream(
+        request_info, BoundNetLog(), CompletionCallback());
     DCHECK_EQ(OK, rv);
     return stream;
   }
 
   void ExpectResponse(const std::string& expected,
                       scoped_ptr<HttpStream>& stream, bool async) {
     scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
 
     if (async) {
       EXPECT_EQ(ERR_IO_PENDING,
                 stream->ReadResponseBody(buffer.get(), expected.size(),
-                                         &callback_));
+                                         callback_.callback()));
       data_->RunFor(1);
       EXPECT_EQ(static_cast<int>(expected.size()), callback_.WaitForResult());
     } else {
       EXPECT_EQ(static_cast<int>(expected.size()),
                 stream->ReadResponseBody(buffer.get(), expected.size(),
-                                         &callback_));
+                                         callback_.callback()));
     }
     std::string actual(buffer->data(), expected.size());
     EXPECT_THAT(actual, StrEq(expected));
   }
 
   void TestSyncRequest(scoped_ptr<HttpStream>& stream,
                        const std::string& filename) {
     HttpRequestHeaders headers;
     HttpResponseInfo response;
-    EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response, &callback_));
-    EXPECT_EQ(OK, stream->ReadResponseHeaders(&callback_));
+    EXPECT_EQ(OK, stream->SendRequest(
+        headers, NULL, &response, callback_.callback()));
+    EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
     ExpectResponse(filename, stream, false);
 
     stream->Close(false);
   }
 
   DeterministicMockClientSocketFactory factory_;
   ClientSocketPoolHistograms histograms_;
   MockTransportClientSocketPool pool_;
   scoped_refptr<DeterministicSocketData> data_;
 
   SSLConfig ssl_config_;
   ProxyInfo proxy_info_;
   NiceMock<MockPipelineDelegate> delegate_;
-  TestOldCompletionCallback callback_;
+  TestCompletionCallback callback_;
   scoped_ptr<HttpPipelinedConnectionImpl> pipeline_;
   ScopedVector<HttpRequestInfo> request_info_vector_;
 };
 
 TEST_F(HttpPipelinedConnectionImplTest, PipelineNotUsed) {
   Initialize(NULL, 0, NULL, 0);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, StreamNotUsed) {
   Initialize(NULL, 0, NULL, 0);
@@ skipping 34 matching lines @@
     MockRead(true, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
     MockRead(true, 3, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(ERR_IO_PENDING,
-            stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, NULL, &response,
+                                                callback_.callback()));
   data_->RunFor(1);
   EXPECT_LE(OK, callback_.WaitForResult());
 
-  EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   ExpectResponse("ok.html", stream, true);
 
   stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) {
   MockWrite writes[] = {
     MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(true, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(true, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
     MockRead(true, 4, "ok.html"),
     MockRead(true, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 6, "Content-Length: 7\r\n\r\n"),
     MockRead(true, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(ERR_IO_PENDING,
-            stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, NULL, &response1,
+                                                 callback_.callback()));
 
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(ERR_IO_PENDING,
-            stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, NULL, &response2,
+                                                 callback_.callback()));
 
   data_->RunFor(1);
   EXPECT_LE(OK, callback_.WaitForResult());
   data_->RunFor(1);
   EXPECT_LE(OK, callback_.WaitForResult());
 
-  EXPECT_EQ(ERR_IO_PENDING, stream1->ReadResponseHeaders(&callback_));
-  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream1->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback_.callback()));
 
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   ExpectResponse("ok.html", stream1, true);
 
   stream1->Close(false);
 
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
@@ skipping 17 matching lines @@
              "Content-Length: 7\r\n\r\n"
              "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", stream1, false);
   stream1->Close(false);
 
-  EXPECT_EQ(OK, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ko.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, SendOrderSwapped) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ko.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 4, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
@@ skipping 26 matching lines @@
     MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
 
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", stream1, false);
 
   stream1->Close(false);
 
   EXPECT_LE(OK, callback_.WaitForResult());
   ExpectResponse("ko.html", stream2, false);
 
   stream2->Close(false);
 }
 
@@ skipping 10 matching lines @@
     MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
 
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
   ExpectResponse("ok.html", stream1, false);
   stream1->Close(false);
 
-  EXPECT_EQ(OK, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ko.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(true, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
     MockRead(true, 4, "ok.html"),
     MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
-  TestOldCompletionCallback callback1;
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
+  TestCompletionCallback callback1;
   std::string expected = "ok.html";
   scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->ReadResponseBody(buffer.get(), expected.size(),
-                                      &callback1));
+                                      callback1.callback()));
 
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            stream2->SendRequest(headers2, NULL, &response2, &callback2));
+            stream2->SendRequest(headers2, NULL, &response2,
+                                 callback2.callback()));
 
   data_->RunFor(1);
   EXPECT_LE(OK, callback2.WaitForResult());
-  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(&callback2));
+  EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback2.callback()));
 
   data_->RunFor(1);
   EXPECT_EQ(static_cast<int>(expected.size()), callback1.WaitForResult());
   std::string actual(buffer->data(), expected.size());
   EXPECT_THAT(actual, StrEq(expected));
   stream1->Close(false);
 
   data_->StopAfter(8);
   EXPECT_LE(OK, callback2.WaitForResult());
   ExpectResponse("ko.html", stream2, false);
@@ skipping 30 matching lines @@
     MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(ERR_IO_PENDING,
-            stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, NULL, &response,
+                                                callback_.callback()));
 
   scoped_ptr<HttpStream> unsent_stream(NewTestStream("unsent.html"));
   HttpRequestHeaders unsent_headers;
   HttpResponseInfo unsent_response;
   EXPECT_EQ(ERR_IO_PENDING,
             unsent_stream->SendRequest(unsent_headers, NULL, &unsent_response,
-                                       &callback_));
+                                       callback_.callback()));
   unsent_stream->Close(false);
 
   data_->RunFor(1);
   EXPECT_LE(OK, callback_.WaitForResult());
 
-  EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   ExpectResponse("ok.html", stream, true);
 
   stream->Close(false);
 
   data_->StopAfter(8);
   scoped_ptr<HttpStream> later_stream(NewTestStream("ko.html"));
   TestSyncRequest(later_stream, "ko.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FailedSend) {
   MockWrite writes[] = {
     MockWrite(true, ERR_FAILED),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> failed_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> closed_stream(NewTestStream("closed.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  TestOldCompletionCallback failed_callback;
+  TestCompletionCallback failed_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             failed_stream->SendRequest(headers, NULL, &response,
-                                       &failed_callback));
-  TestOldCompletionCallback evicted_callback;
+                                       failed_callback.callback()));
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->SendRequest(headers, NULL, &response,
-                                        &evicted_callback));
+                                        evicted_callback.callback()));
   EXPECT_EQ(ERR_IO_PENDING,
             closed_stream->SendRequest(headers, NULL, &response,
-                                       &callback_));
+                                       callback_.callback()));
   closed_stream->Close(false);
 
   data_->RunFor(1);
   EXPECT_EQ(ERR_FAILED, failed_callback.WaitForResult());
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             rejected_stream->SendRequest(headers, NULL, &response,
-                                         &callback_));
+                                         callback_.callback()));
 
   failed_stream->Close(true);
   evicted_stream->Close(true);
   rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"),
@@ skipping 14 matching lines @@
   scoped_ptr<HttpStream> send_closed_stream(
       NewTestStream("send_closed.html"));
   scoped_ptr<HttpStream> send_evicted_stream(
       NewTestStream("send_evicted.html"));
   scoped_ptr<HttpStream> send_rejected_stream(
       NewTestStream("send_rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, closed_stream->SendRequest(headers, NULL, &response,
-                                           &callback_));
+                                           callback_.callback()));
   EXPECT_EQ(OK, read_evicted_stream->SendRequest(headers, NULL, &response,
-                                                 &callback_));
+                                                 callback_.callback()));
   EXPECT_EQ(OK, read_rejected_stream->SendRequest(headers, NULL, &response,
-                                                  &callback_));
-  TestOldCompletionCallback send_closed_callback;
+                                                  callback_.callback()));
+  TestCompletionCallback send_closed_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             send_closed_stream->SendRequest(headers, NULL, &response,
-                                            &send_closed_callback));
-  TestOldCompletionCallback send_evicted_callback;
+                                            send_closed_callback.callback()));
+  TestCompletionCallback send_evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             send_evicted_stream->SendRequest(headers, NULL, &response,
-                                             &send_evicted_callback));
+                                             send_evicted_callback.callback()));
 
-  TestOldCompletionCallback read_evicted_callback;
+  TestCompletionCallback read_evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            read_evicted_stream->ReadResponseHeaders(&read_evicted_callback));
+            read_evicted_stream->ReadResponseHeaders(
+                read_evicted_callback.callback()));
 
-  EXPECT_EQ(OK, closed_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, closed_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", closed_stream, false);
   closed_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, read_evicted_callback.WaitForResult());
   read_evicted_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
-            read_rejected_stream->ReadResponseHeaders(&callback_));
+            read_rejected_stream->ReadResponseHeaders(callback_.callback()));
   read_rejected_stream->Close(true);
 
   data_->RunFor(1);
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, send_closed_callback.WaitForResult());
   send_closed_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, send_evicted_callback.WaitForResult());
   send_evicted_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             send_rejected_stream->SendRequest(headers, NULL, &response,
-                                              &callback_));
+                                              callback_.callback()));
   send_rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) {
   MockWrite writes[] = {
     MockWrite(true, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  TestOldCompletionCallback aborted_callback;
+  TestCompletionCallback aborted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             aborted_stream->SendRequest(headers, NULL, &response,
-                                        &aborted_callback));
-  TestOldCompletionCallback evicted_callback;
+                                        aborted_callback.callback()));
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->SendRequest(headers, NULL, &response,
-                                        &evicted_callback));
+                                        evicted_callback.callback()));
 
   aborted_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(aborted_callback.have_result());
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) {
   MockWrite writes[] = {
     MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(true, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  TestOldCompletionCallback ok_callback;
+  TestCompletionCallback ok_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             ok_stream->SendRequest(headers, NULL, &response,
-                                   &ok_callback));
-  TestOldCompletionCallback aborted_callback;
+                                   ok_callback.callback()));
+  TestCompletionCallback aborted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             aborted_stream->SendRequest(headers, NULL, &response,
-                                        &aborted_callback));
-  TestOldCompletionCallback evicted_callback;
+                                        aborted_callback.callback()));
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->SendRequest(headers, NULL, &response,
-                                        &evicted_callback));
+                                        evicted_callback.callback()));
 
   data_->RunFor(1);
   EXPECT_LE(OK, ok_callback.WaitForResult());
   MessageLoop::current()->RunAllPending();
   aborted_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(aborted_callback.have_result());
   ok_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(true, ERR_FAILED, 2),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, aborted_stream->SendRequest(headers, NULL, &response,
-                                            &callback_));
+                                            callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(headers, NULL, &response,
-                                            &callback_));
+                                            callback_.callback()));
 
-  EXPECT_EQ(ERR_IO_PENDING, aborted_stream->ReadResponseHeaders(&callback_));
-  TestOldCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            aborted_stream->ReadResponseHeaders(callback_.callback()));
+  TestCompletionCallback evicted_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   aborted_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
-            rejected_stream->SendRequest(headers, NULL, &response, &callback_));
+            rejected_stream->SendRequest(headers, NULL, &response,
+                                         callback_.callback()));
   rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 3, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 4, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 5, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> abandoned_stream(NewTestStream("abandoned.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, abandoned_stream->SendRequest(headers, NULL, &response,
-                                              &callback_));
+                                              callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(headers, NULL, &response,
-                                            &callback_));
+                                            callback_.callback()));
 
-  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(&callback_));
-  TestOldCompletionCallback abandoned_callback;
+  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
+  TestCompletionCallback abandoned_callback;
+  EXPECT_EQ(ERR_IO_PENDING, abandoned_stream->ReadResponseHeaders(
+      abandoned_callback.callback()));
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            abandoned_stream->ReadResponseHeaders(&abandoned_callback));
-  TestOldCompletionCallback evicted_callback;
-  EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   abandoned_stream->Close(false);
 
   ExpectResponse("ok.html", ok_stream, false);
   ok_stream->Close(false);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(evicted_stream->IsConnectionReusable());
 }
@@ skipping 13 matching lines @@
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> rejected_read_stream(NewTestStream("rejected.html"));
   scoped_ptr<HttpStream> evicted_send_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_send_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, rejected_read_stream->SendRequest(
-      headers, NULL, &response, &callback_));
+      headers, NULL, &response, callback_.callback()));
 
-  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
   ok_stream->Close(false);
 
-  TestOldCompletionCallback read_callback;
+  TestCompletionCallback read_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_send_stream->SendRequest(headers, NULL, &response,
-                                             &read_callback));
+                                             read_callback.callback()));
   data_->RunFor(1);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, read_callback.WaitForResult());
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
-            rejected_read_stream->ReadResponseHeaders(&callback_));
+            rejected_read_stream->ReadResponseHeaders(callback_.callback()));
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             rejected_send_stream->SendRequest(headers, NULL, &response,
-                                              &callback_));
+                                              callback_.callback()));
 
   rejected_read_stream->Close(true);
   rejected_send_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 4, "ok.html"),
     MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(
-      headers, NULL, &response, &callback_));
+      headers, NULL, &response, callback_.callback()));
 
-  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
 
-  TestOldCompletionCallback evicted_callback;
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   ok_stream->Close(false);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 4, "ok.html"),
     MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(
-      headers, NULL, &response, &callback_));
+      headers, NULL, &response, callback_.callback()));
 
-  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
 
-  TestOldCompletionCallback evicted_callback;
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   ok_stream->Close(false);
   evicted_stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeReadCallback) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
     MockRead(false, 4, "ok.html"),
     MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(
-      headers, NULL, &response, &callback_));
+      headers, NULL, &response, callback_.callback()));
 
-  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
 
-  TestOldCompletionCallback evicted_callback;
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   ok_stream->Close(false);
 
   // The posted tasks should be:
   // 1. DoReadHeadersLoop, which will post:
   // 2. InvokeUserCallback
   SuddenCloseObserver observer(evicted_stream.get(), 2);
   MessageLoop::current()->AddTaskObserver(&observer);
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(evicted_callback.have_result());
 }
 
 class StreamDeleter {
  public:
   StreamDeleter(HttpStream* stream) :
       stream_(stream),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &StreamDeleter::OnIOComplete)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+          base::Bind(&StreamDeleter::OnIOComplete, base::Unretained(this)))) {
   }
 
-  OldCompletionCallbackImpl<StreamDeleter>* callback() { return &callback_; }
+  const CompletionCallback& callback() { return callback_; }
 
  private:
   void OnIOComplete(int result) {
     delete stream_;
   }
 
   HttpStream* stream_;
-  OldCompletionCallbackImpl<StreamDeleter> callback_;
+  CompletionCallback callback_;
 };
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringSendCallback) {
   MockWrite writes[] = {
     MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   HttpStream* stream(NewTestStream("ok.html"));
 
@@ skipping 12 matching lines @@
   MockRead reads[] = {
     MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpStream* stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
+                                    callback_.callback()));
 
   StreamDeleter deleter(stream);
   EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(deleter.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest,
        CloseCalledDuringReadCallbackWithPendingRead) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /failed.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpStream* failed_stream(NewTestStream("failed.html"));
   HttpStream* evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK,
-            failed_stream->SendRequest(headers, NULL, &response, &callback_));
-  EXPECT_EQ(OK,
-            evicted_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, failed_stream->SendRequest(headers, NULL, &response,
+                                           callback_.callback()));
+  EXPECT_EQ(OK, evicted_stream->SendRequest(headers, NULL, &response,
+                                            callback_.callback()));
 
   StreamDeleter failed_deleter(failed_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             failed_stream->ReadResponseHeaders(failed_deleter.callback()));
   StreamDeleter evicted_deleter(evicted_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->ReadResponseHeaders(evicted_deleter.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> deleter_stream(NewTestStream("deleter.html"));
   HttpStream* deleted_stream(NewTestStream("deleted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK,
-            deleter_stream->SendRequest(headers, NULL, &response, &callback_));
-  EXPECT_EQ(OK,
-            deleted_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, deleter_stream->SendRequest(headers, NULL, &response,
+                                            callback_.callback()));
+  EXPECT_EQ(OK, deleted_stream->SendRequest(headers, NULL, &response,
+                                            callback_.callback()));
 
   StreamDeleter deleter(deleted_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             deleter_stream->ReadResponseHeaders(deleter.callback()));
-  EXPECT_EQ(ERR_IO_PENDING, deleted_stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_IO_PENDING,
+            deleted_stream->ReadResponseHeaders(callback_.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeSendCallbackRuns) {
   MockWrite writes[] = {
     MockWrite(true, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
     MockWrite(true, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
   scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
 
-  scoped_ptr<TestOldCompletionCallback> close_callback(
-      new TestOldCompletionCallback);
+  scoped_ptr<TestCompletionCallback> close_callback(
+      new TestCompletionCallback);
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(ERR_IO_PENDING, close_stream->SendRequest(
-      headers, NULL, &response, close_callback.get()));
+      headers, NULL, &response, close_callback->callback()));
 
   data_->RunFor(1);
   EXPECT_FALSE(close_callback->have_result());
 
   close_stream->Close(false);
   close_stream.reset();
   close_callback.reset();
 
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
   scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK,
-            close_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, close_stream->SendRequest(headers, NULL, &response,
+                                          callback_.callback()));
 
-  scoped_ptr<TestOldCompletionCallback> close_callback(
-      new TestOldCompletionCallback);
+  scoped_ptr<TestCompletionCallback> close_callback(
+      new TestCompletionCallback);
   EXPECT_EQ(ERR_IO_PENDING,
-            close_stream->ReadResponseHeaders(close_callback.get()));
+            close_stream->ReadResponseHeaders(close_callback->callback()));
 
   data_->RunFor(1);
   EXPECT_FALSE(close_callback->have_result());
 
   close_stream->Close(false);
   close_stream.reset();
   close_callback.reset();
 
   MessageLoop::current()->RunAllPending();
 }
@@ skipping 13 matching lines @@
              "Content-Length: 7\r\n\r\n"
              "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
-  EXPECT_EQ(OK, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2,
              "HTTP/1.1 302 OK\r\n\r\n"
              "redirect"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
-  EXPECT_EQ(ERR_PIPELINE_EVICTION, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_PIPELINE_EVICTION,
+            stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2,
              "HTTP/1.1 302 OK\r\n"
              "Content-Length: 8\r\n\r\n"),
     MockRead(false, ERR_SOCKET_NOT_CONNECTED, 3),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
-  EXPECT_EQ(ERR_PIPELINE_EVICTION, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_PIPELINE_EVICTION,
+            stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 2,
              "HTTP/1.1 302 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"),
     MockRead(false, 3,
              "jibberish"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
-  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1, &callback_));
+  EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
+                                     callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
-  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2, &callback_));
+  EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
+                                     callback_.callback()));
 
-  EXPECT_EQ(OK, stream1->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
-  EXPECT_EQ(ERR_PIPELINE_EVICTION, stream2->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(ERR_PIPELINE_EVICTION,
+            stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
     MockWrite(false, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(true, 3, "HTTP/1.1 200 OK\r\n\r\n"),
     MockRead(false, 4, "ok.html"),
     MockRead(false, OK, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
+                                       callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(headers, NULL, &response,
-                                            &callback_));
+                                            callback_.callback()));
   EXPECT_EQ(OK, rejected_stream->SendRequest(headers, NULL, &response,
-                                             &callback_));
+                                             callback_.callback()));
 
-  TestOldCompletionCallback ok_callback;
-  EXPECT_EQ(ERR_IO_PENDING, ok_stream->ReadResponseHeaders(&ok_callback));
+  TestCompletionCallback ok_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            ok_stream->ReadResponseHeaders(ok_callback.callback()));
 
-  TestOldCompletionCallback evicted_callback;
+  TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            evicted_stream->ReadResponseHeaders(&evicted_callback));
+            evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   data_->RunFor(1);
   EXPECT_LE(OK, ok_callback.WaitForResult());
   data_->StopAfter(10);
 
   ExpectResponse("ok.html", ok_stream, false);
   ok_stream->Close(false);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
-            rejected_stream->ReadResponseHeaders(&callback_));
+            rejected_stream->ReadResponseHeaders(callback_.callback()));
   rejected_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnSocketError) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, ERR_FAILED, 1),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(
                   pipeline_.get(),
                   HttpPipelinedConnection::PIPELINE_SOCKET_ERROR))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response, &callback_));
-  EXPECT_EQ(ERR_FAILED, stream->ReadResponseHeaders(&callback_));
+  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
+                                    callback_.callback()));
+  EXPECT_EQ(ERR_FAILED, stream->ReadResponseHeaders(callback_.callback()));
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnHttp10) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 1, "HTTP/1.0 200 OK\r\n"),
     MockRead(false, 2, "Content-Length: 7\r\n"),
     MockRead(false, 3, "Connection: keep-alive\r\n\r\n"),
@@ skipping 57 matching lines @@
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   HttpRequestHeaders headers;
   HttpResponseInfo response;
-  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response, &callback_));
+  EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
+                                    callback_.callback()));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   MessageLoop::current()->RunAllPending();
 
   stream->Close(false);
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   stream.reset(NULL);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacityWithoutSend) {
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   MessageLoop::current()->RunAllPending();
 
   stream->Close(false);
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   stream.reset(NULL);
 }
 
 }  // anonymous namespace
 
 }  // namespace net