Rename ClientSocket to StreamSocket.

net/socket/client_socket_pool_base.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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 24 matching lines @@
 #include "base/task.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/request_priority.h"
-#include "net/socket/client_socket.h"
 #include "net/socket/client_socket_pool.h"
+#include "net/socket/stream_socket.h"
 
 namespace net {
 
 class ClientSocketHandle;
 
 // ConnectJob provides an abstract interface for "connecting" a socket.
 // The connection may involve host resolution, tcp connection, ssl connection,
 // etc.
 class ConnectJob {
  public:
@@ skipping 25 matching lines @@
   }
 
   // Initialized by the ClientSocketPoolBaseHelper.
   // TODO(willchan): Move most of the constructor arguments over here.  We
   // shouldn't give the ConnectJobFactory (subclasses) the ability to screw up
   // the initialization.
   void Initialize(bool is_preconnect);
 
   // Releases |socket_| to the client.  On connection error, this should return
   // NULL.
-  ClientSocket* ReleaseSocket() { return socket_.release(); }
+  StreamSocket* ReleaseSocket() { return socket_.release(); }
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
   // if it succeeded.
   int Connect();
 
   // Precondition: is_unused_preconnect() must be true.  Marks the job as a
   // used preconnect job.
   void UseForNormalRequest();
 
   virtual LoadState GetLoadState() const = 0;
 
   // If Connect returns an error (or OnConnectJobComplete reports an error
   // result) this method will be called, allowing the pool to add
   // additional error state to the ClientSocketHandle (post late-binding).
   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {}
 
   const BoundNetLog& net_log() const { return net_log_; }
 
  protected:
-  void set_socket(ClientSocket* socket);
-  ClientSocket* socket() { return socket_.get(); }
+  void set_socket(StreamSocket* socket);
+  StreamSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
   void ResetTimer(base::TimeDelta remainingTime);
 
  private:
   enum PreconnectState {
     NOT_PRECONNECT,
     UNUSED_PRECONNECT,
     USED_PRECONNECT,
   };
 
   virtual int ConnectInternal() = 0;
 
   void LogConnectStart();
   void LogConnectCompletion(int net_error);
 
   // Alerts the delegate that the ConnectJob has timed out.
   void OnTimeout();
 
   const std::string group_name_;
   const base::TimeDelta timeout_duration_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer<ConnectJob> timer_;
   Delegate* delegate_;
-  scoped_ptr<ClientSocket> socket_;
+  scoped_ptr<StreamSocket> socket_;
   BoundNetLog net_log_;
   // A ConnectJob is idle until Connect() has been called.
   bool idle_;
   PreconnectState preconnect_state_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 namespace internal {
 
@@ skipping 77 matching lines @@
   void RequestSockets(const std::string& group_name,
                       const Request& request,
                       int num_sockets);
 
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
-                     ClientSocket* socket,
+                     StreamSocket* socket,
                      int id);
 
   // See ClientSocketPool::Flush for documentation on this function.
   void Flush();
 
   // See ClientSocketPool::CloseIdleSockets for documentation on this function.
   void CloseIdleSockets();
 
   // See ClientSocketPool::IdleSocketCount() for documentation on this function.
   int idle_socket_count() const {
@@ skipping 57 matching lines @@
     // An idle socket should be removed if it can't be reused, or has been idle
     // for too long. |now| is the current time value (TimeTicks::Now()).
     // |timeout| is the length of time to wait before timing out an idle socket.
     //
     // An idle socket can't be reused if it is disconnected or has received
     // data unexpectedly (hence no longer idle).  The unread data would be
     // mistaken for the beginning of the next response if we were to reuse the
     // socket for a new request.
     bool ShouldCleanup(base::TimeTicks now, base::TimeDelta timeout) const;
 
-    ClientSocket* socket;
+    StreamSocket* socket;
     base::TimeTicks start_time;
   };
 
   typedef std::deque<const Request* > RequestQueue;
   typedef std::map<const ClientSocketHandle*, const Request*> RequestMap;
 
   // A Group is allocated per group_name when there are idle sockets or pending
   // requests.  Otherwise, the Group object is removed from the map.
   // |active_socket_count| tracks the number of sockets held by clients.
   class Group {
@@ skipping 110 matching lines @@
   // Removes |job| from |connect_job_set_|.  Also updates |group| if non-NULL.
   void RemoveConnectJob(ConnectJob* job, Group* group);
 
   // Tries to see if we can handle any more requests for |group|.
   void OnAvailableSocketSlot(const std::string& group_name, Group* group);
 
   // Process a pending socket request for a group.
   void ProcessPendingRequest(const std::string& group_name, Group* group);
 
   // Assigns |socket| to |handle| and updates |group|'s counters appropriately.
-  void HandOutSocket(ClientSocket* socket,
+  void HandOutSocket(StreamSocket* socket,
                      bool reused,
                      ClientSocketHandle* handle,
                      base::TimeDelta time_idle,
                      Group* group,
                      const BoundNetLog& net_log);
 
   // Adds |socket| to the list of idle sockets for |group|.
-  void AddIdleSocket(ClientSocket* socket, Group* group);
+  void AddIdleSocket(StreamSocket* socket, Group* group);
 
   // Iterates through |group_map_|, canceling all ConnectJobs and deleting
   // groups if they are no longer needed.
   void CancelAllConnectJobs();
 
   // Iterates through |group_map_|, posting ERR_ABORTED callbacks for all
   // requests, and then deleting groups if they are no longer needed.
   void AbortAllRequests();
 
   // Returns true if we can't create any more sockets due to the total limit.
@@ skipping 181 matching lines @@
                           params,
                           net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
     return helper_.CancelRequest(group_name, handle);
   }
 
-  void ReleaseSocket(const std::string& group_name, ClientSocket* socket,
+  void ReleaseSocket(const std::string& group_name, StreamSocket* socket,
                      int id) {
     return helper_.ReleaseSocket(group_name, socket, id);
   }
 
   void CloseIdleSockets() { return helper_.CloseIdleSockets(); }
 
   int idle_socket_count() const { return helper_.idle_socket_count(); }
 
   int IdleSocketCountInGroup(const std::string& group_name) const {
     return helper_.IdleSocketCountInGroup(group_name);
@@ skipping 76 matching lines @@
   // Histograms for the pool
   ClientSocketPoolHistograms* const histograms_;
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_