Close idle sockets next time we are about to send data.

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 27 matching lines @@
 #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_export.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_pool.h"
 #include "net/socket/stream_socket.h"
+#include "net/socket/client_socket_pool_options.h"
 
 namespace net {
 
 class ClientSocketHandle;
 
 // Returns the client socket reuse policy.
 NET_EXPORT_PRIVATE int GetSocketReusePolicy();
 
 // Sets the client socket reuse policy.
 // NOTE: 'policy' should be a valid ClientSocketReusePolicy enum value.
@@ skipping 170 matching lines @@
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBaseHelper(
       int max_sockets,
       int max_sockets_per_group,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
-      ConnectJobFactory* connect_job_factory);
+      ConnectJobFactory* connect_job_factory,
+      const ClientSocketPoolOptions& options);
 
   virtual ~ClientSocketPoolBaseHelper();
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   // ClientSocketPoolBaseHelper takes ownership of |request|, which must be
   // heap allocated.
   int RequestSocket(const std::string& group_name, const Request* request);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   void RequestSockets(const std::string& group_name,
@@ skipping 186 matching lines @@
                                                Group* group);
 
   Group* GetOrCreateGroup(const std::string& group_name);
   void RemoveGroup(const std::string& group_name);
   void RemoveGroup(GroupMap::iterator it);
 
   // Called when the number of idle sockets changes.
   void IncrementIdleCount();
   void DecrementIdleCount();
 
+  // Start cleanup timer for idle sockets.
+  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, fills |group| and |group_name| with data of the stalled group
   // having highest priority.
   bool FindTopStalledGroup(Group** group, std::string* group_name);
 
   // Called when timer_ fires.  This method scans the idle sockets removing
   // sockets that timed out or can't be reused.
   void OnCleanupTimerFired() {
     CleanupIdleSockets(false);
@@ skipping 90 matching lines @@
 
   // Number of connected sockets we handed out across all groups.
   int handed_out_socket_count_;
 
   // The maximum total number of sockets. See ReachedMaxSocketsLimit.
   const int max_sockets_;
 
   // The maximum number of sockets kept per group.
   const int max_sockets_per_group_;
 
+  // Whether to use timer to cleanup idle sockets.
+  bool use_cleanup_timer_;
+
   // The time to wait until closing idle sockets.
   const base::TimeDelta unused_idle_socket_timeout_;
   const base::TimeDelta used_idle_socket_timeout_;
 
   const scoped_ptr<ConnectJobFactory> connect_job_factory_;
 
   // TODO(vandebo) Remove when backup jobs move to TransportClientSocketPool
   bool connect_backup_jobs_enabled_;
 
   // A unique id for the pool.  It gets incremented every time we Flush() the
@@ skipping 51 matching lines @@
   // 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(
       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)
+      ConnectJobFactory* connect_job_factory,
+      const ClientSocketPoolOptions& options = ClientSocketPoolOptions())
       : histograms_(histograms),
         helper_(max_sockets, max_sockets_per_group,
                 unused_idle_socket_timeout, used_idle_socket_timeout,
-                new ConnectJobFactoryAdaptor(connect_job_factory)) {}
+                new ConnectJobFactoryAdaptor(connect_job_factory),
+                options) {}
 
   virtual ~ClientSocketPoolBase() {}
 
   // These member functions simply forward to ClientSocketPoolBaseHelper.
 
   // 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,
@@ skipping 120 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_