Implements new, more robust design for communicating between SSLConnectJobs.

net/socket/ssl_client_socket_openssl_unittest.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.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include <openssl/bio.h>
@@ skipping 69 matching lines @@
   }
   pkey->reset(result);
   return true;
 }
 
 class SSLClientSocketOpenSSLClientAuthTest : public PlatformTest {
  public:
   SSLClientSocketOpenSSLClientAuthTest()
       : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         cert_verifier_(new MockCertVerifier),
-        transport_security_state_(new TransportSecurityState) {
+        transport_security_state_(new TransportSecurityState),
+        ran_handshake_completion_callback_(false) {

[wtc, 2014/08/03 01:49:10]

I think you should undo all changes in this file. The new tests in
ssl_client_socket_unittest.cc should be enough.

[mshelley, 2014/08/03 23:37:09]

Done.

     cert_verifier_->set_default_result(OK);
     context_.cert_verifier = cert_verifier_.get();
     context_.transport_security_state = transport_security_state_.get();
     key_store_ = OpenSSLClientKeyStore::GetInstance();
   }
 
   virtual ~SSLClientSocketOpenSSLClientAuthTest() {
     key_store_->Flush();
   }
 
+  void RecordCompletedHandshake() { ran_handshake_completion_callback_ = true; }
+
  protected:
   scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<StreamSocket> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config) {
     scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
     connection->SetSocket(transport_socket.Pass());
     return socket_factory_->CreateSSLClientSocket(connection.Pass(),
                                                   host_and_port,
                                                   ssl_config,
@@ skipping 44 matching lines @@
   // |result| will retrieve the ::Connect() result value.
   // Returns true on succes, false otherwise. Success means that the socket
   // could be created and its Connect() was called, not that the connection
   // itself was a success.
   bool CreateAndConnectSSLClientSocket(SSLConfig& ssl_config,
                                        int* result) {
     sock_ = CreateSSLClientSocket(transport_.Pass(),
                                   test_server_->host_port_pair(),
                                   ssl_config);
 
+    sock_->SetHandshakeCompletionCallback(base::Bind(
+        &SSLClientSocketOpenSSLClientAuthTest::RecordCompletedHandshake,
+        base::Unretained(this)));
+
     if (sock_->IsConnected()) {
       LOG(ERROR) << "SSL Socket prematurely connected";
       return false;
     }
 
     *result = callback_.GetResult(sock_->Connect(callback_.callback()));
     return true;
   }
 
 
   // Check that the client certificate was sent.
   // Returns true on success.
   bool CheckSSLClientSocketSentCert() {
     SSLInfo ssl_info;
     sock_->GetSSLInfo(&ssl_info);
     return ssl_info.client_cert_sent;
   }
 
   ClientSocketFactory* socket_factory_;
   scoped_ptr<MockCertVerifier> cert_verifier_;
   scoped_ptr<TransportSecurityState> transport_security_state_;
   SSLClientSocketContext context_;
   OpenSSLClientKeyStore* key_store_;
   scoped_ptr<SpawnedTestServer> test_server_;
   AddressList addr_;
   TestCompletionCallback callback_;
   CapturingNetLog log_;
   scoped_ptr<StreamSocket> transport_;
   scoped_ptr<SSLClientSocket> sock_;
+  bool ran_handshake_completion_callback_;
 };
 
 // Connect to a server requesting client authentication, do not send
 // any client certificates. It should refuse the connection.
 TEST_F(SSLClientSocketOpenSSLClientAuthTest, NoCert) {
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
 
   ASSERT_TRUE(ConnectToTestServer(ssl_options));
 
   base::FilePath certs_dir = GetTestCertsDirectory();
   SSLConfig ssl_config = kDefaultSSLConfig;
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
   EXPECT_FALSE(sock_->IsConnected());
+  EXPECT_TRUE(ran_handshake_completion_callback_);
 }
 
 // Connect to a server requesting client authentication, and send it
 // an empty certificate. It should refuse the connection.
 TEST_F(SSLClientSocketOpenSSLClientAuthTest, SendEmptyCert) {
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   ssl_options.client_authorities.push_back(
       GetTestClientCertsDirectory().AppendASCII("client_1_ca.pem"));
 
@@ skipping 37 matching lines @@
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(sock_->IsConnected());
 
   EXPECT_TRUE(CheckSSLClientSocketSentCert());
 
   sock_->Disconnect();
   EXPECT_FALSE(sock_->IsConnected());
 }
+
 #endif  // defined(USE_OPENSSL_CERTS)
 
 }  // namespace
+
 }  // namespace net