Clang format slam.

net/socket/client_socket_pool_base.h

 // Copyright (c) 2012 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 49 matching lines @@
 class NET_EXPORT_PRIVATE ConnectJob {
  public:
   class NET_EXPORT_PRIVATE Delegate {
    public:
     Delegate() {}
     virtual ~Delegate() {}
 
     // Alerts the delegate that the connection completed. |job| must
     // be destroyed by the delegate. A scoped_ptr<> isn't used because
     // the caller of this function doesn't own |job|.
-    virtual void OnConnectJobComplete(int result,
-                                      ConnectJob* job) = 0;
+    virtual void OnConnectJobComplete(int result, ConnectJob* job) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              base::TimeDelta timeout_duration,
              RequestPriority priority,
              Delegate* delegate,
@@ skipping 72 matching lines @@
 // ClientSocketPoolBaseHelper.  This class is not for external use, please use
 // ClientSocketPoolBase instead.
 class NET_EXPORT_PRIVATE ClientSocketPoolBaseHelper
     : public ConnectJob::Delegate,
       public NetworkChangeNotifier::IPAddressObserver {
  public:
   typedef uint32 Flags;
 
   // Used to specify specific behavior for the ClientSocketPool.
   enum Flag {
-    NORMAL = 0,  // Normal behavior.
+    NORMAL = 0,             // Normal behavior.
     NO_IDLE_SOCKETS = 0x1,  // Do not return an idle socket. Create a new one.
   };
 
   class NET_EXPORT_PRIVATE Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
             bool ignore_limits,
             Flags flags,
@@ skipping 29 matching lines @@
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate) const = 0;
 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
-  ClientSocketPoolBaseHelper(
-      HigherLayeredPool* pool,
-      int max_sockets,
-      int max_sockets_per_group,
-      base::TimeDelta unused_idle_socket_timeout,
-      base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory);
+  ClientSocketPoolBaseHelper(HigherLayeredPool* pool,
+                             int max_sockets,
+                             int max_sockets_per_group,
+                             base::TimeDelta unused_idle_socket_timeout,
+                             base::TimeDelta used_idle_socket_timeout,
+                             ConnectJobFactory* connect_job_factory);
 
   virtual ~ClientSocketPoolBaseHelper();
 
   // Adds a lower layered pool to |this|, and adds |this| as a higher layered
   // pool on top of |lower_pool|.
   void AddLowerLayeredPool(LowerLayeredPool* lower_pool);
 
   // See LowerLayeredPool::IsStalled for documentation on this function.
   bool IsStalled() const;
 
   // See LowerLayeredPool for documentation on these functions. It is expected
   // in the destructor that no higher layer pools remain.
   void AddHigherLayeredPool(HigherLayeredPool* higher_pool);
   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   int RequestSocket(const std::string& group_name,
                     scoped_ptr<const Request> request);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   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);
+  void CancelRequest(const std::string& group_name, ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
                      scoped_ptr<StreamSocket> socket,
                      int id);
 
   // See ClientSocketPool::FlushWithError for documentation on this function.
   void FlushWithError(int error);
 
   // See ClientSocketPool::CloseIdleSockets for documentation on this function.
   void CloseIdleSockets();
 
   // See ClientSocketPool::IdleSocketCount() for documentation on this function.
-  int idle_socket_count() const {
-    return idle_socket_count_;
-  }
+  int idle_socket_count() const { return idle_socket_count_; }
 
   // See ClientSocketPool::IdleSocketCountInGroup() for documentation on this
   // function.
   int IdleSocketCountInGroup(const std::string& group_name) const;
 
   // See ClientSocketPool::GetLoadState() for documentation on this function.
   LoadState GetLoadState(const std::string& group_name,
                          const ClientSocketHandle* handle) const;
 
   base::TimeDelta ConnectRetryInterval() const {
@@ skipping 90 matching lines @@
   // 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 {
    public:
     Group();
     ~Group();
 
     bool IsEmpty() const {
       return active_socket_count_ == 0 && idle_sockets_.empty() &&
-          jobs_.empty() && pending_requests_.empty();
+             jobs_.empty() && pending_requests_.empty();
     }
 
     bool HasAvailableSocketSlot(int max_sockets_per_group) const {
       return NumActiveSocketSlots() < max_sockets_per_group;
     }
 
     int NumActiveSocketSlots() const {
       return active_socket_count_ + static_cast<int>(jobs_.size()) +
-          static_cast<int>(idle_sockets_.size());
+             static_cast<int>(idle_sockets_.size());
     }
 
     bool IsStalledOnPoolMaxSockets(int max_sockets_per_group) const {
       return HasAvailableSocketSlot(max_sockets_per_group) &&
-          pending_requests_.size() > jobs_.size();
+             pending_requests_.size() > jobs_.size();
     }
 
     // Returns the priority of the top of the pending request queue
     // (which may be less than the maximum priority over the entire
     // queue, due to how we prioritize requests with |ignore_limits|
     // set over others).
     RequestPriority TopPendingPriority() const {
       // NOTE: FirstMax().value()->priority() is not the same as
       // FirstMax().priority()!
       return pending_requests_.FirstMax().value()->priority();
     }
 
     // Set a timer to create a backup job if it takes too long to
     // create one and if a timer isn't already running.
     void StartBackupJobTimer(const std::string& group_name,
                              ClientSocketPoolBaseHelper* pool);
 
     bool BackupJobTimerIsRunning() const;
 
     // If there's a ConnectJob that's never been assigned to Request,
     // decrements |unassigned_job_count_| and returns true.
     // Otherwise, returns false.
     bool TryToUseUnassignedConnectJob();
 
     void AddJob(scoped_ptr<ConnectJob> job, bool is_preconnect);
     // Remove |job| from this group, which must already own |job|.
     void RemoveJob(ConnectJob* job);
     void RemoveAllJobs();
 
-    bool has_pending_requests() const {
-      return !pending_requests_.empty();
-    }
+    bool has_pending_requests() const { return !pending_requests_.empty(); }
 
-    size_t pending_request_count() const {
-      return pending_requests_.size();
-    }
+    size_t pending_request_count() const { return pending_requests_.size(); }
 
     // Gets (but does not remove) the next pending request. Returns
     // NULL if there are no pending requests.
     const Request* GetNextPendingRequest() const;
 
     // Returns true if there is a connect job for |handle|.
     bool HasConnectJobForHandle(const ClientSocketHandle* handle) const;
 
     // Inserts the request into the queue based on priority
     // order. Older requests are prioritized over requests of equal
@@ skipping 18 matching lines @@
     int active_socket_count() const { return active_socket_count_; }
     std::list<IdleSocket>* mutable_idle_sockets() { return &idle_sockets_; }
 
    private:
     // Returns the iterator's pending request after removing it from
     // the queue.
     scoped_ptr<const Request> RemovePendingRequest(
         const RequestQueue::Pointer& pointer);
 
     // Called when the backup socket timer fires.
-    void OnBackupJobTimerFired(
-        std::string group_name,
-        ClientSocketPoolBaseHelper* pool);
+    void OnBackupJobTimerFired(std::string group_name,
+                               ClientSocketPoolBaseHelper* pool);
 
     // Checks that |unassigned_job_count_| does not execeed the number of
     // ConnectJobs.
     void SanityCheck();
 
     // Total number of ConnectJobs that have never been assigned to a Request.
     // Since jobs use late binding to requests, which ConnectJobs have or have
     // not been assigned to a request are not tracked.  This is incremented on
     // preconnect and decremented when a preconnect is assigned, or when there
     // are fewer than |unassigned_job_count_| ConnectJobs.  Not incremented
@@ skipping 36 matching lines @@
   void StartIdleSocketTimer();
 
   // Scans the group map for groups which have an available socket slot and
   // at least one pending request. Returns true if any groups are stalled, and
   // if so (and if both |group| and |group_name| are not NULL), fills |group|
   // and |group_name| with data of the stalled group having highest priority.
   bool FindTopStalledGroup(Group** group, std::string* group_name) const;
 
   // Called when timer_ fires.  This method scans the idle sockets removing
   // sockets that timed out or can't be reused.
-  void OnCleanupTimerFired() {
-    CleanupIdleSockets(false);
-  }
+  void OnCleanupTimerFired() { CleanupIdleSockets(false); }
 
   // Removes |job| from |group|, which must already own |job|.
   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);
 
@@ skipping 24 matching lines @@
   // it does not handle logging into NetLog of the queueing status of
   // |request|.
   int RequestSocketInternal(const std::string& group_name,
                             const Request& request);
 
   // Assigns an idle socket for the group to the request.
   // Returns |true| if an idle socket is available, false otherwise.
   bool AssignIdleSocketToRequest(const Request& request, Group* group);
 
   static void LogBoundConnectJobToRequest(
-      const NetLog::Source& connect_job_source, const Request& request);
+      const NetLog::Source& connect_job_source,
+      const Request& request);
 
   // Same as CloseOneIdleSocket() except it won't close an idle socket in
   // |group|.  If |group| is NULL, it is ignored.  Returns true if it closed a
   // socket.
   bool CloseOneIdleSocketExceptInGroup(const Group* group);
 
   // Checks if there are stalled socket groups that should be notified
   // for possible wakeup.
   void CheckForStalledSocketGroups();
 
   // Posts a task to call InvokeUserCallback() on the next iteration through the
   // current message loop.  Inserts |callback| into |pending_callback_map_|,
   // keyed by |handle|.
-  void InvokeUserCallbackLater(
-      ClientSocketHandle* handle, const CompletionCallback& callback, int rv);
+  void InvokeUserCallbackLater(ClientSocketHandle* handle,
+                               const CompletionCallback& callback,
+                               int rv);
 
   // Invokes the user callback for |handle|.  By the time this task has run,
   // it's possible that the request has been cancelled, so |handle| may not
   // exist in |pending_callback_map_|.  We look up the callback and result code
   // in |pending_callback_map_|.
   void InvokeUserCallback(ClientSocketHandle* handle);
 
   // Tries to close idle sockets in a higher level socket pool as long as this
   // this pool is stalled.
   void TryToCloseSocketsInLayeredPools();
@@ skipping 66 matching lines @@
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
             internal::ClientSocketPoolBaseHelper::Flags flags,
             bool ignore_limits,
             const scoped_refptr<SocketParams>& params,
             const BoundNetLog& net_log)
-        : internal::ClientSocketPoolBaseHelper::Request(
-              handle, callback, priority, ignore_limits, flags, net_log),
+        : internal::ClientSocketPoolBaseHelper::Request(handle,
+                                                        callback,
+                                                        priority,
+                                                        ignore_limits,
+                                                        flags,
+                                                        net_log),
           params_(params) {}
 
     const scoped_refptr<SocketParams>& params() const { return params_; }
 
    private:
     const scoped_refptr<SocketParams> params_;
   };
 
   class ConnectJobFactory {
    public:
@@ skipping 10 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   // |max_sockets| is the maximum number of sockets to be maintained by this
   // ClientSocketPool.  |max_sockets_per_group| specifies the maximum number of
   // sockets a "group" can have.  |unused_idle_socket_timeout| specifies how
   // long to leave an unused idle socket open before closing it.
   // |used_idle_socket_timeout| specifies how long to leave a previously used
   // idle socket open before closing it.
-  ClientSocketPoolBase(
-      HigherLayeredPool* self,
-      int max_sockets,
-      int max_sockets_per_group,
-      ClientSocketPoolHistograms* histograms,
-      base::TimeDelta unused_idle_socket_timeout,
-      base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory)
+  ClientSocketPoolBase(HigherLayeredPool* self,
+                       int max_sockets,
+                       int max_sockets_per_group,
+                       ClientSocketPoolHistograms* histograms,
+                       base::TimeDelta unused_idle_socket_timeout,
+                       base::TimeDelta used_idle_socket_timeout,
+                       ConnectJobFactory* connect_job_factory)
       : histograms_(histograms),
-        helper_(self, max_sockets, max_sockets_per_group,
-                unused_idle_socket_timeout, used_idle_socket_timeout,
+        helper_(self,
+                max_sockets,
+                max_sockets_per_group,
+                unused_idle_socket_timeout,
+                used_idle_socket_timeout,
                 new ConnectJobFactoryAdaptor(connect_job_factory)) {}
 
   virtual ~ClientSocketPoolBase() {}
 
   // These member functions simply forward to ClientSocketPoolBaseHelper.
   void AddLowerLayeredPool(LowerLayeredPool* lower_pool) {
     helper_.AddLowerLayeredPool(lower_pool);
   }
 
   void AddHigherLayeredPool(HigherLayeredPool* higher_pool) {
     helper_.AddHigherLayeredPool(higher_pool);
   }
 
   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) {
     helper_.RemoveHigherLayeredPool(higher_pool);
   }
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().
   int RequestSocket(const std::string& group_name,
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log) {
     scoped_ptr<const Request> request(
-        new Request(handle, callback, priority,
+        new Request(handle,
+                    callback,
+                    priority,
                     internal::ClientSocketPoolBaseHelper::NORMAL,
                     params->ignore_limits(),
-                    params, net_log));
+                    params,
+                    net_log));
     return helper_.RequestSocket(
         group_name,
         request.template PassAs<
             const internal::ClientSocketPoolBaseHelper::Request>());
   }
 
   // RequestSockets bundles up the parameters into a Request and then forwards
   // to ClientSocketPoolBaseHelper::RequestSockets().  Note that it assigns the
   // priority to DEFAULT_PRIORITY and specifies the NO_IDLE_SOCKETS flag.
   void RequestSockets(const std::string& group_name,
@@ skipping 64 matching lines @@
 
   base::DictionaryValue* GetInfoAsValue(const std::string& name,
                                         const std::string& type) const {
     return helper_.GetInfoAsValue(name, type);
   }
 
   base::TimeDelta ConnectionTimeout() const {
     return helper_.ConnectionTimeout();
   }
 
-  ClientSocketPoolHistograms* histograms() const {
-    return histograms_;
-  }
+  ClientSocketPoolHistograms* histograms() const { return histograms_; }
 
   void EnableConnectBackupJobs() { helper_.EnableConnectBackupJobs(); }
 
   bool CloseOneIdleSocket() { return helper_.CloseOneIdleSocket(); }
 
   bool CloseOneIdleConnectionInHigherLayeredPool() {
     return helper_.CloseOneIdleConnectionInHigherLayeredPool();
   }
 
  private:
@@ skipping 31 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_