Modify the MockConnect constructor to take an enum of ASYNC or SYNC, instead

net/spdy/spdy_network_transaction_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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 225 matching lines @@
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
         ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
         session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
       session_deps_->socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
-        MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+        MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
         linked_ptr<StaticSocketDataProvider>
             hanging_non_alternate_protocol_socket(
                 new StaticSocketDataProvider(NULL, 0, NULL, 0));
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket.get());
         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
         ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
             AddSSLSocketDataProvider(ssl_.get());
       }
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
-        MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+        MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
         scoped_refptr<DeterministicSocketData>
             hanging_non_alternate_protocol_socket(
             new DeterministicSocketData(NULL, 0, NULL, 0));
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->deterministic_socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket);
         alternate_deterministic_vector_.push_back(
             hanging_non_alternate_protocol_socket);
       }
@@ skipping 464 matching lines @@
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
 
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
@@ skipping 66 matching lines @@
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     MockRead(true, 0, 0),  // EOF
   };
   scoped_ptr<OrderedSocketData> preconnect_data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
-  MockConnect never_finishing_connect(true, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(ASYNC, ERR_IO_PENDING);
 
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
@@ skipping 4845 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net