Change MockRead and MockWrite (et. al.) to take an IoMode enum, instead

net/http/http_pipelined_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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 174 matching lines @@
   scoped_refptr<SSLConfigService> ssl_config_;
   scoped_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   scoped_refptr<HttpNetworkSession> session_;
 };
 
 TEST_F(HttpPipelinedNetworkTransactionTest, OneRequest) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /test.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /test.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 9\r\n\r\n"),
-    MockRead(false, 3, "test.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 9\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "test.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpNetworkTransaction transaction(session_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             transaction.Start(GetRequestInfo("test.html"), callback_.callback(),
                               BoundNetLog()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   ExpectResponse("test.html", transaction);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ReusePipeline) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(true, 4, "one.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 7, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(ASYNC, 4, "one.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   CompleteTwoRequests(0, 5);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ReusesOnSpaceAvailable) {
   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group();
   ClientSocketPoolManager::set_max_sockets_per_group(1);
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 4, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 7, "GET /three.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 12, "GET /four.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "one.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 8, "two.html"),
-    MockRead(false, 9, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 10, "Content-Length: 10\r\n\r\n"),
-    MockRead(false, 11, "three.html"),
-    MockRead(false, 13, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 14, "Content-Length: 9\r\n\r\n"),
-    MockRead(false, 15, "four.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "one.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 8, "two.html"),
+    MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 11, "three.html"),
+    MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 15, "four.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   CompleteFourRequests();
 
   ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, UnknownSizeEvictsToNewPipeline) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead(true, 2, "one.html"),
-    MockRead(false, OK, 3),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
+    MockRead(ASYNC, 2, "one.html"),
+    MockRead(SYNCHRONOUS, OK, 3),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   MockWrite writes2[] = {
-    MockWrite(false, 0, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads2[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "two.html"),
   };
   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   CompleteTwoRequests(0, 3);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ConnectionCloseEvictToNewPipeline) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(true, 4, "one.html"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(ASYNC, 4, "one.html"),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   MockWrite writes2[] = {
-    MockWrite(false, 0, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads2[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "two.html"),
   };
   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   CompleteTwoRequests(0, 5);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ErrorEvictsToNewPipeline) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead(false, ERR_FAILED, 2),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
+    MockRead(SYNCHRONOUS, ERR_FAILED, 2),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   MockWrite writes2[] = {
-    MockWrite(false, 0, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads2[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "two.html"),
   };
   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   HttpNetworkTransaction one_transaction(session_.get());
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             one_transaction.Start(GetRequestInfo("one.html"),
                                   one_callback.callback(), BoundNetLog()));
   EXPECT_EQ(OK, one_callback.WaitForResult());
 
   HttpNetworkTransaction two_transaction(session_.get());
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
   EXPECT_EQ(ERR_FAILED,
             one_transaction.Read(buffer.get(), 1, callback_.callback()));
   EXPECT_EQ(OK, two_callback.WaitForResult());
   ExpectResponse("two.html", two_transaction);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, SendErrorEvictsToNewPipeline) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(true, ERR_FAILED, 0),
+    MockWrite(ASYNC, ERR_FAILED, 0),
   };
   AddExpectedConnection(NULL, 0, writes, arraysize(writes));
 
   MockWrite writes2[] = {
-    MockWrite(false, 0, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads2[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "two.html"),
   };
   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   HttpNetworkTransaction one_transaction(session_.get());
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             one_transaction.Start(GetRequestInfo("one.html"),
                                   one_callback.callback(), BoundNetLog()));
 
   HttpNetworkTransaction two_transaction(session_.get());
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   data_vector_[0]->RunFor(1);
   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
 
   EXPECT_EQ(OK, two_callback.WaitForResult());
   ExpectResponse("two.html", two_transaction);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, RedirectDrained) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 302 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(true, 4, "redirect"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 7, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 302 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(ASYNC, 4, "redirect"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpNetworkTransaction> one_transaction(
       new HttpNetworkTransaction(session_.get()));
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             one_transaction->Start(GetRequestInfo("redirect.html"),
                                    one_callback.callback(), BoundNetLog()));
   EXPECT_EQ(OK, one_callback.WaitForResult());
 
   HttpNetworkTransaction two_transaction(session_.get());
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   one_transaction.reset();
   data_vector_[0]->RunFor(2);
   data_vector_[0]->SetStop(10);
 
   EXPECT_EQ(OK, two_callback.WaitForResult());
   ExpectResponse("two.html", two_transaction);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, BasicHttpAuthentication) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 5, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 5, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: auth_token\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 401 Authentication Required\r\n"),
-    MockRead(false, 2, "WWW-Authenticate: Basic realm=\"Secure Area\"\r\n"),
-    MockRead(false, 3, "Content-Length: 20\r\n\r\n"),
-    MockRead(false, 4, "needs authentication"),
-    MockRead(false, 6, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 7, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 8, "one.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Authentication Required\r\n"),
+    MockRead(SYNCHRONOUS, 2,
+             "WWW-Authenticate: Basic realm=\"Secure Area\"\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 20\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "needs authentication"),
+    MockRead(SYNCHRONOUS, 6, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 7, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 8, "one.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpAuthHandlerMock* mock_auth = new HttpAuthHandlerMock;
   std::string challenge_text = "Basic";
   HttpAuth::ChallengeTokenizer challenge(challenge_text.begin(),
                                          challenge_text.end());
   GURL origin("localhost");
   EXPECT_TRUE(mock_auth->InitFromChallenge(&challenge,
                                            HttpAuth::AUTH_SERVER,
@@ skipping 10 matching lines @@
   AuthCredentials credentials(ASCIIToUTF16("user"), ASCIIToUTF16("pass"));
   EXPECT_EQ(OK, transaction.RestartWithAuth(credentials, callback_.callback()));
 
   ExpectResponse("one.html", transaction);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, OldVersionDisablesPipelining) {
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /pipelined.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /pipelined.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.0 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 14\r\n\r\n"),
-    MockRead(false, 3, "pipelined.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 14\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "pipelined.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   MockWrite writes2[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads2[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(true, 3, "one.html"),
-    MockRead(false, OK, 4),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(ASYNC, 3, "one.html"),
+    MockRead(SYNCHRONOUS, OK, 4),
   };
   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   MockWrite writes3[] = {
-    MockWrite(false, 0, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads3[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "two.html"),
-    MockRead(false, OK, 4),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "two.html"),
+    MockRead(SYNCHRONOUS, OK, 4),
   };
   AddExpectedConnection(reads3, arraysize(reads3), writes3, arraysize(writes3));
 
   HttpNetworkTransaction one_transaction(session_.get());
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             one_transaction.Start(GetRequestInfo("pipelined.html"),
                                   one_callback.callback(), BoundNetLog()));
   EXPECT_EQ(OK, one_callback.WaitForResult());
   ExpectResponse("pipelined.html", one_transaction);
 
   CompleteTwoRequests(1, 4);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, PipelinesImmediatelyIfKnownGood) {
   // The first request gets us an HTTP/1.1. The next 3 test pipelining. When the
   // 3rd request completes, we know pipelining is safe. After the first 4
   // complete, the 5th and 6th should then be immediately sent pipelined on a
   // new HttpPipelinedConnection.
   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group();
   ClientSocketPoolManager::set_max_sockets_per_group(1);
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 4, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 7, "GET /three.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 12, "GET /four.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 16, "GET /second-pipeline-one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 16, "GET /second-pipeline-one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(false, 17, "GET /second-pipeline-two.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 17, "GET /second-pipeline-two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 3, "one.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 8, "two.html"),
-    MockRead(false, 9, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 10, "Content-Length: 10\r\n\r\n"),
-    MockRead(false, 11, "three.html"),
-    MockRead(false, 13, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 14, "Content-Length: 9\r\n\r\n"),
-    MockRead(false, 15, "four.html"),
-    MockRead(true, 18, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 19, "Content-Length: 24\r\n\r\n"),
-    MockRead(false, 20, "second-pipeline-one.html"),
-    MockRead(false, 21, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 22, "Content-Length: 24\r\n\r\n"),
-    MockRead(false, 23, "second-pipeline-two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "one.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 8, "two.html"),
+    MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 11, "three.html"),
+    MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 15, "four.html"),
+    MockRead(ASYNC, 18, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 19, "Content-Length: 24\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 20, "second-pipeline-one.html"),
+    MockRead(SYNCHRONOUS, 21, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 22, "Content-Length: 24\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 23, "second-pipeline-two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   CompleteFourRequests();
 
   HttpNetworkTransaction second_one_transaction(session_.get());
   TestCompletionCallback second_one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             second_one_transaction.Start(
                 GetRequestInfo("second-pipeline-one.html"),
@@ skipping 50 matching lines @@
   // determines this host is probably capable of pipelining.
   // 4. All of the hosts' pipelines are notified they have capacity in a loop.
   // 5. On the first iteration, the first pipeline is opened up to accept new
   // requests and steals the request from step #2.
   // 6. The pipeline from #2 is deleted because it has no streams.
   // 7. On the second iteration, the host tries to notify the pipeline from step
   // #2 that it has capacity. This is a use-after-free.
   Initialize();
 
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
-    MockWrite(true, 3, "GET /two.html HTTP/1.1\r\n"
+    MockWrite(ASYNC, 3, "GET /two.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 2, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 4, "one.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 8\r\n\r\n"),
-    MockRead(false, 7, "two.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "one.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   AddExpectedConnection(NULL, 0, NULL, 0);
 
   HttpNetworkTransaction one_transaction(session_.get());
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             one_transaction.Start(GetRequestInfo("one.html"),
                                   one_callback.callback(), BoundNetLog()));
@@ skipping 22 matching lines @@
 
   EXPECT_EQ(OK, one_callback.WaitForResult());
   ExpectResponse("one.html", one_transaction);
   EXPECT_EQ(OK, two_callback.WaitForResult());
   ExpectResponse("two.html", two_transaction);
 }
 
 }  // anonymous namespace
 
 }  // namespace net