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

net/socket/ssl_client_socket_pool.cc

Index: net/socket/ssl_client_socket_pool.cc
diff --git a/net/socket/ssl_client_socket_pool.cc b/net/socket/ssl_client_socket_pool.cc
index e3530ef1bc4c9529434b4b15975b97c7a633b8dd..b3d10c7e1bc41961a639cd709bb32ae344f5a480 100644
--- a/net/socket/ssl_client_socket_pool.cc
+++ b/net/socket/ssl_client_socket_pool.cc
@@ -9,6 +9,7 @@
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.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"
@@ -115,6 +116,9 @@ void SSLConnectJobMessenger::RemoveSocket(SSLClientSocket* ssl_socket) {
   }
 }
 
+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.
@@ -124,11 +128,11 @@ bool SSLConnectJobMessenger::CanProceed(SSLClientSocket* ssl_socket) {
 void SSLConnectJobMessenger::MonitorConnectionResult(
     SSLClientSocket* ssl_socket) {
   connecting_sockets_.push_back(ssl_socket);
-  // TODO(mshelley): Both of these callbacks will use weak_ptr in future CL.
-  ssl_socket->SetHandshakeFailureCallback(
-      base::Bind(&SSLConnectJobMessenger::OnJobFailed, base::Unretained(this)));
+
+  ssl_socket->SetHandshakeFailureCallback(base::Bind(
+      &SSLConnectJobMessenger::OnJobFailed, weak_factory_.GetWeakPtr()));
   ssl_socket->SetHandshakeSuccessCallback(base::Bind(
-      &SSLConnectJobMessenger::OnJobSucceeded, base::Unretained(this)));
+      &SSLConnectJobMessenger::OnJobSucceeded, weak_factory_.GetWeakPtr()));
 }
 
 void SSLConnectJobMessenger::AddPendingSocket(SSLClientSocket* socket,
@@ -144,23 +148,34 @@ void SSLConnectJobMessenger::OnJobSucceeded() {
 }
 
 void SSLConnectJobMessenger::OnJobFailed() {
+  connecting_sockets_.erase(connecting_sockets_.begin());
+
+  // If there were no valid pending sockets, return.
   if (pending_sockets_and_callbacks_.empty())
     return;
-  base::Closure callback = pending_sockets_and_callbacks_[0].callback;
-  connecting_sockets_.erase(connecting_sockets_.begin());
-  SSLClientSocket* ssl_socket = pending_sockets_and_callbacks_[0].socket;
+
+  SocketAndCallback socket_and_callback =
+      pending_sockets_and_callbacks_.front();
   pending_sockets_and_callbacks_.erase(pending_sockets_and_callbacks_.begin());
-  MonitorConnectionResult(ssl_socket);
-  callback.Run();
+
+  MonitorConnectionResult(socket_and_callback.socket);
+
+  // PostTask is used to avoid the recursive call sequence caused
+  // by SSLConnectJobMessengers running the callback directly.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                socket_and_callback.callback);

[mmenke, 2014/07/22 18:06:32]

Hrm...  Looks like we're fine if the second socket is destroyed either before or
after this function is called, but before the callback is executed.  Wonder if
it's worth testing the second case.  Suggested testing the first on the other
CL.

[mshelley, 2014/07/23 22:09:07]

Just to confirm: by "second case" you mean the case in which the socket is
destroyed after the function is called but before the callback is executed?  

Also, given that after my last patch to my big CL OnJobFailed will be handled in
the same manner as OnJobSucceeded (OnJobComplete), do you think this test is
still necessary? The connections of other pending sockets will no longer be
dependent upon the connection of the second socket, so I'm not sure if it is.

 }
 
 void SSLConnectJobMessenger::RunAllCallbacks(
     const SSLPendingSocketsAndCallbacks& pending_sockets_and_callbacks) {
+  scoped_refptr<base::SequencedTaskRunner> 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();
+       ++it) {
+    task_runner->PostTask(FROM_HERE, it->callback);
+  }
 }
 
 // Timeout for the SSL handshake portion of the connect.