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

net/socket/ssl_client_socket_pool.cc

 // 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.
 
 #include "net/socket/ssl_client_socket_pool.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 81 matching lines @@
 const scoped_refptr<HttpProxySocketParams>&
 SSLSocketParams::GetHttpProxyConnectionParams() const {
   DCHECK_EQ(GetConnectionType(), HTTP_PROXY);
   return http_proxy_params_;
 }
 
 SSLConnectJobMessenger::SSLConnectJobMessenger() : weak_factory_(this) {
 }
 
 bool SSLConnectJobMessenger::CanProceed(SSLClientSocket* ssl_socket) {
-  // If the session is in the session cache, or there are no connecting
-  // sockets allow the connection to proceed.
-  if (ssl_socket->InSessionCache() || connecting_sockets_.empty()) {
-    return true;
-  }
-  return false;
+  // If there are no connecting sockets allow the connection to proceed.
+  return connecting_sockets_.empty();
 }
 
 void SSLConnectJobMessenger::MonitorConnectionResult(
     SSLClientSocket* ssl_socket) {
   connecting_sockets_.push_back(ssl_socket);
   ssl_socket->SetIsLeader();
   // SSLConnectJobMessenger weak_ptrs are used here to ensure that
   // tasks posted with these callbacks are deregistered if the
   // SSLConnectJobMessenger should become invalid before they're run.
   ssl_socket->SetSocketFailureCallback(base::Bind(
@@ skipping 44 matching lines @@
   // Erase all deleted sockets and their callbacks, as well as the socket that
   // will
   // be connected next.
   pending_sockets_and_callbacks_.erase(pending_sockets_and_callbacks_.begin(),
                                        ++it);
 
   MonitorConnectionResult(ssl_socket);
   callback.Run();
 }
 
+bool SSLConnectJobMessenger::IsNeeded() {
+  return pending_sockets_and_callbacks_.empty() && connecting_sockets_.empty();
+}
+
 void SSLConnectJobMessenger::RunAllJobs(
     std::vector<SocketAndCallback>& pending_sockets_and_callbacks) {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
   for (std::vector<SocketAndCallback>::const_iterator it =
            pending_sockets_and_callbacks.begin();
        it != pending_sockets_and_callbacks.end();
        ++it)
     task_runner->PostTask(FROM_HERE, it->callback);
 }
 
 // Timeout for the SSL handshake portion of the connect.
 static const int kSSLHandshakeTimeoutInSeconds = 30;
 
 SSLConnectJob::SSLConnectJob(const std::string& group_name,
                              RequestPriority priority,
                              const scoped_refptr<SSLSocketParams>& params,
                              const base::TimeDelta& timeout_duration,
                              TransportClientSocketPool* transport_pool,
                              SOCKSClientSocketPool* socks_pool,
                              HttpProxyClientSocketPool* http_proxy_pool,
                              ClientSocketFactory* client_socket_factory,
                              HostResolver* host_resolver,
                              const SSLClientSocketContext& context,
                              SSLConnectJobMessenger* messenger,
+                             AddMessengerCallback add_messenger_callback,
+                             DeleteMessengerCallback delete_messenger_callback,
                              Delegate* delegate,
                              NetLog* net_log)
     : ConnectJob(group_name,
                  timeout_duration,
                  priority,
                  delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       params_(params),
       transport_pool_(transport_pool),
       socks_pool_(socks_pool),
       http_proxy_pool_(http_proxy_pool),
       client_socket_factory_(client_socket_factory),
       host_resolver_(host_resolver),
       context_(context.cert_verifier,
                context.server_bound_cert_service,
                context.transport_security_state,
                context.cert_transparency_verifier,
                (params->privacy_mode() == PRIVACY_MODE_ENABLED
                     ? "pm/" + context.ssl_session_cache_shard
                     : context.ssl_session_cache_shard)),
       io_callback_(
           base::Bind(&SSLConnectJob::OnIOComplete, base::Unretained(this))),
       messenger_(messenger),
-      weak_factory_(this) {
+      weak_factory_(this),
+      add_messenger_callback_(add_messenger_callback),
+      delete_messenger_callback_(delete_messenger_callback) {
 }
 
 SSLConnectJob::~SSLConnectJob() {}
 
 LoadState SSLConnectJob::GetLoadState() const {
   switch (next_state_) {
     case STATE_TUNNEL_CONNECT_COMPLETE:
       if (transport_socket_handle_->socket())
         return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL;
       // else, fall through.
@@ skipping 186 matching lines @@
     connect_timing_.connect_start = socket_connect_timing.connect_start;
     connect_timing_.dns_start = socket_connect_timing.dns_start;
     connect_timing_.dns_end = socket_connect_timing.dns_end;
   }
 
   ssl_socket_ = client_socket_factory_->CreateSSLClientSocket(
       transport_socket_handle_.Pass(),
       params_->host_and_port(),
       params_->ssl_config(),
       context_);
+
+  // Retrieve an SSLConnectJobMessenger for this connection if needed.
+  if (!ssl_socket_->InSessionCache())
+    GetMessenger(ssl_socket_->GetSessionCacheKey());
+
   return OK;
 }
 
 int SSLConnectJob::DoCheckForResume() {
   next_state_ = STATE_SSL_CONNECT;
+  if (ssl_socket_->InSessionCache())
+    return OK;
+
   if (messenger_->CanProceed(ssl_socket_.get())) {
-    if (ssl_socket_->InSessionCache())
-      return OK;
     messenger_->MonitorConnectionResult(ssl_socket_.get());
     return OK;
   }
+
   messenger_->AddPendingSocket(
       ssl_socket_.get(),
       base::Bind(&net::SSLConnectJob::ResumeSSLConnection,
                  weak_factory_.GetWeakPtr()));
   return ERR_IO_PENDING;
 }
 
 int SSLConnectJob::DoSSLConnect() {
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 
   connect_timing_.ssl_start = base::TimeTicks::Now();
 
   return ssl_socket_->Connect(io_callback_);
 }
 
 int SSLConnectJob::DoSSLConnectComplete(int result) {
   connect_timing_.ssl_end = base::TimeTicks::Now();
 
-  if (result != OK && SSLClientSocket::GetEnableConnectJobWaiting())
-    messenger_->OnJobFailed();
-
+  if (SSLClientSocket::GetEnableConnectJobWaiting() && messenger_ != NULL) {
+    if (result != OK)
+      messenger_->OnJobFailed();
+    else {
+      // If the connection was successful, determine if the job's messenger is
+      // still needed. If not, remove the messenger.
+      if (!messenger_->IsNeeded())
+        DeleteMessenger(ssl_socket_->GetSessionCacheKey());
+    }
+  }
   SSLClientSocket::NextProtoStatus status =
       SSLClientSocket::kNextProtoUnsupported;
   std::string proto;
   std::string server_protos;
   // GetNextProto will fail and and trigger a NOTREACHED if we pass in a socket
   // that hasn't had SSL_ImportFD called on it. If we get a certificate error
   // here, then we know that we called SSL_ImportFD.
   if (result == OK || IsCertificateError(result))
     status = ssl_socket_->GetNextProto(&proto, &server_protos);
 
@@ skipping 107 matching lines @@
   }
 
   return result;
 }
 
 void SSLConnectJob::ResumeSSLConnection() {
   DCHECK_EQ(next_state_, STATE_SSL_CONNECT);
   OnIOComplete(OK);
 }
 
+void SSLConnectJob::GetMessenger(std::string cache_key) {
+  messenger_ = add_messenger_callback_.Run(cache_key);
+}
+
+void SSLConnectJob::DeleteMessenger(std::string cache_key) {
+  delete_messenger_callback_.Run(cache_key);
+  messenger_ = NULL;
+}
+
 SSLConnectJob::State SSLConnectJob::GetInitialState(
     SSLSocketParams::ConnectionType connection_type) {
   switch (connection_type) {
     case SSLSocketParams::DIRECT:
       return STATE_TRANSPORT_CONNECT;
     case SSLSocketParams::HTTP_PROXY:
       return STATE_TUNNEL_CONNECT;
     case SSLSocketParams::SOCKS_PROXY:
       return STATE_SOCKS_CONNECT;
   }
@@ skipping 13 matching lines @@
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     const SSLClientSocketContext& context,
     NetLog* net_log)
     : transport_pool_(transport_pool),
       socks_pool_(socks_pool),
       http_proxy_pool_(http_proxy_pool),
       client_socket_factory_(client_socket_factory),
       host_resolver_(host_resolver),
       context_(context),
-      net_log_(net_log),
-      messenger_map_(new MessengerMap) {
+      net_log_(net_log) {
   base::TimeDelta max_transport_timeout = base::TimeDelta();
   base::TimeDelta pool_timeout;
   if (transport_pool_)
     max_transport_timeout = transport_pool_->ConnectionTimeout();
   if (socks_pool_) {
     pool_timeout = socks_pool_->ConnectionTimeout();
     if (pool_timeout > max_transport_timeout)
       max_transport_timeout = pool_timeout;
   }
   if (http_proxy_pool_) {
@@ skipping 51 matching lines @@
     base_.AddLowerLayeredPool(socks_pool_);
   if (http_proxy_pool_)
     base_.AddLowerLayeredPool(http_proxy_pool_);
 }
 
 SSLClientSocketPool::~SSLClientSocketPool() {
   if (ssl_config_service_.get())
     ssl_config_service_->RemoveObserver(this);
 }
 
-scoped_ptr<ConnectJob>
-SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
+SSLConnectJobMessenger*
+SSLClientSocketPool::SSLConnectJobFactory::AddSSLConnectJobMessenger(
+    std::string cache_key) {
+  MessengerMap::const_iterator it = messenger_map_.find(cache_key);
+  if (it == messenger_map_.end()) {
+    std::pair<MessengerMap::iterator, bool> iter = messenger_map_.insert(
+        MessengerMap::value_type(cache_key, new SSLConnectJobMessenger()));
+      it = iter.first;
+    }
+    return it->second;
+}
+
+void SSLClientSocketPool::SSLConnectJobFactory::DeleteSSLConnectJobMessenger(
+    std::string cache_key) {
+  MessengerMap::iterator it = messenger_map_.find(cache_key);
+  delete it->second;
+  messenger_map_.erase(it);
+}
+
+scoped_ptr<ConnectJob> SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
-    ConnectJob::Delegate* delegate) const {
-  SSLConnectJobMessenger* messenger;
-  std::string cache_key = SSLClientSocket::FormatSessionCacheKey(
-      request.params()->host_and_port().ToString(),
-      context_.ssl_session_cache_shard);
-  if (SSLClientSocket::GetEnableConnectJobWaiting()) {
-    MessengerMap::const_iterator it = messenger_map_->find(cache_key);
-    if (it == messenger_map_->end()) {
-      std::pair<MessengerMap::iterator, bool> iter = messenger_map_->insert(
-          MessengerMap::value_type(cache_key, new SSLConnectJobMessenger()));
-      it = iter.first;
-    }
-    messenger = it->second;
-  } else {
-    messenger = NULL;
-  }
-
-  return scoped_ptr<ConnectJob>(new SSLConnectJob(group_name,
-                                                  request.priority(),
-                                                  request.params(),
-                                                  ConnectionTimeout(),
-                                                  transport_pool_,
-                                                  socks_pool_,
-                                                  http_proxy_pool_,
-                                                  client_socket_factory_,
-                                                  host_resolver_,
-                                                  context_,
-                                                  messenger,
-                                                  delegate,
-                                                  net_log_));
+    ConnectJob::Delegate* delegate) {
+  return scoped_ptr<ConnectJob>(new SSLConnectJob(
+      group_name,
+      request.priority(),
+      request.params(),
+      ConnectionTimeout(),
+      transport_pool_,
+      socks_pool_,
+      http_proxy_pool_,
+      client_socket_factory_,
+      host_resolver_,
+      context_,
+      NULL,
+      base::Bind(
+          &SSLClientSocketPool::SSLConnectJobFactory::AddSSLConnectJobMessenger,
+          base::Unretained(this)),
+      base::Bind(&SSLClientSocketPool::SSLConnectJobFactory::
+                     DeleteSSLConnectJobMessenger,
+                 base::Unretained(this)),
+      delegate,
+      net_log_));
 }
 
 base::TimeDelta
 SSLClientSocketPool::SSLConnectJobFactory::ConnectionTimeout() const {
   return timeout_;
 }
 
 int SSLClientSocketPool::RequestSocket(const std::string& group_name,
                                        const void* socket_params,
                                        RequestPriority priority,
@@ skipping 103 matching lines @@
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 }
 
 void SSLClientSocketPool::OnSSLConfigChanged() {
   FlushWithError(ERR_NETWORK_CHANGED);
 }
 
 }  // namespace net