This CL changes the lifespan of SSLConnectJobMessengers so that they are created only when needed,

net/socket/client_socket_pool_base.h

 // Copyright (c) 2012 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 185 matching lines @@
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const Request& request,
-        ConnectJob::Delegate* delegate) const = 0;
+        ConnectJob::Delegate* delegate) = 0;

[wtc, 2014/08/12 14:51:00]

Why can't this method be const? I guess it's because the method may need to
modify the MessengerMap? But you moved the MessengerMap from the
SSLConnectJobFactory class to the SSLClientSocketPool class. So it seems that
this method can still be const.

[mshelley, 2014/08/12 21:47:00]

Done.

 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBaseHelper(
       HigherLayeredPool* pool,
       int max_sockets,
@@ skipping 67 matching lines @@
   int NumConnectJobsInGroup(const std::string& group_name) const {
     return group_map_.find(group_name)->second->jobs().size();
   }
 
   int NumActiveSocketsInGroup(const std::string& group_name) const {
     return group_map_.find(group_name)->second->active_socket_count();
   }
 
   bool HasGroup(const std::string& group_name) const;
 
+  void RemoveMessengersFromGroup(const std::string& group_name,
+                                 const std::string& cache_key) const;

[Ryan Sleevi, 2014/08/12 00:27:42]

This feels like a layering violation. ClientSocketPoolBase applies to all client
sockets, but Messengers are strictly an SSL-layer concept (e.g. they do not
exist for SOCKS proxies or TCP connections)

[mshelley, 2014/08/12 21:47:00]

Done.

+
   // Called to enable/disable cleaning up idle sockets. When enabled,
   // idle sockets that have been around for longer than a period defined
   // by kCleanupInterval are cleaned up using a timer. Otherwise they are
   // closed next time client makes a request. This may reduce network
   // activity and power consumption.
   static bool cleanup_timer_enabled();
   static bool set_cleanup_timer_enabled(bool enabled);
 
   // 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.
@@ skipping 103 matching lines @@
 
     // If there's a ConnectJob that's never been assigned to Request,
     // decrements |unassigned_job_count_| and returns true.
     // Otherwise, returns false.
     bool TryToUseUnassignedConnectJob();
 
     void AddJob(scoped_ptr<ConnectJob> job, bool is_preconnect);
     // Remove |job| from this group, which must already own |job|.
     void RemoveJob(ConnectJob* job);
     void RemoveAllJobs();
+    void RemoveMessengers(const std::string& cache_key);
 
     bool has_pending_requests() const {
       return !pending_requests_.empty();
     }
 
     size_t pending_request_count() const {
       return pending_requests_.size();
     }
 
     // Gets (but does not remove) the next pending request. Returns
@@ skipping 252 matching lines @@
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const Request& request,
-        ConnectJob::Delegate* delegate) const = 0;
+        ConnectJob::Delegate* delegate) = 0;
 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   // |max_sockets| is the maximum number of sockets to be maintained by this
   // ClientSocketPool.  |max_sockets_per_group| specifies the maximum number of
   // sockets a "group" can have.  |unused_idle_socket_timeout| specifies how
@@ skipping 105 matching lines @@
   }
 
   int NumActiveSocketsInGroup(const std::string& group_name) const {
     return helper_.NumActiveSocketsInGroup(group_name);
   }
 
   bool HasGroup(const std::string& group_name) const {
     return helper_.HasGroup(group_name);
   }
 
+  void RemoveMessengersFromGroup(const std::string& group_name,
+                                 const std::string& cache_key) const {
+    return helper_.RemoveMessengersFromGroup(group_name, cache_key);
+  }
+
   void CleanupIdleSockets(bool force) {
     return helper_.CleanupIdleSockets(force);
   }
 
   base::DictionaryValue* GetInfoAsValue(const std::string& name,
                                         const std::string& type) const {
     return helper_.GetInfoAsValue(name, type);
   }
 
   base::TimeDelta ConnectionTimeout() const {
@@ skipping 24 matching lines @@
     typedef typename ClientSocketPoolBase<SocketParams>::ConnectJobFactory
         ConnectJobFactory;
 
     explicit ConnectJobFactoryAdaptor(ConnectJobFactory* connect_job_factory)
         : connect_job_factory_(connect_job_factory) {}
     virtual ~ConnectJobFactoryAdaptor() {}
 
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const internal::ClientSocketPoolBaseHelper::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE {
+        ConnectJob::Delegate* delegate) OVERRIDE {
       const Request& casted_request = static_cast<const Request&>(request);
       return connect_job_factory_->NewConnectJob(
           group_name, casted_request, delegate);
     }
 
     virtual base::TimeDelta ConnectionTimeout() const {
       return connect_job_factory_->ConnectionTimeout();
     }
 
     const scoped_ptr<ConnectJobFactory> connect_job_factory_;
   };
 
   // Histograms for the pool
   ClientSocketPoolHistograms* const histograms_;
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_