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

net/http/http_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 <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 6430 matching lines @@
 
 TEST_F(HttpNetworkTransactionTest, MarkBrokenAlternateProtocolAndFallback) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
-  MockConnect mock_connect(true, ERR_CONNECTION_REFUSED);
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&first_data);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(true, OK),
   };
   StaticSocketDataProvider second_data(
@@ skipping 42 matching lines @@
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.google.com:1023/");
   restricted_port_request.load_flags = 0;
 
-  MockConnect mock_connect(true, ERR_CONNECTION_REFUSED);
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&first_data);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(true, OK),
   };
   StaticSocketDataProvider second_data(
@@ skipping 28 matching lines @@
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.google.com:1023/");
   restricted_port_request.load_flags = 0;
 
-  MockConnect mock_connect(true, ERR_CONNECTION_REFUSED);
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&first_data);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(true, OK),
   };
   StaticSocketDataProvider second_data(
@@ skipping 28 matching lines @@
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.google.com:1024/");
   unrestricted_port_request.load_flags = 0;
 
-  MockConnect mock_connect(true, ERR_CONNECTION_REFUSED);
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&first_data);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(true, OK),
   };
   StaticSocketDataProvider second_data(
@@ skipping 28 matching lines @@
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
   SessionDependencies session_deps;
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.google.com:1024/");
   unrestricted_port_request.load_flags = 0;
 
-  MockConnect mock_connect(true, ERR_CONNECTION_REFUSED);
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
   session_deps.socket_factory.AddSocketDataProvider(&first_data);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(true, OK),
   };
   StaticSocketDataProvider second_data(
@@ skipping 115 matching lines @@
     MockRead(true, 0, 0),
   };
 
   scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       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);
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
@@ skipping 47 matching lines @@
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
     MockRead(true, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   // Socket 1 is the HTTP transaction with the Alternate-Protocol header.
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_socket(
       NULL, 0, NULL, 0);
   hanging_socket.set_connect_data(never_finishing_connect);
   // Socket 2 and 3 are the hanging Alternate-Protocol and
   // non-Alternate-Protocol jobs from the 2nd transaction.
   session_deps.socket_factory.AddSocketDataProvider(&hanging_socket);
   session_deps.socket_factory.AddSocketDataProvider(&hanging_socket);
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
@@ skipping 104 matching lines @@
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2.1";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY21;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_alternate_protocol_socket);
 
   // 2nd request is just a copy of the first one, over HTTP again.
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
@@ skipping 139 matching lines @@
     CreateMockRead(*data.get(), 4),  // 5
     MockRead(true, 0, 0, 4),  // 6
   };
 
   scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       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);
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
@@ skipping 803 matching lines @@
   SSLSocketDataProvider ssl_socket_data_provider2(false, OK);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider1);
   session_deps.socket_factory.AddSocketDataProvider(&socket_data_provider2);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider1);
   session_deps.socket_factory.AddSSLSocketDataProvider(
       &ssl_socket_data_provider2);
 
   // Work around http://crbug.com/37454
   StaticSocketDataProvider bug37454_connection;
-  bug37454_connection.set_connect_data(MockConnect(true, ERR_UNEXPECTED));
+  bug37454_connection.set_connect_data(MockConnect(ASYNC, ERR_UNEXPECTED));
   session_deps.socket_factory.AddSocketDataProvider(&bug37454_connection);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 257 matching lines @@
   scoped_ptr<OrderedSocketData> data_2(
       new OrderedSocketData(data_reads_2, arraysize(data_reads_2),
                             data_writes_2, arraysize(data_writes_2)));
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2.1";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY21;
 
-  MockConnect never_finishing_connect(false, ERR_IO_PENDING);
+  MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
 
   session_deps.socket_factory.AddSocketDataProvider(&data_1);
   session_deps.socket_factory.AddSocketDataProvider(data_2.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
@@ skipping 34 matching lines @@
 }
 
 // Test that if we cancel the transaction as the connection is completing, that
 // everything tears down correctly.
 TEST_F(HttpNetworkTransactionTest, SimpleCancel) {
   // Setup everything about the connection to complete synchronously, so that
   // after calling HttpNetworkTransaction::Start, the only thing we're waiting
   // for is the callback from the HttpStreamRequest.
   // Then cancel the transaction.
   // Verify that we don't crash.
-  MockConnect mock_connect(false, OK);
+  MockConnect mock_connect(SYNCHRONOUS, OK);
   MockRead data_reads[] = {
     MockRead(false, "HTTP/1.0 200 OK\r\n\r\n"),
     MockRead(false, "hello world"),
     MockRead(false, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
@@ skipping 932 matching lines @@
   StaticSocketDataProvider* data[] = { &data1, &data2 };
 
   SimpleGetHelperResult out = SimpleGetHelperForData(data, arraysize(data));
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 }  // namespace net