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

net/socket/socket_test_util.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 321 matching lines @@
                                 << ": Clearing stop index";
       loop_stop_stage_ = 0;
     } else {
       return;
     }
   }
   // Record the sequence_number at which we stopped the loop.
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Posting Quit at read " << read_index();
   loop_stop_stage_ = sequence_number_;
-  if (!callback_.is_null())

[awong, 2011/12/20 21:51:35]

Are we sure we are supposed to remove this?

[James Hawkins, 2011/12/20 22:50:48]

Yes, the variable is completely unused because it's never set.

-    callback_.Run(ERR_IO_PENDING);
 }
 
 MockRead OrderedSocketData::GetNextRead() {
   weak_factory_.InvalidateWeakPtrs();
   blocked_ = false;
   const MockRead& next_read = StaticSocketDataProvider::PeekRead();
   if (next_read.sequence_number & MockRead::STOPLOOP)
     EndLoop();
   if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
       sequence_number_++) {
@@ skipping 1107 matching lines @@
     : TransportClientSocketPool(max_sockets, max_sockets_per_group, histograms,
                                 NULL, NULL, NULL),
       client_socket_factory_(socket_factory),
       release_count_(0),
       cancel_count_(0) {
 }
 
 MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
 
 int MockTransportClientSocketPool::RequestSocket(
-    const std::string& group_name,
-    const void* socket_params,
-    RequestPriority priority,
-    ClientSocketHandle* handle,
-    OldCompletionCallback* callback,
-    const BoundNetLog& net_log) {
+    const std::string& group_name, const void* socket_params,
+    RequestPriority priority, ClientSocketHandle* handle,
+    const CompletionCallback& callback, const BoundNetLog& net_log) {
   StreamSocket* socket = client_socket_factory_->CreateTransportClientSocket(
       AddressList(), net_log.net_log(), net::NetLog::Source());
-  CompletionCallback cb;
-  if (callback) {
-    cb = base::Bind(&OldCompletionCallback::Run<int>,
-                    base::Unretained(callback));
-  }
-  MockConnectJob* job = new MockConnectJob(socket, handle, cb);
+  MockConnectJob* job = new MockConnectJob(socket, handle, callback);
   job_list_.push_back(job);
   handle->set_pool_id(1);
   return job->Connect();
 }
 
 void MockTransportClientSocketPool::CancelRequest(const std::string& group_name,
                                             ClientSocketHandle* handle) {
   std::vector<MockConnectJob*>::iterator i;
   for (i = job_list_.begin(); i != job_list_.end(); ++i) {
     if ((*i)->CancelHandle(handle)) {
@@ skipping 78 matching lines @@
     int max_sockets_per_group,
     ClientSocketPoolHistograms* histograms,
     TransportClientSocketPool* transport_pool)
     : SOCKSClientSocketPool(max_sockets, max_sockets_per_group, histograms,
                             NULL, transport_pool, NULL),
       transport_pool_(transport_pool) {
 }
 
 MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() {}
 
-int MockSOCKSClientSocketPool::RequestSocket(const std::string& group_name,
-                                             const void* socket_params,
-                                             RequestPriority priority,
-                                             ClientSocketHandle* handle,
-                                             OldCompletionCallback* callback,
-                                             const BoundNetLog& net_log) {
-  return transport_pool_->RequestSocket(group_name,
-                                        socket_params,
-                                        priority,
-                                        handle,
-                                        callback,
-                                        net_log);
+int MockSOCKSClientSocketPool::RequestSocket(
+    const std::string& group_name, const void* socket_params,
+    RequestPriority priority, ClientSocketHandle* handle,
+    const CompletionCallback& callback, const BoundNetLog& net_log) {
+  return transport_pool_->RequestSocket(
+      group_name, socket_params, priority, handle, callback, net_log);
 }
 
 void MockSOCKSClientSocketPool::CancelRequest(
     const std::string& group_name,
     ClientSocketHandle* handle) {
   return transport_pool_->CancelRequest(group_name, handle);
 }
 
 void MockSOCKSClientSocketPool::ReleaseSocket(const std::string& group_name,
                                               StreamSocket* socket, int id) {
   return transport_pool_->ReleaseSocket(group_name, socket, id);
 }
 
 const char kSOCKS5GreetRequest[] = { 0x05, 0x01, 0x00 };
 const int kSOCKS5GreetRequestLength = arraysize(kSOCKS5GreetRequest);
 
 const char kSOCKS5GreetResponse[] = { 0x05, 0x00 };
 const int kSOCKS5GreetResponseLength = arraysize(kSOCKS5GreetResponse);
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net