Rename ClientSocket to StreamSocket.

net/socket/client_socket_pool_base.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/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 67 matching lines @@
   }
 
   return rv;
 }
 
 void ConnectJob::UseForNormalRequest() {
   DCHECK_EQ(UNUSED_PRECONNECT, preconnect_state_);
   preconnect_state_ = USED_PRECONNECT;
 }
 
-void ConnectJob::set_socket(ClientSocket* socket) {
+void ConnectJob::set_socket(StreamSocket* socket) {
   if (socket) {
     net_log().AddEvent(NetLog::TYPE_CONNECT_JOB_SET_SOCKET, make_scoped_refptr(
           new NetLogSourceParameter("source_dependency",
                                     socket->NetLog().source())));
   }
   socket_.reset(socket);
 }
 
 void ConnectJob::NotifyDelegateOfCompletion(int rv) {
   // The delegate will delete |this|.
@@ skipping 237 matching lines @@
         group->IsEmpty() && !group->HasBackupJob() &&
         handle) {
       group->StartBackupSocketTimer(group_name, this);
     }
 
     connecting_socket_count_++;
 
     group->AddJob(connect_job.release());
   } else {
     LogBoundConnectJobToRequest(connect_job->net_log().source(), request);
-    ClientSocket* error_socket = NULL;
+    StreamSocket* error_socket = NULL;
     if (!preconnecting) {
       DCHECK(handle);
       connect_job->GetAdditionalErrorState(handle);
       error_socket = connect_job->ReleaseSocket();
     }
     if (error_socket) {
       HandOutSocket(error_socket, false /* not reused */, handle,
                     base::TimeDelta(), group, request->net_log());
     } else if (group->IsEmpty()) {
       RemoveGroup(group_name);
@@ skipping 62 matching lines @@
       make_scoped_refptr(new NetLogSourceParameter(
           "source_dependency", connect_job_source)));
 }
 
 void ClientSocketPoolBaseHelper::CancelRequest(
     const std::string& group_name, ClientSocketHandle* handle) {
   PendingCallbackMap::iterator callback_it = pending_callback_map_.find(handle);
   if (callback_it != pending_callback_map_.end()) {
     int result = callback_it->second.result;
     pending_callback_map_.erase(callback_it);
-    ClientSocket* socket = handle->release_socket();
+    StreamSocket* socket = handle->release_socket();
     if (socket) {
       if (result != OK)
         socket->Disconnect();
       ReleaseSocket(handle->group_name(), socket, handle->id());
     }
     return;
   }
 
   CHECK(ContainsKey(group_map_, group_name));
 
@@ skipping 219 matching lines @@
     timer_.Start(TimeDelta::FromSeconds(kCleanupInterval), this,
                  &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
 }
 
 void ClientSocketPoolBaseHelper::DecrementIdleCount() {
   if (--idle_socket_count_ == 0)
     timer_.Stop();
 }
 
 void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string& group_name,
-                                               ClientSocket* socket,
+                                               StreamSocket* socket,
                                                int id) {
   GroupMap::iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
 
   Group* group = i->second;
 
   CHECK_GT(handed_out_socket_count_, 0);
   handed_out_socket_count_--;
 
   CHECK_GT(group->active_socket_count(), 0);
@@ skipping 70 matching lines @@
 }
 
 void ClientSocketPoolBaseHelper::OnConnectJobComplete(
     int result, ConnectJob* job) {
   DCHECK_NE(ERR_IO_PENDING, result);
   const std::string group_name = job->group_name();
   GroupMap::iterator group_it = group_map_.find(group_name);
   CHECK(group_it != group_map_.end());
   Group* group = group_it->second;
 
-  scoped_ptr<ClientSocket> socket(job->ReleaseSocket());
+  scoped_ptr<StreamSocket> socket(job->ReleaseSocket());
 
   BoundNetLog job_log = job->net_log();
 
   if (result == OK) {
     DCHECK(socket.get());
     RemoveConnectJob(job, group);
     if (!group->pending_requests().empty()) {
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group->mutable_pending_requests()->begin(), group));
       LogBoundConnectJobToRequest(job_log.source(), r.get());
@@ skipping 83 matching lines @@
     if (group->IsEmpty())
       RemoveGroup(group_name);
 
     request->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, rv);
     InvokeUserCallbackLater(
         request->handle(), request->callback(), rv);
   }
 }
 
 void ClientSocketPoolBaseHelper::HandOutSocket(
-    ClientSocket* socket,
+    StreamSocket* socket,
     bool reused,
     ClientSocketHandle* handle,
     base::TimeDelta idle_time,
     Group* group,
     const BoundNetLog& net_log) {
   DCHECK(socket);
   handle->set_socket(socket);
   handle->set_is_reused(reused);
   handle->set_idle_time(idle_time);
   handle->set_pool_id(pool_generation_number_);
 
   if (reused) {
     net_log.AddEvent(
         NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET,
         make_scoped_refptr(new NetLogIntegerParameter(
             "idle_ms", static_cast<int>(idle_time.InMilliseconds()))));
   }
 
   net_log.AddEvent(NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
                    make_scoped_refptr(new NetLogSourceParameter(
                        "source_dependency", socket->NetLog().source())));
 
   handed_out_socket_count_++;
   group->IncrementActiveSocketCount();
 }
 
 void ClientSocketPoolBaseHelper::AddIdleSocket(
-    ClientSocket* socket, Group* group) {
+    StreamSocket* socket, Group* group) {
   DCHECK(socket);
   IdleSocket idle_socket;
   idle_socket.socket = socket;
   idle_socket.start_time = base::TimeTicks::Now();
 
   group->mutable_idle_sockets()->push_back(idle_socket);
   IncrementIdleCount();
 }
 
 void ClientSocketPoolBaseHelper::CancelAllConnectJobs() {
@@ skipping 181 matching lines @@
   // Delete active jobs.
   STLDeleteElements(&jobs_);
 
   // Cancel pending backup job.
   method_factory_.RevokeAll();
 }
 
 }  // namespace internal
 
 }  // namespace net