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

net/socket/client_socket_pool_base.cc

Index: net/socket/client_socket_pool_base.cc
diff --git a/net/socket/client_socket_pool_base.cc b/net/socket/client_socket_pool_base.cc
index 231254a5b7d5cb126920812afbeea606bdf7b2be..754d637565171f6252aad4c479f608f781cbc554 100644
--- a/net/socket/client_socket_pool_base.cc
+++ b/net/socket/client_socket_pool_base.cc
@@ -182,6 +182,7 @@ ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
       handed_out_socket_count_(0),
       max_sockets_(max_sockets),
       max_sockets_per_group_(max_sockets_per_group),
+      use_cleanup_timer_(true),
       unused_idle_socket_timeout_(unused_idle_socket_timeout),
       used_idle_socket_timeout_(used_idle_socket_timeout),
       connect_job_factory_(connect_job_factory),
@@ -191,6 +192,9 @@ ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 
+#if defined(OS_ANDROID)
+  SetCleanupTimerEnabled(false);
+#endif
   NetworkChangeNotifier::AddIPAddressObserver(this);
 }
 
@@ -248,6 +252,9 @@ int ClientSocketPoolBaseHelper::RequestSocket(
   } else {
     InsertRequestIntoQueue(request, group->mutable_pending_requests());
   }
+  // Cleanup any timed-out idle sockets if no timer is used.
+  if (!use_cleanup_timer_)
+    CleanupIdleSockets(false);

[mmenke, 2011/11/11 20:19:20]

Wonder if potentially using a more stale than normal socket here could have a
performance impact.  May be interesting to see if calling this at the start of
this function instead makes any difference, at some point in the future.

[selim, 2011/11/11 21:33:06]

I think, if we call cleanup idle sockets first, then under some circumstances,
it can cleanup all idle sockets and the group itself. Then we have to re-create
the group and create a socket immediately, which is slightly less efficient in
terms of CPU usage. I guess your comment is more about network performance. Why
would an idle socket perform worse?

   return rv;
 }
 
@@ -295,6 +302,10 @@ void ClientSocketPoolBaseHelper::RequestSockets(
   if (!deleted_group && group->IsEmpty())
     RemoveGroup(group_name);
 
+  // Cleanup any timed out idle sockets if no timer is used.
+  if (!use_cleanup_timer_)
+    CleanupIdleSockets(false);
+
   if (rv == ERR_IO_PENDING)
     rv = OK;
   request.net_log().EndEventWithNetErrorCode(
@@ -696,9 +707,8 @@ void ClientSocketPoolBaseHelper::EnableConnectBackupJobs() {
 }
 
 void ClientSocketPoolBaseHelper::IncrementIdleCount() {
-  if (++idle_socket_count_ == 1)
-    timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kCleanupInterval), this,
-                 &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
+  if (++idle_socket_count_ == 1 && use_cleanup_timer_)
+    StartIdleSocketTimer();
 }
 
 void ClientSocketPoolBaseHelper::DecrementIdleCount() {
@@ -706,6 +716,21 @@ void ClientSocketPoolBaseHelper::DecrementIdleCount() {
     timer_.Stop();
 }
 
+void ClientSocketPoolBaseHelper::SetCleanupTimerEnabled(bool enabled) {
+  use_cleanup_timer_ = enabled;
+  if (enabled) {
+    if (idle_socket_count_ > 0)
+      StartIdleSocketTimer();
+  } else {
+    timer_.Stop();
+  }
+}
+
+void ClientSocketPoolBaseHelper::StartIdleSocketTimer() {
+  timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kCleanupInterval), this,
+               &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
+}
+
 void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string& group_name,
                                                StreamSocket* socket,
                                                int id) {
@@ -896,8 +921,7 @@ void ClientSocketPoolBaseHelper::ProcessPendingRequest(
       RemoveGroup(group_name);
 
     request->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, rv);
-    InvokeUserCallbackLater(
-        request->handle(), request->callback(), rv);
+    InvokeUserCallbackLater(request->handle(), request->callback(), rv);
   }
 }