Makes waiting SSLConnectJobs use the message loops to resume their connection.

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"
 #include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/transport_client_socket_pool.h"
@@ skipping 79 matching lines @@
            pending_sockets_and_callbacks_.begin();
        it != pending_sockets_and_callbacks_.end();
        ++it) {
     if (it->socket == ssl_socket) {
       pending_sockets_and_callbacks_.erase(it);
       return;
     }
   }
 }
 
+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.
   return ssl_socket->InSessionCache() || connecting_sockets_.empty();
 }
 
 void SSLConnectJobMessenger::MonitorConnectionResult(
     SSLClientSocket* ssl_socket) {
   connecting_sockets_.push_back(ssl_socket);
-  // TODO(mshelley): Both of these callbacks will use WeakPtr in future CL.
   ssl_socket->SetHandshakeCompletionCallback(base::Bind(
-      &SSLConnectJobMessenger::OnJobCompleted, base::Unretained(this)));
+      &SSLConnectJobMessenger::OnJobCompleted, weak_factory_.GetWeakPtr()));
 }
 
 void SSLConnectJobMessenger::AddPendingSocket(SSLClientSocket* ssl_socket,
                                               const base::Closure& callback) {
   DCHECK(!connecting_sockets_.empty());
   pending_sockets_and_callbacks_.push_back(
       SocketAndCallback(ssl_socket, callback));
 }
 
 void SSLConnectJobMessenger::OnJobCompleted() {
   connecting_sockets_.clear();
   SSLPendingSocketsAndCallbacks temp_list;
   temp_list.swap(pending_sockets_and_callbacks_);
   RunAllCallbacks(temp_list);
 }
 
 void SSLConnectJobMessenger::RunAllCallbacks(
     const SSLPendingSocketsAndCallbacks& 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) {
-    it->callback.Run();
+    task_runner->PostTask(FROM_HERE, it->callback);

[wtc, 2014/08/05 00:44:57]

1. I think running the callbacks directly is safe and improves performance. But
I won't block this change.

We don't call SetHandshakeCompletionCallback on any of these pending sockets, so
the callbacks won't call the SSLConnectJobMessenger. Therefore, the "somewhat
recursive call sequence" you mentioned in the CL's description should not occur.

2. Please add a comment to explain why it is necessary or useful to post tasks
to run the callbacks later.

[Ryan Sleevi, 2014/08/06 02:15:50]

I don't think this is entirely true. Any one of these callbacks could create a
new SSLSocket, which would potentially fall back into this messenger. Any number
of side-effects could occur.

Now, whether or not they do in this CL is irrelevant, I think - it's more about
making sure the API contract is consistent.

   }
 }
 
 // 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,
@@ skipping 654 matching lines @@
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 }
 
 void SSLClientSocketPool::OnSSLConfigChanged() {
   FlushWithError(ERR_NETWORK_CHANGED);
 }
 
 }  // namespace net