Reland my close on idle socket change.

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2010 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/format_macros.h"
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
@@ skipping 169 matching lines @@
 int ClientSocketPoolBaseHelper::RequestSocketInternal(
     const std::string& group_name,
     const Request* request) {
   DCHECK_GE(request->priority(), 0);
   CompletionCallback* const callback = request->callback();
   CHECK(callback);
   ClientSocketHandle* const handle = request->handle();
   CHECK(handle);
   Group& group = group_map_[group_name];
 
-  // Can we make another active socket now?
-  if (ReachedMaxSocketsLimit() ||
-      !group.HasAvailableSocketSlot(max_sockets_per_group_)) {
-    if (ReachedMaxSocketsLimit()) {
-      // We could check if we really have a stalled group here, but it requires
-      // a scan of all groups, so just flip a flag here, and do the check later.
-      may_have_stalled_group_ = true;
-
-      request->net_log().AddEvent(NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS,
-                                  NULL);
-    } else {
-      request->net_log().AddEvent(
-          NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS_PER_GROUP, NULL);
-    }
-    return ERR_IO_PENDING;
-  }
-
   // Try to reuse a socket.
   while (!group.idle_sockets.empty()) {
     IdleSocket idle_socket = group.idle_sockets.back();
     group.idle_sockets.pop_back();
     DecrementIdleCount();
     if (idle_socket.socket->IsConnectedAndIdle()) {
       // We found one we can reuse!
       base::TimeDelta idle_time =
           base::TimeTicks::Now() - idle_socket.start_time;
       HandOutSocket(
           idle_socket.socket, idle_socket.used, handle, idle_time, &group,
           request->net_log());
       return OK;
     }
     delete idle_socket.socket;
   }
 
+  // Can we make another active socket now?
+  if (!group.HasAvailableSocketSlot(max_sockets_per_group_)) {
+    request->net_log().AddEvent(
+        NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS_PER_GROUP, NULL);
+    return ERR_IO_PENDING;
+  }
+
+  if (ReachedMaxSocketsLimit()) {
+    if (idle_socket_count() > 0) {
+      CloseOneIdleSocket();
+    } else {
+      // We could check if we really have a stalled group here, but it requires
+      // a scan of all groups, so just flip a flag here, and do the check later.
+      may_have_stalled_group_ = true;
+      request->net_log().AddEvent(
+          NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS, NULL);
+      return ERR_IO_PENDING;
+    }
+  }
+
   // See if we already have enough connect jobs or sockets that will be released
   // soon.
   if (group.HasReleasingSockets()) {
     return ERR_IO_PENDING;
   }
 
   // We couldn't find a socket to reuse, so allocate and connect a new one.
   BoundNetLog job_net_log = BoundNetLog::Make(
       request->net_log().net_log(), NetLog::SOURCE_CONNECT_JOB);
   request->net_log().BeginEvent(
@@ skipping 261 matching lines @@
   // sure it doesn't get ridiculously high.
 
   int iterations = 0;
   while (num_releasing_sockets_ == 0) {
     CHECK_LT(iterations, 1000) << "Probably stuck in an infinite loop.";
     std::string top_group_name;
     Group* top_group = NULL;
     int stalled_group_count = FindTopStalledGroup(&top_group, &top_group_name);
     if (stalled_group_count >= 1) {
       if (ReachedMaxSocketsLimit()) {
-        // We can't activate more sockets since we're already at our global
-        // limit.
-        may_have_stalled_group_ = true;
-        return;
+        if (idle_socket_count() > 0) {
+          CloseOneIdleSocket();
+        } else {
+          // We can't activate more sockets since we're already at our global
+          // limit.
+          may_have_stalled_group_ = true;
+          return;
+        }
       }
 
       ProcessPendingRequest(top_group_name, top_group);
     } else {
       may_have_stalled_group_ = false;
       return;
     }
 
     iterations++;
   }
@@ skipping 110 matching lines @@
 void ClientSocketPoolBaseHelper::OnAvailableSocketSlot(
     const std::string& group_name, Group* group) {
   if (may_have_stalled_group_) {
     std::string top_group_name;
     Group* top_group = NULL;
     int stalled_group_count = FindTopStalledGroup(&top_group, &top_group_name);
     if (stalled_group_count == 0 ||
         (stalled_group_count == 1 && top_group->num_releasing_sockets == 0)) {
       may_have_stalled_group_ = false;
     }
-    if (stalled_group_count >= 1)
+    if (stalled_group_count >= 1) {
+      CHECK_GE(1, idle_socket_count());
       ProcessPendingRequest(top_group_name, top_group);
+    }
   } else if (!group->pending_requests.empty()) {
     ProcessPendingRequest(group_name, group);
     // |group| may no longer be valid after this point.  Be careful not to
     // access it again.
   } else if (group->IsEmpty()) {
     // Delete |group| if no longer needed.  |group| will no longer be valid.
     group_map_.erase(group_name);
   }
 }
 
@@ skipping 68 matching lines @@
     if (group.IsEmpty()) {
       group_map_.erase(i++);
     } else {
       ++i;
     }
   }
 }
 
 bool ClientSocketPoolBaseHelper::ReachedMaxSocketsLimit() const {
   // Each connecting socket will eventually connect and be handed out.
-  int total = handed_out_socket_count_ + connecting_socket_count_;
+  int total = handed_out_socket_count_ + connecting_socket_count_ +
+      idle_socket_count();
   DCHECK_LE(total, max_sockets_);
   if (total < max_sockets_)
     return false;
   LOG(WARNING) << "ReachedMaxSocketsLimit: " << total << "/" << max_sockets_;
   return true;
 }
 
+void ClientSocketPoolBaseHelper::CloseOneIdleSocket() {
+  CHECK_GT(idle_socket_count(), 0);
+
+  for (GroupMap::iterator i = group_map_.begin(); i != group_map_.end(); ++i) {
+    Group& group = i->second;
+
+    if (!group.idle_sockets.empty()) {
+      std::deque<IdleSocket>::iterator j = group.idle_sockets.begin();
+      delete j->socket;
+      group.idle_sockets.erase(j);
+      DecrementIdleCount();
+      if (group.IsEmpty())
+        group_map_.erase(i);
+
+      return;
+    }
+  }
+
+  LOG(DFATAL) << "No idle socket found to close!.";
+}
+
 }  // namespace internal
 
 }  // namespace net