Add a bound on the total number of active sockets in ClientSocketPool....

net/base/client_socket_pool.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef NET_BASE_CLIENT_SOCKET_POOL_H_
 #define NET_BASE_CLIENT_SOCKET_POOL_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 10 matching lines @@
 
 // A ClientSocketPool is used to restrict the number of sockets open at a time.
 // It also maintains a list of idle persistent sockets.
 //
 // The ClientSocketPool allocates scoped_ptr<ClientSocket> objects, but it is
 // not responsible for allocating the associated ClientSocket objects.  The
 // consumer must do so if it gets a scoped_ptr<ClientSocket> with a null value.
 //
 class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
  public:
-  explicit ClientSocketPool(int max_sockets_per_group);
+  // Construct a socket pool with the given limits.
+  //
+  // |max_sockets_per_group|:
+  //   The total number of active sockets allowed per "group".
+  //   (A "group" generally corresponds with a single host, so this is
+  //   effectively the connections-per-host bound).
+  //
+  // |max_sockets|:
+  //   The total number of active sockets across all groups.
+  //
+  // TODO(eroman): would be nice to define these in terms of "open" sockets
+  // instead (active + idle).
+  ClientSocketPool(int max_sockets_per_group, int max_sockets);
 
   // Called to request a socket for the given handle.  There are three possible
   // results: 1) the handle will be initialized with a socket to reuse, 2) the
   // handle will be initialized without a socket such that the consumer needs
   // to supply a socket, or 3) the handle will be added to a wait list until a
   // socket is available to reuse or the opportunity to create a new socket
   // arises.  The completion callback is notified in the 3rd case.  |priority|
   // will determine the placement into the wait list.
   //
   // If this function returns OK, then |handle| is initialized upon return.
@@ skipping 61 matching lines @@
 
   typedef std::deque<Request> RequestQueue;
 
   // A Group is allocated per group_name when there are idle sockets or pending
   // requests.  Otherwise, the Group object is removed from the map.
   struct Group {
     Group() : active_socket_count(0) {}
     std::deque<IdleSocket> idle_sockets;
     RequestQueue pending_requests;
     int active_socket_count;
+
+    bool empty() const {
+      return active_socket_count == 0 && idle_sockets.empty() &&
+          pending_requests.empty();
+    }
   };
 
   typedef std::map<std::string, Group> GroupMap;
 
   ~ClientSocketPool();
 
   static void InsertRequestIntoQueue(const Request& r,
                                      RequestQueue* pending_requests);
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
   // sockets that timed out or can't be reused.
   void CleanupIdleSockets(bool force);
 
   // Called when the number of idle sockets changes.
   void IncrementIdleCount();
   void DecrementIdleCount();
 
   // Called via PostTask by ReleaseSocket.
   void DoReleaseSocket(const std::string& group_name, ClientSocketPtr* ptr);
 
+  // Dequeue and start the highest priority pending request in |group|.
+  void StartPendingRequestForGroup(Group* group);
+
+  // Finds the group containing the highest priority pending request, and which
+  // has fewer than |max_sockets_per_group_| active sockets. Returns NULL if
+  // there is no such group.
+  Group* FindTopStalledGroup();
+
+  // Until the maximum number of sockets limit is reached, a group can ONLY
+  // have pending requests if it exceeds the "max sockets per group" limit.
+  //
+  // This means when a socket is released, the only pending requests that can
+  // be started next belong to the same group.
+  //
+  // However once the |max_sockets_| limit is reached, this stops being true:
+  // groups can now have pending requests without having first reached the
+  // |max_sockets_per_group_| limit. So choosing the next request involves
+  // selecting the highest priority request across *all* groups.
+  //
+  // Since reaching the maximum number of sockets is an edge case, we make note
+  // of when it happens with the following variable, and thus avoid doing
+  // the slower "scan all groups" in the common case.
+  bool may_have_stalled_group_;
+
   // Called when timer_ fires.  This method scans the idle sockets removing
   // sockets that timed out or can't be reused.
   void OnCleanupTimerFired() {
     CleanupIdleSockets(false);
   }
 
   GroupMap group_map_;
 
   // Timer used to periodically prune idle sockets that timed out or can't be
   // reused.
   base::RepeatingTimer<ClientSocketPool> timer_;
 
   // The total number of idle sockets in the system.
   int idle_socket_count_;
 
-  // The maximum number of sockets kept per group.
+  // The total number of active sockets in the system.
+  int active_socket_count_;
+
+  // The maximum number of active sockets kept per group.
   int max_sockets_per_group_;
 
+  // The maximum number of active sockets kept across all groups.
+  int max_sockets_;
+
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPool);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_CLIENT_SOCKET_POOL_H_