Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

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>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "net/base/address_list.h"
-#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_controller.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socks_client_socket_pool.h"
@@ skipping 227 matching lines @@
 struct SSLSocketDataProvider {
   SSLSocketDataProvider(bool async, int result);
   ~SSLSocketDataProvider();
 
   MockConnect connect;
   SSLClientSocket::NextProtoStatus next_proto_status;
   std::string next_proto;
   std::string server_protos;
   bool was_npn_negotiated;
   bool client_cert_sent;
-  net::SSLCertRequestInfo* cert_request_info;
+  SSLCertRequestInfo* cert_request_info;
   scoped_refptr<X509Certificate> cert;
 };
 
 // A DataProvider where the client must write a request before the reads (e.g.
 // the response) will complete.
 class DelayedSocketData : public StaticSocketDataProvider,
                           public base::RefCounted<DelayedSocketData> {
  public:
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
@@ skipping 22 matching lines @@
   void ForceNextRead();
 
   // StaticSocketDataProvider:
   virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void CompleteRead() OVERRIDE;
 
  private:
   int write_delay_;
-  ScopedRunnableMethodFactory<DelayedSocketData> factory_;
+  base::WeakPtrFactory<DelayedSocketData> weak_factory_;
 };
 
 // A DataProvider where the reads are ordered.
 // If a read is requested before its sequence number is reached, we return an
 // ERR_IO_PENDING (that way we don't have to explicitly add a MockRead just to
 // wait).
 // The sequence number is incremented on every read and write operation.
 // The message loop may be interrupted by setting the high bit of the sequence
 // number in the MockRead's sequence number.  When that MockRead is reached,
 // we post a Quit message to the loop.  This allows us to interrupt the reading
@@ skipping 14 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 SetOldCompletionCallback(OldCompletionCallback* callback) {
+  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_;
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
   bool blocked_;
-  ScopedRunnableMethodFactory<OrderedSocketData> factory_;
+  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.
 //
 // Network activity is modeled as a sequence of numbered steps which is
@@ skipping 194 matching lines @@
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<MockUDPClientSocket*> udp_client_sockets_;
   std::vector<MockTCPClientSocket*> tcp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
-class MockClientSocket : public net::SSLClientSocket {
+class MockClientSocket : public SSLClientSocket {
  public:
+  // TODO(ajwong): Why do we need net::NetLog?
   explicit MockClientSocket(net::NetLog* net_log);
 
   // Socket implementation.
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) = 0;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) = 0;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) = 0;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) = 0;
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) = 0;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // StreamSocket implementation.
-  virtual int Connect(net::OldCompletionCallback* callback) = 0;
-  virtual int Connect(const net::CompletionCallback& callback) = 0;
+  virtual int Connect(const CompletionCallback& callback) = 0;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
   virtual void SetSubresourceSpeculation() OVERRIDE {}
   virtual void SetOmniboxSpeculation() OVERRIDE {}
 
   // SSLClientSocket implementation.
-  virtual void GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
   virtual void GetSSLCertRequestInfo(
-      net::SSLCertRequestInfo* cert_request_info) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    const base::StringPiece& context,
                                    unsigned char *out,
                                    unsigned int outlen) OVERRIDE;
   virtual NextProtoStatus GetNextProto(std::string* proto,
                                        std::string* server_protos) OVERRIDE;
 
  protected:
   virtual ~MockClientSocket();
-  void RunCallbackAsync(net::OldCompletionCallback* callback, int result);
-  void RunCallbackAsync(const net::CompletionCallback& callback, int result);
-  void RunOldCallback(net::OldCompletionCallback*, int result);
-  void RunCallback(const net::CompletionCallback&, int result);
+  void RunCallbackAsync(const CompletionCallback& callback, int result);
+  void RunCallback(const CompletionCallback& callback, int result);
 
   base::WeakPtrFactory<MockClientSocket> weak_factory_;
 
   // True if Connect completed successfully and Disconnect hasn't been called.
   bool connected_;
 
-  net::BoundNetLog net_log_;
+  BoundNetLog net_log_;
 };
 
 class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
  public:
-  MockTCPClientSocket(const net::AddressList& addresses, net::NetLog* net_log,
-                      net::SocketDataProvider* socket);
+  MockTCPClientSocket(const AddressList& addresses, net::NetLog* net_log,
+                      SocketDataProvider* socket);
   virtual ~MockTCPClientSocket();
 
-  net::AddressList addresses() const { return addresses_; }
+  AddressList addresses() const { return addresses_; }
 
   // Socket implementation.
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) OVERRIDE;
 
   // StreamSocket implementation.
-  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual int64 NumBytesRead() const OVERRIDE;
   virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // AsyncSocket:
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   int CompleteRead();
 
-  net::AddressList addresses_;
+  AddressList addresses_;
 
-  net::SocketDataProvider* data_;
+  SocketDataProvider* data_;
   int read_offset_;
   int num_bytes_read_;
-  net::MockRead read_data_;
+  MockRead read_data_;
   bool need_read_data_;
 
   // True if the peer has closed the connection.  This allows us to simulate
   // the recv(..., MSG_PEEK) call in the IsConnectedAndIdle method of the real
   // TCPClientSocket.
   bool peer_closed_connection_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
-  net::IOBuffer* pending_buf_;
+  IOBuffer* pending_buf_;
   int pending_buf_len_;
-  net::OldCompletionCallback* old_pending_callback_;
-  net::CompletionCallback pending_callback_;
+  CompletionCallback pending_callback_;
   bool was_used_to_convey_data_;
 };
 
 class DeterministicMockTCPClientSocket : public MockClientSocket,
     public AsyncSocket,
     public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
  public:
   DeterministicMockTCPClientSocket(net::NetLog* net_log,
-      net::DeterministicSocketData* data);
+                                   DeterministicSocketData* data);
   virtual ~DeterministicMockTCPClientSocket();
 
   bool write_pending() const { return write_pending_; }
   bool read_pending() const { return read_pending_; }
 
   void CompleteWrite();
   int CompleteRead();
 
   // Socket implementation.
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) OVERRIDE;
+  // Socket:
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) OVERRIDE;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
 
   // StreamSocket implementation.
-  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual int64 NumBytesRead() const OVERRIDE;
   virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // AsyncSocket:
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   bool write_pending_;
-  net::OldCompletionCallback* write_callback_;
+  CompletionCallback write_callback_;
   int write_result_;
 
-  net::MockRead read_data_;
+  MockRead read_data_;
 
-  net::IOBuffer* read_buf_;
+  IOBuffer* read_buf_;
   int read_buf_len_;
   bool read_pending_;
-  net::OldCompletionCallback* old_read_callback_;
-  net::CompletionCallback read_callback_;
-  net::DeterministicSocketData* data_;
+  CompletionCallback read_callback_;
+  DeterministicSocketData* data_;
   bool was_used_to_convey_data_;
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(
-      net::ClientSocketHandle* transport_socket,
+      ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
-      const net::SSLConfig& ssl_config,
+      const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
-      net::SSLSocketDataProvider* socket);
+      SSLSocketDataProvider* socket);
   virtual ~MockSSLClientSocket();
 
   // Socket implementation.
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) OVERRIDE;
 
   // StreamSocket implementation.
-  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
   virtual int64 NumBytesRead() const OVERRIDE;
   virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // SSLClientSocket implementation.
-  virtual void GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
   virtual void GetSSLCertRequestInfo(
-      net::SSLCertRequestInfo* cert_request_info) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual NextProtoStatus GetNextProto(std::string* proto,
                                        std::string* server_protos) OVERRIDE;
   virtual bool was_npn_negotiated() const OVERRIDE;
   virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
 
   // This MockSocket does not implement the manual async IO feature.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
-  class OldConnectCallback;
-  class ConnectCallback;
+  static void ConnectCallback(MockSSLClientSocket *ssl_client_socket,
+                              const CompletionCallback& callback,
+                              int rv);
 
   scoped_ptr<ClientSocketHandle> transport_;
-  net::SSLSocketDataProvider* data_;
+  SSLSocketDataProvider* data_;
   bool is_npn_state_set_;
   bool new_npn_value_;
   bool was_used_to_convey_data_;
 };
 
 class MockUDPClientSocket : public DatagramClientSocket,
     public AsyncSocket {
  public:
   MockUDPClientSocket(SocketDataProvider* data, net::NetLog* net_log);
   virtual ~MockUDPClientSocket();
 
   // Socket implementation.
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) OVERRIDE;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // DatagramSocket implementation.
   virtual void Close() OVERRIDE;
   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual const BoundNetLog& NetLog() const OVERRIDE;
 
   // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
   // AsyncSocket implementation.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   int CompleteRead();
 
-  void RunCallbackAsync(net::OldCompletionCallback* callback, int result);
-  void RunCallbackAsync(const net::CompletionCallback& callback, int result);
-  void RunOldCallback(net::OldCompletionCallback* callback, int result);
-  void RunCallback(const net::CompletionCallback& callback, int result);
+  void RunCallbackAsync(const CompletionCallback& callback, int result);
+  void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
   SocketDataProvider* data_;
   int read_offset_;
-  net::MockRead read_data_;
+  MockRead read_data_;
   bool need_read_data_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
-  net::IOBuffer* pending_buf_;
+  IOBuffer* pending_buf_;
   int pending_buf_len_;
-  net::OldCompletionCallback* old_pending_callback_;
-  net::CompletionCallback pending_callback_;
+  CompletionCallback pending_callback_;
 
   BoundNetLog net_log_;
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
 class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
  public:
@@ skipping 68 matching lines @@
   ScopedVector<TestSocketRequest> requests_;
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
 };
 
 class MockTransportClientSocketPool : public TransportClientSocketPool {
  public:
   class MockConnectJob {
    public:
     MockConnectJob(StreamSocket* socket, ClientSocketHandle* handle,
-                   OldCompletionCallback* callback);
+                   const CompletionCallback& callback);
     ~MockConnectJob();
 
     int Connect();
     bool CancelHandle(const ClientSocketHandle* handle);
 
    private:
     void OnConnect(int rv);
 
     scoped_ptr<StreamSocket> socket_;
     ClientSocketHandle* handle_;
-    OldCompletionCallback* user_callback_;
-    OldCompletionCallbackImpl<MockConnectJob> connect_callback_;
+    CompletionCallback user_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(MockConnectJob);
   };
 
   MockTransportClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
       ClientSocketPoolHistograms* histograms,
       ClientSocketFactory* socket_factory);
 
@@ skipping 109 matching lines @@
 
 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_