Rename ClientSocket to StreamSocket.

net/socket/client_socket_pool_base_unittest.cc

 // 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.
 
 #include "net/socket/client_socket_pool_base.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
-#include "net/socket/client_socket.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_histograms.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_host_info.h"
+#include "net/socket/stream_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const int kDefaultMaxSockets = 4;
 const int kDefaultMaxSocketsPerGroup = 2;
 const net::RequestPriority kDefaultPriority = MEDIUM;
 
 class TestSocketParams : public base::RefCounted<TestSocketParams> {
  public:
   bool ignore_limits() { return false; }
  private:
   friend class base::RefCounted<TestSocketParams>;
   ~TestSocketParams() {}
 };
 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 
-class MockClientSocket : public ClientSocket {
+class MockClientSocket : public StreamSocket {
  public:
   MockClientSocket() : connected_(false), was_used_to_convey_data_(false) {}
 
   // Socket methods:
   virtual int Read(
       IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) {
     return ERR_UNEXPECTED;
   }
 
   virtual int Write(
       IOBuffer* /* buf */, int len, CompletionCallback* /* callback */) {
     was_used_to_convey_data_ = true;
     return len;
   }
   virtual bool SetReceiveBufferSize(int32 size) { return true; }
   virtual bool SetSendBufferSize(int32 size) { return true; }
 
-  // ClientSocket methods:
+  // StreamSocket methods:
 
   virtual int Connect(CompletionCallback* callback) {
     connected_ = true;
     return OK;
   }
 
   virtual void Disconnect() { connected_ = false; }
   virtual bool IsConnected() const { return connected_; }
   virtual bool IsConnectedAndIdle() const { return connected_; }
 
@@ skipping 21 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class TestConnectJob;
 
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory() : allocation_count_(0) {}
 
-  virtual ClientSocket* CreateTransportClientSocket(
+  virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
       const NetLog::Source& /*source*/) {
     allocation_count_++;
     return NULL;
   }
 
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
@@ skipping 292 matching lines @@
   }
 
   virtual void CancelRequest(
       const std::string& group_name,
       ClientSocketHandle* handle) {
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
-      ClientSocket* socket,
+      StreamSocket* socket,
       int id) {
     base_.ReleaseSocket(group_name, socket, id);
   }
 
   virtual void Flush() {
     base_.Flush();
   }
 
   virtual void CloseIdleSockets() {
     base_.CloseIdleSockets();
@@ skipping 63 matching lines @@
 }
 
 class TestConnectJobDelegate : public ConnectJob::Delegate {
  public:
   TestConnectJobDelegate()
       : have_result_(false), waiting_for_result_(false), result_(OK) {}
   virtual ~TestConnectJobDelegate() {}
 
   virtual void OnConnectJobComplete(int result, ConnectJob* job) {
     result_ = result;
-    scoped_ptr<ClientSocket> socket(job->ReleaseSocket());
+    scoped_ptr<StreamSocket> socket(job->ReleaseSocket());
     // socket.get() should be NULL iff result != OK
     EXPECT_EQ(socket.get() == NULL, result != OK);
     delete job;
     have_result_ = true;
     if (waiting_for_result_)
       MessageLoop::current()->Quit();
   }
 
   int WaitForResult() {
     DCHECK(!waiting_for_result_);
@@ skipping 2611 matching lines @@
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("b"));
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
 }
 
 }  // namespace
 
 }  // namespace net