Rename ClientSocket to StreamSocket.

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 27 matching lines @@
 
 enum {
   // A private network error code used by the socket test utility classes.
   // If the |result| member of a MockRead is
   // ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, that MockRead is just a
   // marker that indicates the peer will close the connection after the next
   // MockRead.  The other members of that MockRead are ignored.
   ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ = -10000,
 };
 
-class ClientSocket;
 class MockClientSocket;
 class SSLClientSocket;
 class SSLHostInfo;
+class StreamSocket;
 
 struct MockConnect {
   // Asynchronous connection success.
   MockConnect() : async(true), result(OK) { }
   MockConnect(bool a, int r) : async(a), result(r) { }
 
   bool async;
   int result;
 };
 
@@ skipping 399 matching lines @@
 
   int sequence_number_;
   MockRead current_read_;
   MockWrite current_write_;
   int stopping_sequence_number_;
   bool stopped_;
   base::WeakPtr<DeterministicMockTCPClientSocket> socket_;
   bool print_debug_;
 };
 
-// Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}ClientSocket
+// Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}StreamSocket
 // objects get instantiated, they take their data from the i'th element of this
 // array.
 template<typename T>
 class SocketDataProviderArray {
  public:
   SocketDataProviderArray() : next_index_(0) {
   }
 
   T* GetNext() {
     DCHECK_LT(next_index_, data_providers_.size());
@@ skipping 44 matching lines @@
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
   SocketDataProviderArray<SocketDataProvider>& mock_data() {
     return mock_data_;
   }
   std::vector<MockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
 
   // ClientSocketFactory
-  virtual ClientSocket* CreateTransportClientSocket(
+  virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
@@ skipping 20 matching lines @@
   virtual void OnReadComplete(const MockRead& data) = 0;
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback) = 0;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback) = 0;
   virtual bool SetReceiveBufferSize(int32 size);
   virtual bool SetSendBufferSize(int32 size);
 
-  // ClientSocket methods:
+  // StreamSocket methods:
   virtual int Connect(net::CompletionCallback* callback) = 0;
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool IsConnectedAndIdle() const;
   virtual int GetPeerAddress(AddressList* address) const;
   virtual int GetLocalAddress(IPEndPoint* address) const;
   virtual const BoundNetLog& NetLog() const;
   virtual void SetSubresourceSpeculation() {}
   virtual void SetOmniboxSpeculation() {}
 
@@ skipping 22 matching lines @@
                       net::SocketDataProvider* socket);
 
   net::AddressList addresses() const { return addresses_; }
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
-  // ClientSocket methods:
+  // StreamSocket methods:
   virtual int Connect(net::CompletionCallback* callback);
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool IsConnectedAndIdle() const;
   virtual bool WasEverUsed() const;
   virtual bool UsingTCPFastOpen() const;
 
   // MockClientSocket:
   virtual void OnReadComplete(const MockRead& data);
 
@@ skipping 31 matching lines @@
 
   void CompleteWrite();
   int CompleteRead();
 
   // Socket:
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
 
-  // ClientSocket:
+  // StreamSocket:
   virtual int Connect(net::CompletionCallback* callback);
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool IsConnectedAndIdle() const;
   virtual bool WasEverUsed() const;
   virtual bool UsingTCPFastOpen() const;
 
   // MockClientSocket:
   virtual void OnReadComplete(const MockRead& data);
 
@@ skipping 21 matching lines @@
       SSLHostInfo* ssl_host_info,
       net::SSLSocketDataProvider* socket);
   virtual ~MockSSLClientSocket();
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
-  // ClientSocket methods:
+  // StreamSocket methods:
   virtual int Connect(net::CompletionCallback* callback);
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool WasEverUsed() const;
   virtual bool UsingTCPFastOpen() const;
 
   // SSLClientSocket methods:
   virtual void GetSSLInfo(net::SSLInfo* ssl_info);
   virtual void GetSSLCertRequestInfo(
       net::SSLCertRequestInfo* cert_request_info);
@@ skipping 86 matching lines @@
  private:
   ScopedVector<TestSocketRequest> requests_;
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
 };
 
 class MockTransportClientSocketPool : public TransportClientSocketPool {
  public:
   class MockConnectJob {
    public:
-    MockConnectJob(ClientSocket* socket, ClientSocketHandle* handle,
+    MockConnectJob(StreamSocket* socket, ClientSocketHandle* handle,
                    CompletionCallback* callback);
     ~MockConnectJob();
 
     int Connect();
     bool CancelHandle(const ClientSocketHandle* handle);
 
    private:
     void OnConnect(int rv);
 
-    scoped_ptr<ClientSocket> socket_;
+    scoped_ptr<StreamSocket> socket_;
     ClientSocketHandle* handle_;
     CompletionCallback* user_callback_;
     CompletionCallbackImpl<MockConnectJob> connect_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(MockConnectJob);
   };
 
   MockTransportClientSocketPool(
       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.
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback,
                             const BoundNetLog& net_log);
 
   virtual void CancelRequest(const std::string& group_name,
                              ClientSocketHandle* handle);
   virtual void ReleaseSocket(const std::string& group_name,
-                             ClientSocket* socket, int id);
+                             StreamSocket* socket, int id);
 
  private:
   ClientSocketFactory* client_socket_factory_;
   ScopedVector<MockConnectJob> job_list_;
   int release_count_;
   int cancel_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketPool);
 };
 
@@ skipping 11 matching lines @@
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
   SocketDataProviderArray<DeterministicSocketData>& mock_data() {
     return mock_data_;
   }
   std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
 
   // ClientSocketFactory
-  virtual ClientSocket* CreateTransportClientSocket(
+  virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
@@ skipping 22 matching lines @@
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback,
                             const BoundNetLog& net_log);
 
   virtual void CancelRequest(const std::string& group_name,
                              ClientSocketHandle* handle);
   virtual void ReleaseSocket(const std::string& group_name,
-                             ClientSocket* socket, int id);
+                             StreamSocket* socket, int id);
 
  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_