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

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 326 matching lines @@
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: The MockRead and MockWrite lists musts end with a EOF
   //       e.g. a MockRead(true, 0, 0);
   OrderedSocketData(const MockConnect& connect,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
 
-  void SetCompletionCallback(const CompletionCallback& callback) {
-    callback_ = callback;
-  }
-
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop();
 
   // StaticSocketDataProvider:
   virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void CompleteRead() OVERRIDE;
 
  private:
   friend class base::RefCounted<OrderedSocketData>;
   virtual ~OrderedSocketData();
 
   int sequence_number_;
   int loop_stop_stage_;
-  CompletionCallback callback_;
   bool blocked_;
   base::WeakPtrFactory<OrderedSocketData> weak_factory_;
 };
 
 class DeterministicMockTCPClientSocket;
 
 // This class gives the user full control over the network activity,
 // specifically the timing of the COMPLETION of I/O operations.  Regardless of
 // the order in which I/O operations are initiated, this class ensures that they
 // complete in the correct order.
@@ skipping 557 matching lines @@
       int max_sockets,
       int max_sockets_per_group,
       ClientSocketPoolHistograms* histograms,
       ClientSocketFactory* socket_factory);
 
   virtual ~MockTransportClientSocketPool();
 
   int release_count() const { return release_count_; }
   int cancel_count() const { return cancel_count_; }
 
-  // TransportClientSocketPool methods.
+  // TransportClientSocketPool implementation.
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
-                            OldCompletionCallback* callback,
+                            const CompletionCallback& callback,
                             const BoundNetLog& net_log) OVERRIDE;
 
   virtual void CancelRequest(const std::string& group_name,
                              ClientSocketHandle* handle) OVERRIDE;
   virtual void ReleaseSocket(const std::string& group_name,
                              StreamSocket* socket, int id) OVERRIDE;
 
  private:
   ClientSocketFactory* client_socket_factory_;
   ScopedVector<MockConnectJob> job_list_;
@@ skipping 53 matching lines @@
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
  public:
   MockSOCKSClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
       ClientSocketPoolHistograms* histograms,
       TransportClientSocketPool* transport_pool);
 
   virtual ~MockSOCKSClientSocketPool();
 
-  // SOCKSClientSocketPool methods.
+  // SOCKSClientSocketPool implementation.
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
-                            OldCompletionCallback* callback,
+                            const CompletionCallback& callback,
                             const BoundNetLog& net_log) OVERRIDE;
 
   virtual void CancelRequest(const std::string& group_name,
                              ClientSocketHandle* handle) OVERRIDE;
   virtual void ReleaseSocket(const std::string& group_name,
                              StreamSocket* socket, int id) OVERRIDE;
 
  private:
   TransportClientSocketPool* const transport_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSOCKSClientSocketPool);
 };
 
 // Constants for a successful SOCKS v5 handshake.
 extern const char kSOCKS5GreetRequest[];
 extern const int kSOCKS5GreetRequestLength;
 
 extern const char kSOCKS5GreetResponse[];
 extern const int kSOCKS5GreetResponseLength;
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_