This CL is a follow up to https://codereview.chromium.org/353713005.

net/socket/socket_test_util.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/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 261 matching lines @@
 
 SSLSocketDataProvider::SSLSocketDataProvider(IoMode mode, int result)
     : connect(mode, result),
       next_proto_status(SSLClientSocket::kNextProtoUnsupported),
       was_npn_negotiated(false),
       protocol_negotiated(kProtoUnknown),
       client_cert_sent(false),
       cert_request_info(NULL),
       channel_id_sent(false),
       connection_status(0),
-      should_block_on_connect(false),
+      should_pause_on_connect(false),
       is_in_session_cache(false) {
   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2,
                                 &connection_status);
   // Set to TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305
   SSLConnectionStatusSetCipherSuite(0xcc14, &connection_status);
 }
 
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
 
@@ skipping 1049 matching lines @@
                               const CompletionCallback& callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
-  next_connect_state_ = STATE_TRANSPORT_CONNECT;
+  next_connect_state_ = STATE_SSL_CONNECT;
   reached_connect_ = true;
   int rv = DoConnectLoop(OK);
   if (rv == ERR_IO_PENDING)
     connect_callback_ = callback;
   return rv;
 }
 
 void MockSSLClientSocket::Disconnect() {
   weak_factory_.InvalidateWeakPtrs();
   MockClientSocket::Disconnect();
@@ skipping 90 matching lines @@
 
 void MockSSLClientSocket::OnReadComplete(const MockRead& data) {
   NOTIMPLEMENTED();
 }
 
 void MockSSLClientSocket::OnConnectComplete(const MockConnect& data) {
   NOTIMPLEMENTED();
 }
 
 void MockSSLClientSocket::RestartPausedConnect() {
-  DCHECK(data_->should_block_on_connect);
+  DCHECK(data_->should_pause_on_connect);
   DCHECK_EQ(next_connect_state_, STATE_SSL_CONNECT_COMPLETE);
   OnIOComplete(data_->connect.result);
 }
 
 void MockSSLClientSocket::OnIOComplete(int result) {
   int rv = DoConnectLoop(result);
   if (rv != ERR_IO_PENDING)
     base::ResetAndReturn(&connect_callback_).Run(rv);
 }
 
 int MockSSLClientSocket::DoConnectLoop(int result) {
   DCHECK_NE(next_connect_state_, STATE_NONE);
 
   int rv = result;
   do {
     ConnectState state = next_connect_state_;
     next_connect_state_ = STATE_NONE;
     switch (state) {
-      case STATE_TRANSPORT_CONNECT:
-        rv = DoTransportConnect();
-        break;
-      case STATE_TRANSPORT_CONNECT_COMPLETE:
-        rv = DoTransportConnectComplete(rv);
-        break;
       case STATE_SSL_CONNECT:
         rv = DoSSLConnect();
         break;
       case STATE_SSL_CONNECT_COMPLETE:
         rv = DoSSLConnectComplete(rv);
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_connect_state_ != STATE_NONE);
 
   return rv;
 }
 
-int MockSSLClientSocket::DoTransportConnect() {
-  next_connect_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
-  return transport_->socket()->Connect(
-      base::Bind(&MockSSLClientSocket::OnIOComplete, base::Unretained(this)));
-}
-
-int MockSSLClientSocket::DoTransportConnectComplete(int result) {
-  if (result == OK)
-    next_connect_state_ = STATE_SSL_CONNECT;
-  return result;
-}
-
 int MockSSLClientSocket::DoSSLConnect() {
   next_connect_state_ = STATE_SSL_CONNECT_COMPLETE;
 
-  if (data_->should_block_on_connect)
+  if (data_->should_pause_on_connect)
     return ERR_IO_PENDING;
 
   if (data_->connect.mode == ASYNC) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MockSSLClientSocket::OnIOComplete,
                    weak_factory_.GetWeakPtr(),
                    data_->connect.result));
     return ERR_IO_PENDING;
   }
@@ skipping 467 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net