A/B experiment for re-establishing TCP connections

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 221 matching lines @@
   }
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
   // sockets that timed out or can't be reused.  Made public for testing.
   void CleanupIdleSockets(bool force);
 
   base::TimeDelta ConnectionTimeout() const {
     return connect_job_factory_->ConnectionTimeout();
   }
 
-  void EnableBackupJobs() { backup_jobs_enabled_ = true; }
+  static void set_connect_backup_jobs_enabled(bool enabled);
+  void EnableConnectBackupJobs();
 
  private:
   friend class base::RefCounted<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.
@@ skipping 11 matching lines @@
 
   typedef std::deque<const Request*> RequestQueue;
   typedef std::map<const ClientSocketHandle*, const Request*> RequestMap;
 
   // A Group is allocated per group_name when there are idle sockets or pending
   // requests.  Otherwise, the Group object is removed from the map.
   // |active_socket_count| tracks the number of sockets held by clients.
   struct Group {
     Group()
         : active_socket_count(0),
-          backup_job(NULL),
+          connect_backup_job(NULL),
           backup_task(NULL) {
     }
 
     ~Group() {
       CleanupBackupJob();
     }
 
     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 (connect_backup_job) {
+        delete connect_backup_job;
+        connect_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;
+    ConnectJob* connect_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)
@@ skipping 126 matching lines @@
   // The maximum number of sockets kept per group.
   const int max_sockets_per_group_;
 
   // The time to wait until closing idle sockets.
   const base::TimeDelta unused_idle_socket_timeout_;
   const base::TimeDelta used_idle_socket_timeout_;
 
   const scoped_ptr<ConnectJobFactory> connect_job_factory_;
 
   // TODO(vandebo) Remove when backup jobs move to TCPClientSocketPool
-  bool backup_jobs_enabled_;
+  bool connect_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_;
 
   // Some parts of this class need to know if the destructor is running.
@@ skipping 113 matching lines @@
   }
 
   base::TimeDelta ConnectionTimeout() const {
     return helper_->ConnectionTimeout();
   }
 
   scoped_refptr<ClientSocketPoolHistograms> histograms() const {
     return histograms_;
   }
 
-  void EnableBackupJobs() { helper_->EnableBackupJobs(); }
+  void EnableConnectBackupJobs() { helper_->EnableConnectBackupJobs(); }
 
   void Flush() { helper_->Flush(); }
 
  private:
   // This adaptor class exists to bridge the
   // internal::ClientSocketPoolBaseHelper::ConnectJobFactory and
   // ClientSocketPoolBase::ConnectJobFactory types, allowing clients to use the
   // typesafe ClientSocketPoolBase::ConnectJobFactory, rather than having to
   // static_cast themselves.
   class ConnectJobFactoryAdaptor
@@ skipping 30 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_