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

net/socket/client_socket_pool_base.h

 // 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.
 
 #ifndef NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 #define NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 25 matching lines @@
     Delegate() {}
     virtual ~Delegate() {}
 
     // Alerts the delegate that the connection completed.
     virtual void OnConnectJobComplete(int result, ConnectJob* job) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
+  // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              const ClientSocketHandle* key_handle,
+             base::TimeDelta timeout_duration,
              Delegate* delegate);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
   LoadState load_state() const { return load_state_; }
   const ClientSocketHandle* key_handle() const { return key_handle_; }
 
   // Releases |socket_| to the client.  On connection error, this should return
   // NULL.
   ClientSocket* ReleaseSocket() { return socket_.release(); }
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
   // if it succeeded.
-  virtual int Connect() = 0;
+  int Connect();
 
  protected:
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
   void set_socket(ClientSocket* socket) { socket_.reset(socket); }
   ClientSocket* socket() { return socket_.get(); }
   Delegate* delegate() { return delegate_; }
 
  private:
+  virtual int ConnectInternal() = 0;
+
+  // Alerts the delegate that the ConnectJob has timed out.
+  void OnTimeout();
+
   const std::string group_name_;
   // Temporarily needed until we switch to late binding.
   const ClientSocketHandle* const key_handle_;
-  Delegate* const delegate_;
+  const base::TimeDelta timeout_duration_;
+  // Timer to abort jobs that take too long.
+  base::OneShotTimer<ConnectJob> timer_;
+  Delegate* delegate_;
   LoadState load_state_;
   scoped_ptr<ClientSocket> socket_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets.
 //
 class ClientSocketPoolBase
@@ skipping 72 matching lines @@
   // Enables late binding of sockets.  In this mode, socket requests are
   // decoupled from socket connection jobs.  A socket request may initiate a
   // socket connection job, but there is no guarantee that that socket
   // connection will service the request (for example, a released socket may
   // service the request sooner, or a higher priority request may come in
   // afterward and receive the socket from the job).
   static void EnableLateBindingOfSockets(bool enabled);
 
   // For testing.
   bool may_have_stalled_group() const { return may_have_stalled_group_; }
+  int NumConnectJobsInGroup(const std::string& group_name) const {
+    return group_map_.find(group_name)->second.jobs.size();
+  }
 
  private:
   // Entry for a persistent socket which became idle at time |start_time|.
   struct IdleSocket {
     IdleSocket() : socket(NULL), used(false) {}
     ClientSocket* socket;
     base::TimeTicks start_time;
     bool used;  // Indicates whether or not the socket has been used yet.
 
     // An idle socket should be removed if it can't be reused, or has been idle
@@ skipping 64 matching lines @@
   // sockets that timed out or can't be reused.
   void OnCleanupTimerFired() {
     CleanupIdleSockets(false);
   }
 
   // Removes the ConnectJob corresponding to |handle| from the
   // |connect_job_map_| or |connect_job_set_| depending on whether or not late
   // binding is enabled.  |job| must be non-NULL when late binding is
   // enabled.  Also updates |group| if non-NULL.
   void RemoveConnectJob(const ClientSocketHandle* handle,
-                        ConnectJob* job,
+                        const ConnectJob* job,
                         Group* group);
 
   // Same as OnAvailableSocketSlot except it looks up the Group first to see if
   // it's there.
   void MaybeOnAvailableSocketSlot(const std::string& group_name);
 
   // Might delete the Group from |group_map_|.
   void OnAvailableSocketSlot(const std::string& group_name, Group* group);
 
   // Process a request from a group's pending_requests queue.
@@ skipping 61 matching lines @@
 
   // Controls whether or not we use late binding of sockets.
   static bool g_late_binding;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_