Change MockRead and MockWrite (et. al.) to take an IoMode enum, 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 413 matching lines @@
 TEST_F(HttpNetworkTransactionTest, Basic) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 }
 
 TEST_F(HttpNetworkTransactionTest, SimpleGET) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Response with no status line.
 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeaders) {
   MockRead data_reads[] = {
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk2Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk4Bytes) {
   MockRead data_reads[] = {
     MockRead("\n\nQJHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Beyond 4 bytes of slop and it should fail to find a status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk5Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxxxHTTP/1.1 404 Not Found\nServer: blah"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("xxxxxHTTP/1.1 404 Not Found\nServer: blah", out.response_data);
 }
 
 // Same as StatusLineJunk4Bytes, except the read chunks are smaller.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk4Bytes_Slow) {
   MockRead data_reads[] = {
     MockRead("\n"),
     MockRead("\n"),
     MockRead("Q"),
     MockRead("J"),
     MockRead("HTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Close the connection before enough bytes to have a status line.
 TEST_F(HttpNetworkTransactionTest, StatusLinePartial) {
   MockRead data_reads[] = {
     MockRead("HTT"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("HTT", out.response_data);
 }
 
 // Simulate a 204 response, lacking a Content-Length header, sent over a
 // persistent connection.  The response should still terminate since a 204
 // cannot have a response body.
 TEST_F(HttpNetworkTransactionTest, StopsReading204) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 204 No Content", out.status_line);
   EXPECT_EQ("", out.response_data);
 }
 
 // A simple request using chunked encoding with some extra data after.
 // (Like might be seen in a pipelined response.)
 TEST_F(HttpNetworkTransactionTest, ChunkedEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"),
     MockRead("5\r\nHello\r\n"),
     MockRead("1\r\n"),
     MockRead(" \r\n"),
     MockRead("5\r\nworld\r\n"),
     MockRead("0\r\n\r\nHTTP/1.1 200 OK\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello world", out.response_data);
 }
 
 // Next tests deal with http://crbug.com/56344.
 
@@ skipping 75 matching lines @@
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 666\r\n"),
     MockRead("Content-Length: 1337\r\n"),
     MockRead("Transfer-Encoding: chunked\r\n\r\n"),
     MockRead("5\r\nHello\r\n"),
     MockRead("1\r\n"),
     MockRead(" \r\n"),
     MockRead("5\r\nworld\r\n"),
     MockRead("0\r\n\r\nHTTP/1.1 200 OK\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello world", out.response_data);
 }
 
 // Next tests deal with http://crbug.com/98895.
 
@@ skipping 40 matching lines @@
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION, out.rv);
 }
 
 // Checks the behavior of a single Location header.
 TEST_F(HttpNetworkTransactionTest, SingleLocationHeader) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://redirect.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
@@ skipping 16 matching lines @@
   EXPECT_EQ("http://good.com/", url);
 }
 
 // Checks that two identical Location headers result in an error.
 TEST_F(HttpNetworkTransactionTest, DuplicateIdenticalLocationHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION, out.rv);
 }
 
 // Checks that two distinct Location headers result in an error.
 TEST_F(HttpNetworkTransactionTest, DuplicateDistinctLocationHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Location: http://evil.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION, out.rv);
 }
 
 // Do a request using the HEAD method. Verify that we don't try to read the
 // message body (since HEAD has none).
 TEST_F(HttpNetworkTransactionTest, Head) {
   HttpRequestInfo request;
@@ skipping 10 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
   };
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Server: Blah\r\n"),
     MockRead("Content-Length: 1234\r\n\r\n"),
 
     // No response body because the test stops reading here.
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 26 matching lines @@
 
 TEST_F(HttpNetworkTransactionTest, ReuseConnection) {
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   const char* const kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     HttpRequestInfo request;
@@ skipping 33 matching lines @@
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 100 Continue\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 21 matching lines @@
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n"
              "HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 15 matching lines @@
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
-    MockRead(false, "HTTP/1.0 100 Continue\r\n"),
-    MockRead(true, 0),
+    MockRead(SYNCHRONOUS, "HTTP/1.0 100 Continue\r\n"),
+    MockRead(ASYNC, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
 TEST_F(HttpNetworkTransactionTest, EmptyResponse) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
-    MockRead(true, 0),
+    MockRead(ASYNC, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 18 matching lines @@
               "Connection: keep-alive\r\n\r\n"),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.foo.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   // Read results for the first request.
   MockRead data1_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
 
   if (write_failure) {
     ASSERT_TRUE(!read_failure);
     data1_writes[1] = *write_failure;
   } else {
     ASSERT_TRUE(read_failure);
     data1_reads[2] = *read_failure;
   }
 
   StaticSocketDataProvider data1(data1_reads, arraysize(data1_reads),
                                  data1_writes, arraysize(data1_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   MockRead data2_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider data2(data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     TestCompletionCallback callback;
@@ skipping 13 matching lines @@
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
     EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionNotConnectedOnWrite) {
-  MockWrite write_failure(true, ERR_SOCKET_NOT_CONNECTED);
+  MockWrite write_failure(ASYNC, ERR_SOCKET_NOT_CONNECTED);
   KeepAliveConnectionResendRequestTest(&write_failure, NULL);
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionReset) {
-  MockRead read_failure(true, ERR_CONNECTION_RESET);
+  MockRead read_failure(ASYNC, ERR_CONNECTION_RESET);
   KeepAliveConnectionResendRequestTest(NULL, &read_failure);
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionEOF) {
-  MockRead read_failure(false, OK);  // EOF
+  MockRead read_failure(SYNCHRONOUS, OK);  // EOF
   KeepAliveConnectionResendRequestTest(NULL, &read_failure);
 }
 
 TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
-    MockRead(true, ERR_CONNECTION_RESET),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // What do various browsers do when the server closes a non-keepalive
 // connection without sending any response header or body?
 //
 // IE7: error page
 // Safari 3.1.2 (Windows): error page
 // Firefox 3.0.1: blank page
 // Opera 9.52: after five attempts, blank page
 // Us with WinHTTP: error page (ERR_INVALID_RESPONSE)
 // Us: error page (EMPTY_RESPONSE)
 TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionEOF) {
   MockRead data_reads[] = {
-    MockRead(false, OK),  // EOF
+    MockRead(SYNCHRONOUS, OK),  // EOF
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_EMPTY_RESPONSE, out.rv);
 }
 
 // Test that we correctly reuse a keep-alive connection after not explicitly
 // reading the body.
 TEST_F(HttpNetworkTransactionTest, KeepAliveAfterUnreadBody) {
   HttpRequestInfo request;
@@ skipping 21 matching lines @@
     MockRead("HTTP/1.1 301 Moved Permanently\r\n"
              "Content-Length: 5\r\n\r\n"
              "hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
   };
   StaticSocketDataProvider data1(data1_reads, arraysize(data1_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   MockRead data2_reads[] = {
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
   StaticSocketDataProvider data2(data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const int kNumUnreadBodies = arraysize(data1_reads) - 2;
   std::string response_lines[kNumUnreadBodies];
 
   for (size_t i = 0; i < arraysize(data1_reads) - 2; ++i) {
     TestCompletionCallback callback;
 
@@ skipping 67 matching lines @@
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     // Give a couple authenticate options (only the middle one is actually
     // supported).
     MockRead("WWW-Authenticate: Basic invalid\r\n"),  // Malformed.
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("WWW-Authenticate: UNSUPPORTED realm=\"FOO\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   // After calling trans->RestartWithAuth(), this is the request we should
   // be issuing -- the final header line contains the credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
@@ skipping 38 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 39 matching lines @@
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("Hello"),
   };
 
   // If there is a regression where we disconnect a Keep-Alive
   // connection during an auth roundtrip, we'll end up reading this.
   MockRead data_reads2[] = {
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
@@ skipping 55 matching lines @@
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("hello"),
   };
 
   // An incorrect reconnect would cause this to be read.
   MockRead data_reads2[] = {
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
@@ skipping 52 matching lines @@
   std::string large_body_string("Unauthorized");
   large_body_string.append(5 * 1024, ' ');
   large_body_string.append("\r\n");
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // 5134 = 12 + 5 * 1024 + 2
     MockRead("Content-Length: 5134\r\n\r\n"),
-    MockRead(true, large_body_string.data(), large_body_string.size()),
+    MockRead(ASYNC, large_body_string.data(), large_body_string.size()),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("hello"),
   };
 
   // An incorrect reconnect would cause this to be read.
   MockRead data_reads2[] = {
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
@@ skipping 46 matching lines @@
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 14\r\n\r\n"),
     // Tell MockTCPClientSocket to simulate the server closing the connection.
-    MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead("Unauthorized\r\n"),
-    MockRead(false, OK),  // The server closes the connection.
+    MockRead(SYNCHRONOUS, OK),  // The server closes the connection.
   };
 
   // After calling trans->RestartWithAuth(), this is the request we should
   // be issuing -- the final header line contains the credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
@@ skipping 80 matching lines @@
     // No credentials.
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Proxy-Connection: close\r\n\r\n"),
 
     MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
 
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
-    MockRead(false, "hello"),
+    MockRead(SYNCHRONOUS, "hello"),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 78 matching lines @@
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead("0123456789"),
 
     // Wrong credentials (wrong password).
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 63 matching lines @@
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   // The proxy responds to the connect with a 407.
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 34 matching lines @@
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 407 Proxy Auth required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 29 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
 
     MockRead("HTTP/1.1 407 Unauthorized\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 26 matching lines @@
   MockWrite data_writes1[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 28 matching lines @@
   // fetch http://www.google.com/ via SPDY
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST,
                                                    false));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
-    MockRead(true, 0, 0),
+    MockRead(ASYNC, 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());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 55 matching lines @@
           1));
   scoped_ptr<spdy::SpdyFrame> body_authentication(
       ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> resp_data(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body_data(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp_authentication, 2),
     CreateMockRead(*body_authentication, 3),
     CreateMockRead(*resp_data, 5),
     CreateMockRead(*body_data, 6),
-    MockRead(true, 0, 7),
+    MockRead(ASYNC, 0, 7),
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(data.get());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 61 matching lines @@
   scoped_ptr<spdy::SpdyFrame> window_update(
       ConstructSpdyWindowUpdate(1, wrapped_get_resp->length()));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*wrapped_get, 3),
       CreateMockWrite(*window_update, 5)
   };
 
   MockRead spdy_reads[] = {
-    CreateMockRead(*conn_resp, 2, true),
-    CreateMockRead(*wrapped_get_resp, 4, true),
-    CreateMockRead(*wrapped_body, 6, true),
-    CreateMockRead(*wrapped_body, 7, true),
-    MockRead(true, 0, 8),
+    CreateMockRead(*conn_resp, 2, ASYNC),
+    CreateMockRead(*wrapped_get_resp, 4, ASYNC),
+    CreateMockRead(*wrapped_body, 6, ASYNC),
+    CreateMockRead(*wrapped_body, 7, ASYNC),
+    MockRead(ASYNC, 0, 8),
   };
 
   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());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
-  SSLSocketDataProvider ssl2(true, OK);
+  SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.was_npn_negotiated = false;
   ssl2.protocol_negotiated = SSLClientSocket::kProtoUnknown;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 43 matching lines @@
       ConstructSpdyWindowUpdate(1, wrapped_body->length()));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*wrapped_get, 3),
       CreateMockWrite(*window_update_get_resp, 5),
       CreateMockWrite(*window_update_body, 7),
   };
 
   MockRead spdy_reads[] = {
-    CreateMockRead(*conn_resp, 2, true),
-    CreateMockRead(*wrapped_get_resp, 4, true),
-    CreateMockRead(*wrapped_body, 6, true),
-    MockRead(true, 0, 8),
+    CreateMockRead(*conn_resp, 2, ASYNC),
+    CreateMockRead(*wrapped_get_resp, 4, ASYNC),
+    CreateMockRead(*wrapped_body, 6, ASYNC),
+    MockRead(ASYNC, 0, 8),
   };
 
   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());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
-  SSLSocketDataProvider ssl2(true, OK);
+  SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.SetNextProto(SSLClientSocket::kProtoSPDY21);
   ssl2.protocol_negotiated = SSLClientSocket::kProtoSPDY21;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 30 matching lines @@
   scoped_ptr<spdy::SpdyFrame> get(ConstructSpdyRstStream(1, spdy::CANCEL));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*get, 3),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdySynReplyError(1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
-    CreateMockRead(*resp, 2, true),
-    MockRead(true, 0, 4),
+    CreateMockRead(*resp, 2, ASYNC),
+    MockRead(ASYNC, 0, 4),
   };
 
   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());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
-  SSLSocketDataProvider ssl2(true, OK);
+  SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ skipping 37 matching lines @@
   MockRead data_reads1[] = {
     // No credentials.
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Proxy-Connection: keep-alive\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
 
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 43 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     status,
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
@@ skipping 197 matching lines @@
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 407 Unauthorized\r\n"),
     // Give a couple authenticate options (only the middle one is actually
     // supported).
     MockRead("Proxy-Authenticate: Basic invalid\r\n"),  // Malformed.
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Proxy-Authenticate: UNSUPPORTED realm=\"FOO\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   // After calling trans->RestartWithAuth() the first time, this is the
   // request we should be issuing -- the final header line contains the
   // proxy's credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Now the proxy server lets the request pass through to origin server.
   // The origin server responds with a 401.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     // Note: We are using the same realm-name as the proxy server. This is
     // completely valid, as realms are unique across hosts.
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 2000\r\n\r\n"),
-    MockRead(false, ERR_FAILED),  // Won't be reached.
+    MockRead(SYNCHRONOUS, ERR_FAILED),  // Won't be reached.
   };
 
   // After calling trans->RestartWithAuth() the second time, we should send
   // the credentials for both the proxy and origin server.
   MockWrite data_writes3[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n"
               "Authorization: Basic Zm9vMjpiYXIy\r\n\r\n"),
   };
 
   // Lastly we get the desired content.
   MockRead data_reads3[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
@@ skipping 67 matching lines @@
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     // Negotiate and NTLM are often requested together.  However, we only want
     // to test NTLM. Since Negotiate is preferred over NTLM, we have to skip
     // the header that requests Negotiate for this test.
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, ERR_UNEXPECTED),
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 25 matching lines @@
              "BtAAAAAAA=\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
@@ skipping 62 matching lines @@
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     // Negotiate and NTLM are often requested together.  However, we only want
     // to test NTLM. Since Negotiate is preferred over NTLM, we have to skip
     // the header that requests Negotiate for this test.
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, ERR_UNEXPECTED),
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 27 matching lines @@
     MockRead("Content-Type: text/html\r\n\r\n"),
     MockRead("You are not authorized to view this page\r\n"),
 
     // Wrong password.
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, ERR_UNEXPECTED),
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes3[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 25 matching lines @@
              "BtAAAAAAA=\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
@@ skipping 76 matching lines @@
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   // Respond with 300 kb of headers (we should fail after 256 kb).
   std::string large_headers_string;
   FillLargeHeadersString(&large_headers_string, 300 * 1024);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
-    MockRead(true, large_headers_string.data(), large_headers_string.size()),
+    MockRead(ASYNC, large_headers_string.data(), large_headers_string.size()),
     MockRead("\r\nBODY"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 25 matching lines @@
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   // The proxy responds to the connect with a 404, using a persistent
   // connection. Usually a proxy would return 501 (not implemented),
   // or 200 (tunnel established).
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 29 matching lines @@
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   MockRead data_reads[] = {
     // A part of the response body is received with the response headers.
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\nhel"),
     // The rest of the response body is received in two parts.
     MockRead("lo"),
     MockRead(" world"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 34 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 11\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
@@ skipping 37 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 11\r\n\r\n"),
-    MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead("hello world"),
-    MockRead(true, 0, 0)   // EOF
+    MockRead(ASYNC, 0, 0)   // EOF
   };
 
-  SSLSocketDataProvider ssl(true, OK);
-  SSLSocketDataProvider ssl2(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
+  SSLSocketDataProvider ssl2(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   StaticSocketDataProvider data2(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
@@ skipping 68 matching lines @@
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n"
              "Content-Length: 0\r\n"
              "Content-Type: text/html\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 42 matching lines @@
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   // The first socket is used for transaction 1 and the first attempt of
   // transaction 2.
 
   // The response of transaction 1.
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   // The mock write results of transaction 1 and the first attempt of
   // transaction 2.
   MockWrite data_writes1[] = {
-    MockWrite(false, 64),  // GET
-    MockWrite(false, 93),  // POST
-    MockWrite(false, ERR_CONNECTION_ABORTED),  // POST data
+    MockWrite(SYNCHRONOUS, 64),  // GET
+    MockWrite(SYNCHRONOUS, 93),  // POST
+    MockWrite(SYNCHRONOUS, ERR_CONNECTION_ABORTED),  // POST data
   };
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
 
   // The second socket is used for the second attempt of transaction 2.
 
   // The response of transaction 2.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 7\r\n\r\n"),
     MockRead("welcome"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   // The mock write results of the second attempt of transaction 2.
   MockWrite data_writes2[] = {
-    MockWrite(false, 93),  // POST
-    MockWrite(false, 3),  // POST data
+    MockWrite(SYNCHRONOUS, 93),  // POST
+    MockWrite(SYNCHRONOUS, 3),  // POST data
   };
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
 
   session_deps.socket_factory.AddSocketDataProvider(&data1);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello world", "welcome"
   };
@@ skipping 43 matching lines @@
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, ERR_FAILED),
+    MockRead(SYNCHRONOUS, ERR_FAILED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback1.WaitForResult();
@@ skipping 21 matching lines @@
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, ERR_FAILED),
+      MockRead(SYNCHRONOUS, ERR_FAILED),
     };
 
     // Resend with authorization (username=foo, password=bar)
     MockWrite data_writes2[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
@@ skipping 43 matching lines @@
                 // Send preemptive authorization for MyRealm1
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // The server didn't like the preemptive authorization, and
     // challenges us for a different realm (MyRealm2).
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm2\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, ERR_FAILED),
+      MockRead(SYNCHRONOUS, ERR_FAILED),
     };
 
     // Resend with authorization for MyRealm2 (username=foo2, password=bar2)
     MockWrite data_writes2[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vMjpiYXIy\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
@@ skipping 46 matching lines @@
                 "Connection: keep-alive\r\n"
                 // The authorization for MyRealm1 gets sent preemptively
                 // (since the url is in the same protection space)
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the preemptive authorization
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 23 matching lines @@
     MockWrite data_writes1[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, ERR_FAILED),
+      MockRead(SYNCHRONOUS, ERR_FAILED),
     };
 
     // Resend with authorization from MyRealm's cache.
     MockWrite data_writes2[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
@@ skipping 33 matching lines @@
     MockWrite data_writes1[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, ERR_FAILED),
+      MockRead(SYNCHRONOUS, ERR_FAILED),
     };
 
     // Resend with authorization from cache for MyRealm.
     MockWrite data_writes2[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever rejects the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, ERR_FAILED),
+      MockRead(SYNCHRONOUS, ERR_FAILED),
     };
 
     // At this point we should prompt for new credentials for MyRealm.
     // Restart with username=foo3, password=foo4.
     MockWrite data_writes3[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vMzpiYXIz\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads3[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                    data_writes3, arraysize(data_writes3));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
@@ skipping 59 matching lines @@
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Digest realm=\"digestive\", nonce=\"OU812\", "
                "algorithm=MD5, qop=\"auth\"\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     // Resend with authorization (username=foo, password=bar)
     MockWrite data_writes2[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Digest username=\"foo\", realm=\"digestive\", "
                 "nonce=\"OU812\", uri=\"/x/y/z\", algorithm=MD5, "
                 "response=\"03ffbcd30add722589c1de345d7a927f\", qop=auth, "
                 "nc=00000001, cnonce=\"0123456789abcdef\"\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
     session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
@@ skipping 44 matching lines @@
                 "Authorization: Digest username=\"foo\", realm=\"digestive\", "
                 "nonce=\"OU812\", uri=\"/x/y/a/b\", algorithm=MD5, "
                 "response=\"d6f9a2c07d1c5df7b89379dca1269b35\", qop=auth, "
                 "nc=00000002, cnonce=\"0123456789abcdef\"\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, OK),
+      MockRead(SYNCHRONOUS, OK),
     };
 
     StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                    data_writes1, arraysize(data_writes1));
     session_deps.socket_factory.AddSocketDataProvider(&data1);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 64 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider ssl_bad_certificate;
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
-  SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl_bad(ASYNC, ERR_CERT_AUTHORITY_INVALID);
+  SSLSocketDataProvider ssl(ASYNC, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 24 matching lines @@
   request.load_flags = 0;
 
   MockWrite proxy_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead proxy_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider ssl_bad_certificate(
       proxy_reads, arraysize(proxy_reads),
       proxy_writes, arraysize(proxy_writes));
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
-  SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl_bad(ASYNC, ERR_CERT_AUTHORITY_INVALID);
+  SSLSocketDataProvider ssl(ASYNC, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   for (int i = 0; i < 2; i++) {
     session_deps.socket_factory.ResetNextMockIndexes();
@@ skipping 38 matching lines @@
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
-  SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
-  SSLSocketDataProvider tunnel_ssl(true, OK);  // SSL through the tunnel
+  SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
+  SSLSocketDataProvider tunnel_ssl(ASYNC, OK);  // SSL through the tunnel
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
   session_deps.socket_factory.AddSSLSocketDataProvider(&tunnel_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
@@ skipping 25 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://login.example.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
-  SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
+  SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ skipping 17 matching lines @@
       ProxyService::CreateFixed("https://proxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<spdy::SpdyFrame> conn(ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> goaway(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockWrite data_writes[] = {
-    CreateMockWrite(*conn.get(), 0, false),
+    CreateMockWrite(*conn.get(), 0, SYNCHRONOUS),
   };
 
   static const char* const kExtraHeaders[] = {
     "location",
     "http://login.example.com/",
   };
   scoped_ptr<spdy::SpdyFrame> resp(
       ConstructSpdySynReplyError("302 Redirect", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   MockRead data_reads[] = {
-    CreateMockRead(*resp.get(), 1, false),
-    MockRead(true, 0, 2),  // EOF
+    CreateMockRead(*resp.get(), 1, SYNCHRONOUS),
+    MockRead(ASYNC, 0, 2),  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
-  SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
+  SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
   proxy_ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
 
   session_deps.socket_factory.AddSocketDataProvider(data.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
@@ skipping 25 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 23\r\n\r\n"),
     MockRead("The host does not exist"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
-  SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
+  SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
@@ skipping 22 matching lines @@
       ProxyService::CreateFixed("https://proxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<spdy::SpdyFrame> conn(ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> goaway(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockWrite data_writes[] = {
-    CreateMockWrite(*conn.get(), 0, false),
+    CreateMockWrite(*conn.get(), 0, SYNCHRONOUS),
   };
 
   static const char* const kExtraHeaders[] = {
     "location",
     "http://login.example.com/",
   };
   scoped_ptr<spdy::SpdyFrame> resp(
       ConstructSpdySynReplyError("404 Not Found", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   scoped_ptr<spdy::SpdyFrame> body(
       ConstructSpdyBodyFrame(1, "The host does not exist", 23, true));
   MockRead data_reads[] = {
-    CreateMockRead(*resp.get(), 1, false),
-    CreateMockRead(*body.get(), 2, false),
-    MockRead(true, 0, 3),  // EOF
+    CreateMockRead(*resp.get(), 1, SYNCHRONOUS),
+    CreateMockRead(*body.get(), 2, SYNCHRONOUS),
+    MockRead(ASYNC, 0, 3),  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
-  SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
+  SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
   proxy_ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
 
   session_deps.socket_factory.AddSocketDataProvider(data.get());
   session_deps.socket_factory.AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
@@ skipping 27 matching lines @@
 
   // Attempt to fetch the URL from a server with a bad cert
   MockWrite bad_cert_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead bad_cert_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   // Attempt to fetch the URL with a good cert
   MockWrite good_data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead good_cert_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider ssl_bad_certificate(
       bad_cert_reads, arraysize(bad_cert_reads),
       bad_cert_writes, arraysize(bad_cert_writes));
   StaticSocketDataProvider data(good_cert_reads, arraysize(good_cert_reads),
                                 good_data_writes, arraysize(good_data_writes));
-  SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl_bad(ASYNC, ERR_CERT_AUTHORITY_INVALID);
+  SSLSocketDataProvider ssl(ASYNC, OK);
 
   // SSL to the proxy, then CONNECT request, then SSL with bad certificate
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
 
   // SSL to the proxy, then CONNECT request, then valid SSL certificate
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
@@ skipping 37 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "User-Agent: Chromium Ultra Awesome X Edition\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 57 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Referer: http://the.previous.site.com/\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 16 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 16 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 16 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 18 matching lines @@
               "Connection: keep-alive\r\n"
               "Pragma: no-cache\r\n"
               "Cache-Control: no-cache\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 18 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Cache-Control: max-age=0\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 17 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "FooHeader: Bar\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 21 matching lines @@
               "referer: www.foo.com\r\n"
               "hEllo: Kitty\r\n"
               "FoO: bar\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 18 matching lines @@
   SessionDependencies session_deps(
       ProxyService::CreateFixed("socks4://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   char write_buffer[] = { 0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0 };
   char read_buffer[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
 
   MockWrite data_writes[] = {
-    MockWrite(true, write_buffer, arraysize(write_buffer)),
+    MockWrite(ASYNC, write_buffer, arraysize(write_buffer)),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead data_reads[] = {
-    MockRead(true, read_buffer, arraysize(read_buffer)),
+    MockRead(ASYNC, read_buffer, arraysize(read_buffer)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 26 matching lines @@
   SessionDependencies session_deps(
       ProxyService::CreateFixed("socks4://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   unsigned char write_buffer[] = { 0x04, 0x01, 0x01, 0xBB, 127, 0, 0, 1, 0 };
   unsigned char read_buffer[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
 
   MockWrite data_writes[] = {
-    MockWrite(true, reinterpret_cast<char*>(write_buffer),
+    MockWrite(ASYNC, reinterpret_cast<char*>(write_buffer),
               arraysize(write_buffer)),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead data_reads[] = {
-    MockWrite(true, reinterpret_cast<char*>(read_buffer),
+    MockWrite(ASYNC, reinterpret_cast<char*>(read_buffer),
               arraysize(read_buffer)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
@@ skipping 27 matching lines @@
     0x03,  // Address type (DOMAINNAME).
     0x0E,  // Length of domain (14)
     // Domain string:
     'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm',
     0x00, 0x50,  // 16-bit port (80)
   };
   const char kSOCKS5OkResponse[] =
       { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 
   MockWrite data_writes[] = {
-    MockWrite(true, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-    MockWrite(true, kSOCKS5OkRequest, arraysize(kSOCKS5OkRequest)),
+    MockWrite(ASYNC, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
+    MockWrite(ASYNC, kSOCKS5OkRequest, arraysize(kSOCKS5OkRequest)),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead data_reads[] = {
-    MockWrite(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 32 matching lines @@
     0x0E,  // Length of domain (14)
     // Domain string:
     'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm',
     0x01, 0xBB,  // 16-bit port (443)
   };
 
   const char kSOCKS5OkResponse[] =
       { 0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0x00, 0x00 };
 
   MockWrite data_writes[] = {
-    MockWrite(true, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
-    MockWrite(true, reinterpret_cast<const char*>(kSOCKS5OkRequest),
+    MockWrite(ASYNC, kSOCKS5GreetRequest, arraysize(kSOCKS5GreetRequest)),
+    MockWrite(ASYNC, reinterpret_cast<const char*>(kSOCKS5OkRequest),
               arraysize(kSOCKS5OkRequest)),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead data_reads[] = {
-    MockWrite(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
@@ skipping 304 matching lines @@
       callback.callback(), NULL, BoundNetLog());
   ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
   // we can tell if the next lookup hit the cache, or the "network".
   // (cache --> success, "network" --> failure).
   session_deps.host_resolver->rules()->AddSimulatedFailure("www.google.com");
 
   // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
   // first read -- this won't be reached as the host resolution will fail first.
-  MockRead data_reads[] = { MockRead(false, ERR_UNEXPECTED) };
+  MockRead data_reads[] = { MockRead(SYNCHRONOUS, ERR_UNEXPECTED) };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Run the request.
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
@@ skipping 18 matching lines @@
 TEST_F(HttpNetworkTransactionTest, RequestWriteError) {
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockWrite write_failure[] = {
-    MockWrite(true, ERR_CONNECTION_RESET),
+    MockWrite(ASYNC, ERR_CONNECTION_RESET),
   };
   StaticSocketDataProvider data(NULL, 0,
                                 write_failure, arraysize(write_failure));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 }
 
 // Check that a connection closed after the start of the headers finishes ok.
 TEST_F(HttpNetworkTransactionTest, ConnectionClosedAfterStartOfHeaders) {
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1."),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
@@ skipping 31 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 14\r\n\r\n"),
     MockRead("Unauth"),
-    MockRead(true, ERR_CONNECTION_RESET),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   // After calling trans->RestartWithAuth(), this is the request we should
   // be issuing -- the final header line contains the credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
@@ skipping 26 matching lines @@
 TEST_F(HttpNetworkTransactionTest, HTTPSViaProxyWithExtraData) {
   SessionDependencies session_deps(ProxyService::CreateFixed("myproxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockRead proxy_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\nExtra data"),
-    MockRead(false, OK)
+    MockRead(SYNCHRONOUS, OK)
   };
 
   StaticSocketDataProvider data(proxy_reads, arraysize(proxy_reads), NULL, 0);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   session_deps.socket_factory.ResetNextMockIndexes();
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
@@ skipping 10 matching lines @@
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\nContent-Length:6719476739\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 29 matching lines @@
   UploadData::Element element;
   element.SetToFilePath(temp_file_path);
   element.SetContentLength(kFakeSize);
   elements.push_back(element);
   request.upload_data->SetElements(elements);
   EXPECT_EQ(kFakeSize, request.upload_data->GetContentLengthSync());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 34 matching lines @@
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
   std::vector<UploadData::Element> elements;
   UploadData::Element element;
   element.SetToFilePath(temp_file);
   elements.push_back(element);
   request.upload_data->SetElements(elements);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   MockWrite data_writes[] = {
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
-    MockWrite(false, OK),
+    MockWrite(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 32 matching lines @@
   elements.push_back(element);
   request.upload_data->SetElements(elements);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),  // No response body.
 
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   MockWrite data_writes[] = {
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 16\r\n\r\n"),
-    MockWrite(false, temp_file_contents.c_str()),
+    MockWrite(SYNCHRONOUS, temp_file_contents.c_str()),
 
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 16\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
-    MockWrite(false, unreadable_contents.c_str(), temp_file_contents.length()),
-    MockWrite(false, OK),
+    MockWrite(SYNCHRONOUS, unreadable_contents.c_str(),
+              temp_file_contents.length()),
+    MockWrite(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 183 matching lines @@
 TEST_F(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
   HttpStreamFactory::set_next_protos(MakeNextProtos("foo", "bar", NULL));
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   SessionDependencies session_deps;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
@@ skipping 47 matching lines @@
   request.load_flags = 0;
 
   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),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   // Port must be < 1024, or the header will be ignored (since initial port was
@@ skipping 42 matching lines @@
   restricted_port_request.load_flags = 0;
 
   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),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
@@ skipping 28 matching lines @@
   restricted_port_request.load_flags = 0;
 
   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),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
@@ skipping 28 matching lines @@
   unrestricted_port_request.load_flags = 0;
 
   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),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
@@ skipping 28 matching lines @@
   unrestricted_port_request.load_flags = 0;
 
   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),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider second_data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
@@ skipping 24 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // The alternate protocol request will error out before we attempt to connect,
   // so only the standard HTTP request will try to connect.
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
   StaticSocketDataProvider data(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnsafePort = 7;
@@ skipping 30 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
-    MockRead(true, 0, 0),
+    MockRead(ASYNC, 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(SYNCHRONOUS, ERR_IO_PENDING);
@@ skipping 49 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, 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(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);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> req1(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req1),
     CreateMockWrite(*req2),
   };
   scoped_ptr<spdy::SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data1(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> data2(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp1),
     CreateMockRead(*data1),
     CreateMockRead(*resp2),
     CreateMockRead(*data2),
-    MockRead(true, 0, 0),
+    MockRead(ASYNC, 0, 0),
   };
 
   scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           2,  // wait for writes to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   // Socket 4 is the successful Alternate-Protocol for transaction 3.
   session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
@@ skipping 59 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   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);
@@ skipping 104 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite spdy_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),  // 0
     CreateMockWrite(*req)  // 3
   };
 
   const char kCONNECTResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
-    MockRead(true, kCONNECTResponse, arraysize(kCONNECTResponse) - 1, 1),  // 1
+    MockRead(ASYNC, kCONNECTResponse, arraysize(kCONNECTResponse) - 1, 1),  // 1
     CreateMockRead(*resp.get(), 4),  // 2, 4
     CreateMockRead(*data.get(), 4),  // 5
-    MockRead(true, 0, 0, 4),  // 6
+    MockRead(ASYNC, 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(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
@@ skipping 56 matching lines @@
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(true, OK),
+    MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&first_transaction);
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   // Make sure we use ssl for spdy here.
   SpdySession::SetSSLMode(true);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
-    MockRead(true, 0, 0),
+    MockRead(ASYNC, 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());
 
   TestCompletionCallback callback;
@@ skipping 439 matching lines @@
       size_t length_writes = 1;
       if (read_write_round.extra_write) {
         writes[1] = *read_write_round.extra_write;
         length_writes = 2;
       }
       StaticSocketDataProvider data_provider(
           reads, length_reads, writes, length_writes);
       session_deps.socket_factory.AddSocketDataProvider(&data_provider);
 
       // Add an SSL sequence if necessary.
-      SSLSocketDataProvider ssl_socket_data_provider(false, OK);
+      SSLSocketDataProvider ssl_socket_data_provider(SYNCHRONOUS, OK);
       if (round >= test_config.first_ssl_round)
         session_deps.socket_factory.AddSSLSocketDataProvider(
             &ssl_socket_data_provider);
 
       // Start or restart the transaction.
       TestCompletionCallback callback;
       int rv;
       if (round == 0) {
         rv = trans.Start(&request, callback.callback(), BoundNetLog());
       } else {
@@ skipping 209 matching lines @@
 }
 
 class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
  public:
   explicit TLSDecompressionFailureSocketDataProvider(bool fail_all)
       : fail_all_(fail_all) {
   }
 
   virtual MockRead GetNextRead() {
     if (fail_all_)
-      return MockRead(false /* async */, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
+      return MockRead(SYNCHRONOUS, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
 
-    return MockRead(false /* async */,
+    return MockRead(SYNCHRONOUS,
                     "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nok.\r\n");
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
-    return MockWriteResult(false /* async */, data.size());
+    return MockWriteResult(SYNCHRONOUS /* async */, data.size());
   }
 
   void Reset() {
   }
 
  private:
   const bool fail_all_;
 };
 
 // Test that we restart a connection when we see a decompression failure from
 // the peer during the handshake. (In the real world we'll restart with SSLv3
 // and we won't offer DEFLATE in that case.)
 TEST_F(HttpNetworkTransactionTest, RestartAfterTLSDecompressionFailure) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://tlsdecompressionfailure.example.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   TLSDecompressionFailureSocketDataProvider socket_data_provider1(
       false /* fail all reads */);
   TLSDecompressionFailureSocketDataProvider socket_data_provider2(false);
   SSLSocketDataProvider ssl_socket_data_provider1(
-      false, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
-  SSLSocketDataProvider ssl_socket_data_provider2(false, OK);
+      SYNCHRONOUS, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
+  SSLSocketDataProvider ssl_socket_data_provider2(SYNCHRONOUS, 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(ASYNC, ERR_UNEXPECTED));
@@ skipping 25 matching lines @@
        RestartAfterTLSDecompressionFailureWithFalseStart) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://tlsdecompressionfailure2.example.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   TLSDecompressionFailureSocketDataProvider socket_data_provider1(
       true /* fail all reads */);
   TLSDecompressionFailureSocketDataProvider socket_data_provider2(false);
-  SSLSocketDataProvider ssl_socket_data_provider1(false, OK);
-  SSLSocketDataProvider ssl_socket_data_provider2(false, OK);
+  SSLSocketDataProvider ssl_socket_data_provider1(SYNCHRONOUS, OK);
+  SSLSocketDataProvider ssl_socket_data_provider2(SYNCHRONOUS, 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);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
   TestCompletionCallback callback;
@@ skipping 27 matching lines @@
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "http/1.1";
   ssl.protocol_negotiated = SSLClientSocket::kProtoHTTP11;
 
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
@@ skipping 29 matching lines @@
   // Fix crash:  http://crbug.com/46369
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::set_next_protos(SpdyNextProtos());
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(SSLClientSocket::kProtoSPDY21);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   MockRead spdy_reads[] = {
-    MockRead(false, 0, 0)   // Not async - return 0 immediately.
+    MockRead(SYNCHRONOUS, 0, 0)   // Not async - return 0 immediately.
   };
 
   scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           0,  // don't wait in this case, immediate hangup.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   TestCompletionCallback callback;
@@ skipping 31 matching lines @@
   request.load_flags = 0;
 
   // First round goes unauthenticated through the proxy.
   MockWrite data_writes_1[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "\r\n"),
   };
   MockRead data_reads_1[] = {
-    MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead("HTTP/1.1 200 OK\r\n"
              "Alternate-Protocol: 443:npn-spdy/2.1\r\n"
              "Proxy-Connection: close\r\n"
              "\r\n"),
   };
   StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1),
                                   data_writes_1, arraysize(data_writes_1));
 
   // Second round tries to tunnel to www.google.com due to the
   // Alternate-Protocol announcement in the first round. It fails due
@@ skipping 33 matching lines @@
     // SPDY request
     CreateMockWrite(*req),
   };
   const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n"
                                          "Proxy-Authenticate: Mock\r\n"
                                          "Proxy-Connection: close\r\n"
                                          "\r\n");
   const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
   MockRead data_reads_2[] = {
     // First connection attempt fails
-    MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1),
-    MockRead(true, kRejectConnectResponse,
+    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1),
+    MockRead(ASYNC, kRejectConnectResponse,
              arraysize(kRejectConnectResponse) - 1, 1),
 
     // Second connection attempt passes
-    MockRead(true, kAcceptConnectResponse,
+    MockRead(ASYNC, kAcceptConnectResponse,
              arraysize(kAcceptConnectResponse) -1, 4),
 
     // SPDY response
     CreateMockRead(*resp.get(), 6),
     CreateMockRead(*data.get(), 6),
-    MockRead(true, 0, 0, 6),
+    MockRead(ASYNC, 0, 0, 6),
   };
   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);
+  SSLSocketDataProvider ssl(ASYNC, 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(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);
@@ skipping 42 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(SYNCHRONOUS, OK);
   MockRead data_reads[] = {
-    MockRead(false, "HTTP/1.0 200 OK\r\n\r\n"),
-    MockRead(false, "hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, "HTTP/1.0 200 OK\r\n\r\n"),
+    MockRead(SYNCHRONOUS, "hello world"),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   SessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
   scoped_ptr<HttpTransaction> trans(
@@ skipping 27 matching lines @@
   MockWrite data_writes1[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
@@ skipping 34 matching lines @@
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
 
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 35 matching lines @@
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
 
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
-    MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps.socket_factory.AddSocketDataProvider(&data1);
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
@@ skipping 15 matching lines @@
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(
       "https://www.google.com", false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
-    MockRead(true, 0, 0),
+    MockRead(ASYNC, 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());
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, 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);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.google.com", 443);
@@ skipping 22 matching lines @@
 
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Given a net error, cause that error to be returned from the first Write()
 // call and verify that the HttpTransaction fails with that error.
-static void CheckErrorIsPassedBack(int error, bool async) {
+static void CheckErrorIsPassedBack(int error, IoMode mode) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   SessionDependencies session_deps;
 
-  SSLSocketDataProvider ssl_data(async, OK);
+  SSLSocketDataProvider ssl_data(mode, OK);
   net::MockWrite data_writes[] = {
-    net::MockWrite(async, error),
+    net::MockWrite(mode, error),
   };
   net::StaticSocketDataProvider data(NULL, 0,
                                      data_writes, arraysize(data_writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(error, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, SSLWriteCertError) {
   // Just check a grab bag of cert errors.
   static const int kErrors[] = {
     ERR_CERT_COMMON_NAME_INVALID,
     ERR_CERT_AUTHORITY_INVALID,
     ERR_CERT_DATE_INVALID,
   };
   for (size_t i = 0; i < arraysize(kErrors); i++) {
-    CheckErrorIsPassedBack(kErrors[i], false /* not async */);
-    CheckErrorIsPassedBack(kErrors[i], true /* async */);
+    CheckErrorIsPassedBack(kErrors[i], ASYNC);
+    CheckErrorIsPassedBack(kErrors[i], SYNCHRONOUS);
   }
 }
 
 // Ensure that a client certificate is removed from the SSL client auth
 // cache when:
 //  1) No proxy is involved.
 //  2) TLS False Start is disabled.
 //  3) The initial TLS handshake requests a client certificate.
 //  4) The client supplies an invalid/unacceptable certificate.
 TEST_F(HttpNetworkTransactionTest, ClientAuthCertCache_Direct_NoFalseStart) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   SessionDependencies session_deps;
 
   scoped_refptr<SSLCertRequestInfo> cert_request(new SSLCertRequestInfo());
   cert_request->host_and_port = "www.example.com:443";
 
   // [ssl_]data1 contains the data for the first SSL handshake. When a
   // CertificateRequest is received for the first time, the handshake will
   // be aborted to allow the caller to provide a certificate.
-  SSLSocketDataProvider ssl_data1(true /* async */,
-                                  net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
+  SSLSocketDataProvider ssl_data1(ASYNC, net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
   ssl_data1.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data1);
   net::StaticSocketDataProvider data1(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   // [ssl_]data2 contains the data for the second SSL handshake. When TLS
   // False Start is not being used, the result of the SSL handshake will be
   // returned as part of the SSLClientSocket::Connect() call. This test
   // matches the result of a server sending a handshake_failure alert,
   // rather than a Finished message, because it requires a client
   // certificate and none was supplied.
-  SSLSocketDataProvider ssl_data2(true /* async */,
-                                  net::ERR_SSL_PROTOCOL_ERROR);
+  SSLSocketDataProvider ssl_data2(ASYNC, net::ERR_SSL_PROTOCOL_ERROR);
   ssl_data2.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data2);
   net::StaticSocketDataProvider data2(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   // [ssl_]data3 contains the data for the third SSL handshake. When a
   // connection to a server fails during an SSL handshake,
   // HttpNetworkTransaction will attempt to fallback to SSLv3 if the initial
   // connection was attempted with TLSv1. This is transparent to the caller
   // of the HttpNetworkTransaction. Because this test failure is due to
   // requiring a client certificate, this fallback handshake should also
   // fail.
-  SSLSocketDataProvider ssl_data3(true /* async */,
-                                  net::ERR_SSL_PROTOCOL_ERROR);
+  SSLSocketDataProvider ssl_data3(ASYNC, net::ERR_SSL_PROTOCOL_ERROR);
   ssl_data3.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data3);
   net::StaticSocketDataProvider data3(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   // Begin the SSL handshake with the peer. This consumes ssl_data1.
   TestCompletionCallback callback;
@@ skipping 56 matching lines @@
   // The actual handshake will be finished when SSLClientSocket::Read() is
   // called, which expects to process the peer's ChangeCipherSpec and
   // Finished messages. If there was an error negotiating with the peer,
   // such as due to the peer requiring a client certificate when none was
   // supplied, the alert sent by the peer won't be processed until Read() is
   // called.
 
   // Like the non-False Start case, when a client certificate is requested by
   // the peer, the handshake is aborted during the Connect() call.
   // [ssl_]data1 represents the initial SSL handshake with the peer.
-  SSLSocketDataProvider ssl_data1(true /* async */,
-                                  net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
+  SSLSocketDataProvider ssl_data1(ASYNC, net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
   ssl_data1.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data1);
   net::StaticSocketDataProvider data1(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   // When a client certificate is supplied, Connect() will not be aborted
   // when the peer requests the certificate. Instead, the handshake will
   // artificially succeed, allowing the caller to write the HTTP request to
   // the socket. The handshake messages are not processed until Read() is
   // called, which then detects that the handshake was aborted, due to the
   // peer sending a handshake_failure because it requires a client
   // certificate.
-  SSLSocketDataProvider ssl_data2(true /* async */, net::OK);
+  SSLSocketDataProvider ssl_data2(ASYNC, net::OK);
   ssl_data2.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data2);
   net::MockRead data2_reads[] = {
-    net::MockRead(true /* async */, net::ERR_SSL_PROTOCOL_ERROR),
+    net::MockRead(ASYNC /* async */, net::ERR_SSL_PROTOCOL_ERROR),
   };
   net::StaticSocketDataProvider data2(
       data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   // As described in ClientAuthCertCache_Direct_NoFalseStart, [ssl_]data3 is
   // the data for the SSL handshake once the TLSv1 connection falls back to
   // SSLv3. It has the same behaviour as [ssl_]data2.
-  SSLSocketDataProvider ssl_data3(true /* async */, net::OK);
+  SSLSocketDataProvider ssl_data3(ASYNC, net::OK);
   ssl_data3.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data3);
   net::StaticSocketDataProvider data3(
       data2_reads, arraysize(data2_reads), NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   // Begin the initial SSL handshake.
@@ skipping 47 matching lines @@
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   session_deps.net_log = log.bound().net_log();
 
   scoped_refptr<SSLCertRequestInfo> cert_request(new SSLCertRequestInfo());
   cert_request->host_and_port = "proxy:70";
 
   // See ClientAuthCertCache_Direct_NoFalseStart for the explanation of
   // [ssl_]data[1-3]. Rather than represending the endpoint
   // (www.example.com:443), they represent failures with the HTTPS proxy
   // (proxy:70).
-  SSLSocketDataProvider ssl_data1(true /* async */,
-                                  net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
+  SSLSocketDataProvider ssl_data1(ASYNC, net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
   ssl_data1.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data1);
   net::StaticSocketDataProvider data1(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data1);
 
-  SSLSocketDataProvider ssl_data2(true /* async */,
-                                  net::ERR_SSL_PROTOCOL_ERROR);
+  SSLSocketDataProvider ssl_data2(ASYNC, net::ERR_SSL_PROTOCOL_ERROR);
   ssl_data2.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data2);
   net::StaticSocketDataProvider data2(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data2);
 
-  SSLSocketDataProvider ssl_data3(true /* async */,
-                                  net::ERR_SSL_PROTOCOL_ERROR);
+  SSLSocketDataProvider ssl_data3(ASYNC, net::ERR_SSL_PROTOCOL_ERROR);
   ssl_data3.cert_request_info = cert_request.get();
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_data3);
   net::StaticSocketDataProvider data3(NULL, 0, NULL, 0);
   session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   net::HttpRequestInfo requests[2];
   requests[0].url = GURL("https://www.example.com/");
   requests[0].method = "GET";
   requests[0].load_flags = net::LOAD_NORMAL;
 
@@ skipping 98 matching lines @@
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
   params.http_auth_handler_factory =
       session_deps.http_auth_handler_factory.get();
   params.http_server_properties = &session_deps.http_server_properties;
   params.net_log = session_deps.net_log;
   scoped_refptr<HttpNetworkSession> session(new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, 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);
 
   scoped_ptr<spdy::SpdyFrame> host1_req(ConstructSpdyGet(
       "https://www.google.com", false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> host2_req(ConstructSpdyGet(
       "https://www.gmail.com", false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*host1_req, 1),
     CreateMockWrite(*host2_req, 4),
   };
   scoped_ptr<spdy::SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
-    MockRead(true, 0, 7),
+    MockRead(ASYNC, 0, 7),
   };
 
   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());
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
@@ skipping 109 matching lines @@
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
   params.http_auth_handler_factory =
       session_deps.http_auth_handler_factory.get();
   params.http_server_properties = &session_deps.http_server_properties;
   params.net_log = session_deps.net_log;
   scoped_refptr<HttpNetworkSession> session(new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
-  SSLSocketDataProvider ssl(true, OK);
+  SSLSocketDataProvider ssl(ASYNC, 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);
 
   scoped_ptr<spdy::SpdyFrame> host1_req(ConstructSpdyGet(
       "https://www.google.com", false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> host2_req(ConstructSpdyGet(
       "https://www.gmail.com", false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*host1_req, 1),
     CreateMockWrite(*host2_req, 4),
   };
   scoped_ptr<spdy::SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
-    MockRead(true, 0, 7),
+    MockRead(ASYNC, 0, 7),
   };
 
   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());
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
@@ skipping 48 matching lines @@
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 TEST_F(HttpNetworkTransactionTest, ReadPipelineEvictionFallback) {
   MockRead data_reads1[] = {
-    MockRead(false, ERR_PIPELINE_EVICTION),
+    MockRead(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
   };
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), NULL, 0);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), NULL, 0);
   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);
 }
 
 TEST_F(HttpNetworkTransactionTest, SendPipelineEvictionFallback) {
   MockWrite data_writes1[] = {
-    MockWrite(false, ERR_PIPELINE_EVICTION),
+    MockWrite(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
   };
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data1(NULL, 0,
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   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