Refactor how ClientSocketPoolBaseHelper avoids re-entrancy.

net/socket/client_socket_pool_base.h

 // 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 170 matching lines @@
       base::TimeDelta used_idle_socket_timeout,
       ConnectJobFactory* connect_job_factory);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   // ClientSocketPoolBaseHelper takes ownership of |request|, which must be
   // heap allocated.
   int RequestSocket(const std::string& group_name, const Request* request);
 
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
-                     const ClientSocketHandle* handle);
+                     ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
                      ClientSocket* socket,
                      int id);
 
   // See ClientSocketPool::Flush for documentation on this function.
   void Flush();
 
   // See ClientSocketPool::CloseIdleSockets for documentation on this function.
@@ skipping 34 matching lines @@
 
   base::TimeDelta ConnectionTimeout() const {
     return connect_job_factory_->ConnectionTimeout();
   }
 
   void EnableBackupJobs() { backup_jobs_enabled_ = true; }
 
  private:
   friend class base::RefCounted<ClientSocketPoolBaseHelper>;
 
-  ~ClientSocketPoolBaseHelper();
-
   // 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
     // for too long. |now| is the current time value (TimeTicks::Now()).
     // |timeout| is the length of time to wait before timing out an idle socket.
@@ skipping 25 matching lines @@
     bool IsEmpty() const {
       return active_socket_count == 0 && idle_sockets.empty() && jobs.empty() &&
           pending_requests.empty();
     }
 
     bool HasAvailableSocketSlot(int max_sockets_per_group) const {
       return active_socket_count + static_cast<int>(jobs.size()) <
           max_sockets_per_group;
     }
 
+    bool IsStalled(int max_sockets_per_group) const {
+      return HasAvailableSocketSlot(max_sockets_per_group) &&
+          pending_requests.size() > jobs.size();
+    }
+
     RequestPriority TopPendingPriority() const {
       return pending_requests.front()->priority();
     }
 
     void CleanupBackupJob() {
       if (backup_job) {
         delete backup_job;
         backup_job = NULL;
       }
       if (backup_task) {
         backup_task->Cancel();
         backup_task = NULL;
       }
     }
 
     std::deque<IdleSocket> idle_sockets;
     std::set<const ConnectJob*> jobs;
     RequestQueue pending_requests;
     int active_socket_count;  // number of active sockets used by clients
     // A backup job in case the connect for this group takes too long.
     ConnectJob* backup_job;
     CancelableTask* backup_task;
   };
 
   typedef std::map<std::string, Group> GroupMap;
 
   typedef std::set<const ConnectJob*> ConnectJobSet;
 
+  struct CallbackResultPair {
+    CallbackResultPair() : callback(NULL), result(OK) {}
+    CallbackResultPair(CompletionCallback* callback_in, int result_in)
+        : callback(callback_in), result(result_in) {}
+
+    CompletionCallback* callback;
+    int result;
+  };
+
+  typedef std::map<const ClientSocketHandle*, CallbackResultPair>
+      PendingCallbackMap;
+
+  ~ClientSocketPoolBaseHelper();
+
   static void InsertRequestIntoQueue(const Request* r,
                                      RequestQueue* pending_requests);
   static const Request* RemoveRequestFromQueue(RequestQueue::iterator it,
                                                RequestQueue* pending_requests);
 
   // Called when the number of idle sockets changes.
   void IncrementIdleCount();
   void DecrementIdleCount();
 
   // Scans the group map for groups which have an available socket slot and
-  // at least one pending request. Returns number of groups found, and if found
-  // at least one, fills |group| and |group_name| with data of the stalled group
+  // at least one pending request. Returns true if any groups are stalled, and
+  // if so, fills |group| and |group_name| with data of the stalled group
   // having highest priority.
-  int FindTopStalledGroup(Group** group, std::string* group_name);
+  bool FindTopStalledGroup(Group** group, std::string* group_name);
 
   // Called when timer_ fires.  This method scans the idle sockets removing
   // sockets that timed out or can't be reused.
   void OnCleanupTimerFired() {
     CleanupIdleSockets(false);
   }
 
   // Removes |job| from |connect_job_set_|.  Also updates |group| if non-NULL.
   void RemoveConnectJob(const ConnectJob* job, Group* group);
 
-  // Might delete the Group from |group_map_|.
-  // If |was_at_socket_limit|, will also check for idle sockets to assign
-  // to any stalled groups.
-  void OnAvailableSocketSlot(const std::string& group_name,
-                             bool was_at_socket_limit);
+  // Tries to see if we can handle any more requests for |group|.
+  void OnAvailableSocketSlot(const std::string& group_name, Group* group);
 
   // Process a pending socket request for a group.
-  // If |was_at_socket_limit|, will also check for idle sockets to assign
-  // to any stalled groups.
-  void ProcessPendingRequest(const std::string& group_name,
-                             bool was_at_socket_limit);
+  void ProcessPendingRequest(const std::string& group_name, Group* group);
 
   // Assigns |socket| to |handle| and updates |group|'s counters appropriately.
   void HandOutSocket(ClientSocket* socket,
                      bool reused,
                      ClientSocketHandle* handle,
                      base::TimeDelta time_idle,
                      Group* group,
                      const BoundNetLog& net_log);
 
   // Adds |socket| to the list of idle sockets for |group|.  |used| indicates
@@ skipping 31 matching lines @@
   // TODO(willchan): Consider a better algorithm for doing this.  Perhaps we
   // should keep an ordered list of idle sockets, and close them in order.
   // Requires maintaining more state.  It's not clear if it's worth it since
   // I'm not sure if we hit this situation often.
   void CloseOneIdleSocket();
 
   // Checks if there are stalled socket groups that should be notified
   // for possible wakeup.
   void CheckForStalledSocketGroups();
 
-  // Returns true if we might have a stalled group.
-  bool MayHaveStalledGroups();
+  // Posts a task to call InvokeUserCallback() on the next iteration through the
+  // current message loop.  Inserts |callback| into |pending_callback_map_|,
+  // keyed by |handle|.
+  void InvokeUserCallbackLater(
+      ClientSocketHandle* handle, CompletionCallback* callback, int rv);
+
+  // Invokes the user callback for |handle|.  By the time this task has run,
+  // it's possible that the request has been cancelled, so |handle| may not
+  // exist in |pending_callback_map_|.  We look up the callback and result code
+  // in |pending_callback_map_|.
+  void InvokeUserCallback(ClientSocketHandle* handle);
 
   GroupMap group_map_;
 
+  // Map of the ClientSocketHandles for which we have a pending Task to invoke a
+  // callback.  This is necessary since, before we invoke said callback, it's
+  // possible that the request is cancelled.
+  PendingCallbackMap pending_callback_map_;
+
   // Timer used to periodically prune idle sockets that timed out or can't be
   // reused.
   base::RepeatingTimer<ClientSocketPoolBaseHelper> timer_;
 
   // The total number of idle sockets in the system.
   int idle_socket_count_;
 
   // Number of connecting sockets across all groups.
   int connecting_socket_count_;
 
@@ skipping 15 matching lines @@
   // TODO(vandebo) Remove when backup jobs move to TCPClientSocketPool
   bool backup_jobs_enabled_;
 
   // A factory to pin the backup_job tasks.
   ScopedRunnableMethodFactory<ClientSocketPoolBaseHelper> method_factory_;
 
   // A unique id for the pool.  It gets incremented every time we Flush() the
   // pool.  This is so that when sockets get released back to the pool, we can
   // make sure that they are discarded rather than reused.
   int pool_generation_number_;
-
-  // The count of stalled groups the last time we checked.
-  int last_stalled_group_count_;
 };
 
 }  // namespace internal
 
 // The maximum duration, in seconds, to keep used idle persistent sockets alive.
 static const int kUsedIdleSocketTimeout = 300;  // 5 minutes
 
 template <typename SocketParams>
 class ClientSocketPoolBase {
  public:
@@ skipping 60 matching lines @@
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
                     ClientSocketHandle* handle,
                     CompletionCallback* callback,
                     const BoundNetLog& net_log) {
     Request* request = new Request(handle, callback, priority, params, net_log);
     return helper_->RequestSocket(group_name, request);
   }
 
   void CancelRequest(const std::string& group_name,
-                     const ClientSocketHandle* handle) {
+                     ClientSocketHandle* handle) {
     return helper_->CancelRequest(group_name, handle);
   }
 
   void ReleaseSocket(const std::string& group_name, ClientSocket* socket,
                      int id) {
     return helper_->ReleaseSocket(group_name, socket, id);
   }
 
   void CloseIdleSockets() { return helper_->CloseIdleSockets(); }
 
@@ skipping 73 matching lines @@
   // ClientSocketPoolBase<T> reference to drop to zero.  While we're deep
   // in cleanup code, we'll often hold a reference to |self|.
   scoped_refptr<internal::ClientSocketPoolBaseHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_