Add timeouts for ConnectJobs. Limit ConnectJobs per group to number of Requests per group + 1.

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"
@@ skipping 16 matching lines @@
 const int kIdleTimeout = 300;  // 5 minutes.
 
 }  // namespace
 
 namespace net {
 
 bool ClientSocketPoolBase::g_late_binding = false;
 
 ConnectJob::ConnectJob(const std::string& group_name,
                        const ClientSocketHandle* key_handle,
+                       base::TimeDelta timeout_duration,
                        Delegate* delegate)
     : group_name_(group_name),
       key_handle_(key_handle),
+      timeout_duration_(timeout_duration),
       delegate_(delegate),
       load_state_(LOAD_STATE_IDLE) {
   DCHECK(!group_name.empty());
   DCHECK(key_handle);
   DCHECK(delegate);
 }
 
 ConnectJob::~ConnectJob() {}
 
+int ConnectJob::Connect() {
+  if (timeout_duration_ != base::TimeDelta())
+    timer_.Start(timeout_duration_, this, &ConnectJob::OnTimeout);
+  return ConnectInternal();
+}
+
+void ConnectJob::OnTimeout() {
+  // The delegate will delete |this|.
+  Delegate *delegate = delegate_;
+  delegate_ = NULL;
+  delegate->OnConnectJobComplete(ERR_TIMED_OUT, this);
+}
+
 ClientSocketPoolBase::ClientSocketPoolBase(
     int max_sockets,
     int max_sockets_per_group,
     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),
       may_have_stalled_group_(false),
@@ skipping 98 matching lines @@
                                          const ClientSocketHandle* handle) {
   CHECK(ContainsKey(group_map_, group_name));
 
   Group& group = group_map_[group_name];
 
   // Search pending_requests for matching handle.
   RequestQueue::iterator it = group.pending_requests.begin();
   for (; it != group.pending_requests.end(); ++it) {
     if (it->handle == handle) {
       group.pending_requests.erase(it);
+      if (g_late_binding &&
+          group.jobs.size() > group.pending_requests.size() + 1) {
+        // TODO(willchan): Cancel the job in the earliest LoadState.
+        RemoveConnectJob(handle, *group.jobs.begin(), &group);
+        OnAvailableSocketSlot(group_name, &group);
+      }
       return;
     }
   }
 
   if (!g_late_binding) {
     // It's invalid to cancel a non-existent request.
     CHECK(ContainsKey(group.connecting_requests, handle));
 
     RequestMap::iterator map_it = group.connecting_requests.find(handle);
     if (map_it != group.connecting_requests.end()) {
@@ skipping 233 matching lines @@
     HandOutSocket(socket.release(), false /* not reused */, handle, &group);
     callback->Run(result);
   }
 }
 
 void ClientSocketPoolBase::EnableLateBindingOfSockets(bool enabled) {
   g_late_binding = enabled;
 }
 
 void ClientSocketPoolBase::RemoveConnectJob(
-    const ClientSocketHandle* handle, ConnectJob *job, Group* group) {
+    const ClientSocketHandle* handle, const ConnectJob *job, Group* group) {
   CHECK(connecting_socket_count_ > 0);
   connecting_socket_count_--;
 
   if (g_late_binding) {
     DCHECK(job);
     delete job;
   } else {
     ConnectJobMap::iterator it = connect_job_map_.find(handle);
     CHECK(it != connect_job_map_.end());
     job = it->second;
@@ skipping 96 matching lines @@
 }
 
 bool ClientSocketPoolBase::ReachedMaxSocketsLimit() const {
   // Each connecting socket will eventually connect and be handed out.
   int total = handed_out_socket_count_ + connecting_socket_count_;
   DCHECK_LE(total, max_sockets_);
   return total == max_sockets_;
 }
 
 }  // namespace net