Fix preconnect crash when we hit max socket limit.

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/metrics/stats_counters.h"
@@ skipping 228 matching lines @@
   request.net_log().BeginEvent(
       NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS,
       make_scoped_refptr(new NetLogIntegerParameter(
           "num_sockets", num_sockets)));
 
   Group* group = GetOrCreateGroup(group_name);
 
   for (int num_iterations_left = num_sockets;
        group->NumActiveSocketSlots() < num_sockets &&
        num_iterations_left > 0 ; num_iterations_left--) {
     int rv = RequestSocketInternal(group_name, &request);

[willchan no longer on Chromium, 2010/12/02 01:58:07]

Should I special case ERR_PRECONNECT_MAX_SOCKET_LIMIT here so I can add a new
NetLog EventParameter for TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS so we can tell
when preconnect is not warming up any more sockets due to the max socket limit? 
Will anyone read this?

[Mike Belshe, 2010/12/02 02:46:48]

It's up to you.  Maybe add a TODO

     if (rv < 0 && rv != ERR_IO_PENDING) {
       // We're encountering a synchronous error.  Give up.
       break;
     }
   }
 
   if (group->IsEmpty())
     RemoveGroup(group_name);
 
   request.net_log().EndEvent(
@@ skipping 19 matching lines @@
 
   // 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();
+      bool closed = CloseOneIdleSocketExceptInGroup(group);
+      if (preconnecting && !closed)
+        return ERR_PRECONNECT_MAX_SOCKET_LIMIT;
     } 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.
       request->net_log().AddEvent(
           NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS, NULL);
       return ERR_IO_PENDING;
     }
   }
 
   // We couldn't find a socket to reuse, so allocate and connect a new one.
@@ skipping 621 matching lines @@
   // Each connecting socket will eventually connect and be handed out.
   int total = handed_out_socket_count_ + connecting_socket_count_ +
       idle_socket_count();
   DCHECK_LE(total, max_sockets_);
   if (total < max_sockets_)
     return false;
   return true;
 }
 
 void ClientSocketPoolBaseHelper::CloseOneIdleSocket() {
+  CloseOneIdleSocketExceptInGroup(NULL);
+}
+
+bool ClientSocketPoolBaseHelper::CloseOneIdleSocketExceptInGroup(
+    const Group* exception_group) {
   CHECK_GT(idle_socket_count(), 0);
 
   for (GroupMap::iterator i = group_map_.begin(); i != group_map_.end(); ++i) {
     Group* group = i->second;
+    if (exception_group == group)
+      continue;
     std::list<IdleSocket>* idle_sockets = group->mutable_idle_sockets();
 
     if (!idle_sockets->empty()) {
       delete idle_sockets->front().socket;
       idle_sockets->pop_front();
       DecrementIdleCount();
       if (group->IsEmpty())
         RemoveGroup(i);
 
-      return;
+      return true;
     }
   }
 
-  LOG(DFATAL) << "No idle socket found to close!.";
+  if (!exception_group)
+    LOG(DFATAL) << "No idle socket found to close!.";
+
+  return false;
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallbackLater(
     ClientSocketHandle* handle, CompletionCallback* callback, int rv) {
   CHECK(!ContainsKey(pending_callback_map_, handle));
   pending_callback_map_[handle] = CallbackResultPair(callback, rv);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(
           &ClientSocketPoolBaseHelper::InvokeUserCallback,
@@ skipping 88 matching lines @@
   // Delete active jobs.
   STLDeleteElements(&jobs_);
 
   // Cancel pending backup job.
   method_factory_.RevokeAll();
 }
 
 }  // namespace internal
 
 }  // namespace net