base::Bind: Convert Socket::Read.

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 569 matching lines @@
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public net::SSLClientSocket {
  public:
   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 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 void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
@@ skipping 33 matching lines @@
 class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockTCPClientSocket(const net::AddressList& addresses, net::NetLog* net_log,
                       net::SocketDataProvider* socket);
 
   net::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;
 
   // StreamSocket implementation.
   virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool IsConnectedAndIdle() const OVERRIDE;
   virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
@@ skipping 17 matching lines @@
   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_;
   int pending_buf_len_;
-  net::OldCompletionCallback* pending_callback_;
+  net::OldCompletionCallback* old_pending_callback_;
+  net::CompletionCallback pending_callback_;

[James Hawkins, 2011/12/07 00:01:57]

#include "net/base/completion_callback.h"

[James Hawkins, 2011/12/07 00:08:11]

Done.

   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);
   virtual ~DeterministicMockTCPClientSocket();
 
   bool write_pending() const { return write_pending_; }
   bool read_pending() const { return read_pending_; }
 
   void CompleteWrite();
   int CompleteRead();
 
-  // Socket:
+  // 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;
 
   // StreamSocket implementation.
   virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Connect(const net::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_;
   int write_result_;
 
   net::MockRead read_data_;
 
   net::IOBuffer* read_buf_;
   int read_buf_len_;
   bool read_pending_;
-  net::OldCompletionCallback* read_callback_;
+  net::OldCompletionCallback* old_read_callback_;
+  net::CompletionCallback read_callback_;
   net::DeterministicSocketData* data_;
   bool was_used_to_convey_data_;
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(
       net::ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const net::SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       net::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;
 
   // StreamSocket implementation.
   virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
   virtual bool WasEverUsed() const OVERRIDE;
   virtual bool UsingTCPFastOpen() const OVERRIDE;
@@ skipping 22 matching lines @@
   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 interface
+  // 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 bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
-  // DatagramSocket interface
+  // 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 interface
+  // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
-  // AsyncSocket interface
+  // AsyncSocket implementation.
   virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(net::OldCompletionCallback* callback, int result);
-  void RunCallback(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);
 
   bool connected_;
   SocketDataProvider* data_;
   int read_offset_;
   net::MockRead read_data_;
   bool need_read_data_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
   net::IOBuffer* pending_buf_;
   int pending_buf_len_;
-  net::OldCompletionCallback* pending_callback_;
+  net::OldCompletionCallback* old_pending_callback_;
+  net::CompletionCallback pending_callback_;
 
   BoundNetLog net_log_;
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
 class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
  public:
@@ skipping 210 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_