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

net/http/http_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_transaction_unittest.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 143 matching lines @@
   factory->CreateTransaction(&trans_);
   ++quit_counter_;
 }
 
 TestTransactionConsumer::~TestTransactionConsumer() {
 }
 
 void TestTransactionConsumer::Start(const net::HttpRequestInfo* request,
                                     const net::BoundNetLog& net_log) {
   state_ = STARTING;
-  int result = trans_->Start(request, this, net_log);
+  int result = trans_->Start(
+      request, base::Bind(&net::OldCompletionCallbackAdapter, this), net_log);
   if (result != net::ERR_IO_PENDING)
     DidStart(result);
 }
 
 void TestTransactionConsumer::DidStart(int result) {
   if (result != net::OK) {
     DidFinish(result);
   } else {
     Read();
   }
@@ skipping 11 matching lines @@
 void TestTransactionConsumer::DidFinish(int result) {
   state_ = DONE;
   error_ = result;
   if (--quit_counter_ == 0)
     MessageLoop::current()->Quit();
 }
 
 void TestTransactionConsumer::Read() {
   state_ = READING;
   read_buf_ = new net::IOBuffer(1024);
-  int result = trans_->Read(read_buf_, 1024, this);
+  int result = trans_->Read(
+      read_buf_, 1024, base::Bind(&net::OldCompletionCallbackAdapter, this));
   if (result != net::ERR_IO_PENDING)
     DidRead(result);
 }
 
 void TestTransactionConsumer::RunWithParams(const Tuple1<int>& params) {
   int result = params.a;
   switch (state_) {
     case STARTING:
       DidStart(result);
       break;
     case READING:
       DidRead(result);
       break;
     default:
       NOTREACHED();
   }
 }
 
 
 MockNetworkTransaction::MockNetworkTransaction(MockNetworkLayer* factory)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       data_cursor_(0),
       transaction_factory_(factory->AsWeakPtr()) {
 }
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
-                                  net::OldCompletionCallback* callback,
+                                  const net::CompletionCallback& callback,
                                   const net::BoundNetLog& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return net::ERR_FAILED;
 
   std::string resp_status = t->status;
   std::string resp_headers = t->response_headers;
   std::string resp_data = t->data;
   if (t->handler)
     (t->handler)(request, &resp_status, &resp_headers, &resp_data);
@@ skipping 18 matching lines @@
   test_mode_ = t->test_mode;
 
   if (test_mode_ & TEST_MODE_SYNC_NET_START)
     return net::OK;
 
   CallbackLater(callback, net::OK);
   return net::ERR_IO_PENDING;
 }
 
 int MockNetworkTransaction::RestartIgnoringLastError(
-    net::OldCompletionCallback* callback) {
+    const net::CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int MockNetworkTransaction::RestartWithCertificate(
     net::X509Certificate* client_cert,
-    net::OldCompletionCallback* callback) {
+    const net::CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int MockNetworkTransaction::RestartWithAuth(
     const net::AuthCredentials& credentials,
-    net::OldCompletionCallback* callback) {
+    const net::CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 bool MockNetworkTransaction::IsReadyToRestartForAuth() {
   return false;
 }
 
 int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len,
-                                 net::OldCompletionCallback* callback) {
+                                 const net::CompletionCallback& callback) {
   int data_len = static_cast<int>(data_.size());
   int num = std::min(buf_len, data_len - data_cursor_);
   if (num) {
     memcpy(buf->data(), data_.data() + data_cursor_, num);
     data_cursor_ += num;
   }
   if (test_mode_ & TEST_MODE_SYNC_NET_READ)
     return num;
 
   CallbackLater(callback, num);
@@ skipping 14 matching lines @@
 net::LoadState MockNetworkTransaction::GetLoadState() const {
   if (data_cursor_)
     return net::LOAD_STATE_READING_RESPONSE;
   return net::LOAD_STATE_IDLE;
 }
 
 uint64 MockNetworkTransaction::GetUploadProgress() const {
   return 0;
 }
 
-void MockNetworkTransaction::CallbackLater(net::OldCompletionCallback* callback,
-                                           int result) {
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MockNetworkTransaction::RunCallback, ptr_factory_.GetWeakPtr(),
-      callback, result));
+void MockNetworkTransaction::CallbackLater(
+    const net::CompletionCallback& callback, int result) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
+                            weak_factory_.GetWeakPtr(), callback, result));
 }
 
-void MockNetworkTransaction::RunCallback(net::OldCompletionCallback* callback,
-                                         int result) {
-  callback->Run(result);
+void MockNetworkTransaction::RunCallback(
+    const net::CompletionCallback& callback, int result) {
+  callback.Run(result);
 }
 
 MockNetworkLayer::MockNetworkLayer()
     : transaction_count_(0), done_reading_called_(false) {}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
 void MockNetworkLayer::TransactionDoneReading() {
   done_reading_called_ = true;
 }
@@ skipping 12 matching lines @@
 net::HttpNetworkSession* MockNetworkLayer::GetSession() {
   return NULL;
 }
 
 //-----------------------------------------------------------------------------
 // helpers
 
 int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
   int rv;
 
-  TestOldCompletionCallback callback;
+  net::TestCompletionCallback callback;
 
   std::string content;
   do {
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
-    rv = trans->Read(buf, 256, &callback);
+    rv = trans->Read(buf, 256, callback.callback());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
-    if (rv > 0) {
+
+    if (rv > 0)
       content.append(buf->data(), rv);
-    } else if (rv < 0) {
+    else if (rv < 0)
       return rv;
-    }
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }