Rename ClientSocket to StreamSocket.

net/socket/socket_test_util.cc

 // Copyright (c) 2010 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>
 
 
@@ skipping 570 matching lines @@
   DCHECK_LT(index, tcp_client_sockets_.size());
   return tcp_client_sockets_[index];
 }
 
 MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket(
     size_t index) const {
   DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
-ClientSocket* MockClientSocketFactory::CreateTransportClientSocket(
+StreamSocket* MockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     net::NetLog* net_log,
     const NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockTCPClientSocket* socket =
       new MockTCPClientSocket(addresses, net_log, data_provider);
   data_provider->set_socket(socket);
   tcp_client_sockets_.push_back(socket);
   return socket;
 }
@@ skipping 571 matching lines @@
 }
 
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 MockTransportClientSocketPool::MockConnectJob::MockConnectJob(
-    ClientSocket* socket,
+    StreamSocket* socket,
     ClientSocketHandle* handle,
     CompletionCallback* callback)
     : socket_(socket),
       handle_(handle),
       user_callback_(callback),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           connect_callback_(this, &MockConnectJob::OnConnect)) {
 }
 
 MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {}
@@ skipping 48 matching lines @@
 }
 
 MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
 
 int MockTransportClientSocketPool::RequestSocket(const std::string& group_name,
                                            const void* socket_params,
                                            RequestPriority priority,
                                            ClientSocketHandle* handle,
                                            CompletionCallback* callback,
                                            const BoundNetLog& net_log) {
-  ClientSocket* socket = client_socket_factory_->CreateTransportClientSocket(
+  StreamSocket* socket = client_socket_factory_->CreateTransportClientSocket(
       AddressList(), net_log.net_log(), net::NetLog::Source());
   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)) {
       cancel_count_++;
       break;
     }
   }
 }
 
 void MockTransportClientSocketPool::ReleaseSocket(const std::string& group_name,
-                                            ClientSocket* socket, int id) {
+                                            StreamSocket* socket, int id) {
   EXPECT_EQ(1, id);
   release_count_++;
   delete socket;
 }
 
 DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {}
 
 DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {}
 
 void DeterministicMockClientSocketFactory::AddSocketDataProvider(
@@ skipping 10 matching lines @@
   mock_data_.ResetNextIndex();
   mock_ssl_data_.ResetNextIndex();
 }
 
 MockSSLClientSocket* DeterministicMockClientSocketFactory::
     GetMockSSLClientSocket(size_t index) const {
   DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
-ClientSocket* DeterministicMockClientSocketFactory::CreateTransportClientSocket(
+StreamSocket* DeterministicMockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     net::NetLog* net_log,
     const net::NetLog::Source& source) {
   DeterministicSocketData* data_provider = mock_data().GetNext();
   DeterministicMockTCPClientSocket* socket =
       new DeterministicMockTCPClientSocket(net_log, data_provider);
   data_provider->set_socket(socket->AsWeakPtr());
   tcp_client_sockets().push_back(socket);
   return socket;
 }
@@ skipping 41 matching lines @@
                                         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,
-                                              ClientSocket* socket, int id) {
+                                              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