Control the amount of time to leave an unused socket idle before closing it.

net/socket/client_socket_pool_base.cc

 // 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.
 
 #include "net/socket/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_handle.h"
 
 using base::TimeDelta;
 
 namespace {
 
 // The timeout value, in seconds, used to clean up idle sockets that can't be
 // reused.
 //
 // Note: It's important to close idle sockets that have received data as soon
 // as possible because the received data may cause BSOD on Windows XP under
 // some conditions.  See http://crbug.com/4606.
 const int kCleanupInterval = 10;  // DO NOT INCREASE THIS TIMEOUT.
 
-// The maximum duration, in seconds, to keep idle persistent sockets alive.
-const int kIdleTimeout = 300;  // 5 minutes.
-
 }  // namespace
 
 namespace net {
 
 ConnectJob::ConnectJob(const std::string& group_name,
                        const ClientSocketHandle* key_handle,
                        base::TimeDelta timeout_duration,
                        Delegate* delegate,
                        LoadLog* load_log)
     : group_name_(group_name),
@@ skipping 52 matching lines @@
   NotifyDelegateOfCompletion(ERR_TIMED_OUT);
 }
 
 namespace internal {
 
 bool ClientSocketPoolBaseHelper::g_late_binding = false;
 
 ClientSocketPoolBaseHelper::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)
     : idle_socket_count_(0),
       connecting_socket_count_(0),
       handed_out_socket_count_(0),
       max_sockets_(max_sockets),
       max_sockets_per_group_(max_sockets_per_group),
+      unused_idle_socket_timeout_(unused_idle_socket_timeout),
+      used_idle_socket_timeout_(used_idle_socket_timeout),
       may_have_stalled_group_(false),
       connect_job_factory_(connect_job_factory) {
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 }
 
 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
   if (g_late_binding)
     CancelAllConnectJobs();
   // Clean up any idle sockets.  Assert that we have no remaining active
@@ skipping 215 matching lines @@
         return LOAD_STATE_IDLE;
       }
     }
   }
 
   NOTREACHED();
   return LOAD_STATE_IDLE;
 }
 
 bool ClientSocketPoolBaseHelper::IdleSocket::ShouldCleanup(
-    base::TimeTicks now) const {
-  bool timed_out = (now - start_time) >=
-      base::TimeDelta::FromSeconds(kIdleTimeout);
+    base::TimeTicks now,
+    base::TimeDelta timeout) const {
+  bool timed_out = (now - start_time) >= timeout;
   return timed_out ||
       !(used ? socket->IsConnectedAndIdle() : socket->IsConnected());
 }
 
 void ClientSocketPoolBaseHelper::CleanupIdleSockets(bool force) {
   if (idle_socket_count_ == 0)
     return;
 
   // Current time value. Retrieving it once at the function start rather than
   // inside the inner loop, since it shouldn't change by any meaningful amount.
   base::TimeTicks now = base::TimeTicks::Now();
 
   GroupMap::iterator i = group_map_.begin();
   while (i != group_map_.end()) {
     Group& group = i->second;
 
     std::deque<IdleSocket>::iterator j = group.idle_sockets.begin();
     while (j != group.idle_sockets.end()) {
-      if (force || j->ShouldCleanup(now)) {
+      base::TimeDelta timeout =
+          j->used ? used_idle_socket_timeout_ : unused_idle_socket_timeout_;
+      if (force || j->ShouldCleanup(now, timeout)) {
         delete j->socket;
         j = group.idle_sockets.erase(j);
         DecrementIdleCount();
       } else {
         ++j;
       }
     }
 
     // Delete group if no longer needed.
     if (group.IsEmpty()) {
@@ skipping 271 matching lines @@
   return total == max_sockets_;
 }
 
 }  // namespace internal
 
 void EnableLateBindingOfSockets(bool enabled) {
   internal::ClientSocketPoolBaseHelper::EnableLateBindingOfSockets(enabled);
 }
 
 }  // namespace net