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

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 213 matching lines @@
       RunPreTestSetup();
       AddData(data);
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void AddData(StaticSocketDataProvider* data) {
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
-          new SSLSocketDataProvider(true, OK));
+          new SSLSocketDataProvider(ASYNC, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
         ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)
         session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());
       session_deps_->socket_factory->AddSocketDataProvider(data);
       if (test_type_ == SPDYNPN) {
         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
         linked_ptr<StaticSocketDataProvider>
             hanging_non_alternate_protocol_socket(
                 new StaticSocketDataProvider(NULL, 0, NULL, 0));
         hanging_non_alternate_protocol_socket->set_connect_data(
             never_finishing_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alternate_protocol_socket.get());
         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
-          new SSLSocketDataProvider(true, OK));
+          new SSLSocketDataProvider(ASYNC, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
         ssl_->next_proto = "spdy/2.1";
         ssl_->was_npn_negotiated = true;
         ssl_->protocol_negotiated = SSLClientSocket::kProtoSPDY21;
       }
       ssl_vector_.push_back(ssl_);
       if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {
         session_deps_->deterministic_socket_factory->
             AddSSLSocketDataProvider(ssl_.get());
@@ skipping 277 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, Get) {
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 29 matching lines @@
         break;
       default:
         FAIL();
     }
 
     scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 0)  // EOF
     };
 
     scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     HttpRequestInfo http_req = CreateGetRequest();
     http_req.priority = p;
 
     NormalSpdyTransactionHelper helper(http_req, BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
@@ skipping 40 matching lines @@
     CreateMockRead(*body),
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*resp3, 7),
     CreateMockRead(*body3),
 
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
     CreateMockRead(*fbody3),
 
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 63 matching lines @@
     CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body),
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
 
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
@@ skipping 66 matching lines @@
     CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body),
     CreateMockRead(*resp2, 4),
     CreateMockRead(*body2),
     CreateMockRead(*fbody),
     CreateMockRead(*fbody2),
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
   scoped_ptr<OrderedSocketData> preconnect_data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   MockConnect never_finishing_connect(ASYNC, ERR_IO_PENDING);
 
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
   data_placeholder->set_connect_data(never_finishing_connect);
@@ skipping 105 matching lines @@
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fbody),
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
     CreateMockRead(*resp3, 12),
     CreateMockRead(*body3),
     CreateMockRead(*fbody3),
 
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
@@ skipping 119 matching lines @@
     CreateMockRead(*fbody),
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
     CreateMockRead(*resp4, 13),
     CreateMockRead(*fbody4),
     CreateMockRead(*resp3, 16),
     CreateMockRead(*body3),
     CreateMockRead(*fbody3),
 
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
@@ skipping 116 matching lines @@
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fbody),
     CreateMockRead(*resp2, 7),
     CreateMockRead(*body2),
     CreateMockRead(*fbody2),
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
@@ skipping 109 matching lines @@
 
   MockWrite writes[] = { CreateMockWrite(*req),
     CreateMockWrite(*req2),
   };
   MockRead reads[] = {
     CreateMockRead(*settings_frame, 1),
     CreateMockRead(*resp),
     CreateMockRead(*body),
     CreateMockRead(*fin_body),
     CreateMockRead(*resp2, 7),
-    MockRead(true, ERR_CONNECTION_RESET, 0),  // Abort!
+    MockRead(ASYNC, ERR_CONNECTION_RESET, 0),  // Abort!
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
         writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data_placeholder(
       new OrderedSocketData(NULL, 0, NULL, 0));
 
   BoundNetLog log;
   TransactionHelperResult out;
@@ skipping 101 matching lines @@
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
 
@@ skipping 50 matching lines @@
   static const char* const kStandardGetHeaders[] = {
     "status", "200",
     "version", "HTTP/1.1"
     "content-length", "1234"
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPacket(kSynReplyHeader,
       NULL, 0, kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, Post) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreatePostRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 11 matching lines @@
     CreateMockWrite(*req),
     CreateMockWrite(*chunk1),
     CreateMockWrite(*chunk2),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*chunk1),
     CreateMockRead(*chunk2),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 17 matching lines @@
   req->set_flags(spdy::CONTROL_FLAG_FIN);
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
@@ skipping 26 matching lines @@
   req->set_flags(spdy::CONTROL_FLAG_FIN);
   MockWrite writes[] = {
     CreateMockWrite(*req),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
@@ skipping 18 matching lines @@
   scoped_ptr<UploadDataStream> stream(
       new UploadDataStream(request.upload_data));
   ASSERT_EQ(OK, stream->Init());
   ASSERT_EQ(request.upload_data->GetContentLengthSync(),
             stream->size());
   scoped_ptr<spdy::SpdyFrame> stream_reply(ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<spdy::SpdyFrame> stream_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream_reply, 2),
     CreateMockRead(*stream_body, 3),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads), NULL, 0));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
 
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
 }
 
 // The client upon cancellation tries to send a RST_STREAM frame. The mock
 // socket causes the TCP write to return zero. This test checks that the client
 // tries to queue up the RST_STREAM frame again.
 TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> rst(
       ConstructSpdyRstStream(1, spdy::CANCEL));
   MockWrite writes[] = {
-    CreateMockWrite(*req.get(), 0, false),
-    MockWrite(false, 0, 0, 2),
-    CreateMockWrite(*rst.get(), 3, false),
+    CreateMockWrite(*req.get(), 0, SYNCHRONOUS),
+    MockWrite(SYNCHRONOUS, 0, 0, 2),
+    CreateMockWrite(*rst.get(), 3, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp.get(), 1, true),
-    MockRead(true, 0, 0, 4)  // EOF
+    CreateMockRead(*resp.get(), 1, ASYNC),
+    MockRead(ASYNC, 0, 0, 4)  // EOF
   };
 
   scoped_refptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
                                   writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(data.get());
@@ skipping 11 matching lines @@
   data->Run();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads), NULL, 0));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
 }
 
 // Test that the transaction doesn't crash when we get two replies on the same
 // stream ID. See http://crbug.com/45639.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 67 matching lines @@
   MockRead reads[] = {
     CreateMockRead(*window_update_dummy),
     CreateMockRead(*window_update_dummy),
     CreateMockRead(*window_update_dummy),
     CreateMockRead(*window_update),     // Four updates, therefore window
     CreateMockRead(*window_update),     // size should increase by
     CreateMockRead(*window_update),     // kDeltaWindowSize * 4
     CreateMockRead(*window_update),
     CreateMockRead(*resp),
     CreateMockRead(*body_end),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(kDefaultURL);
@@ skipping 42 matching lines @@
 
   scoped_ptr<spdy::SpdyFrame> resp(
       ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body_no_fin(
       ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> body_fin(
       ConstructSpdyBodyFrame(1, NULL, 0, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body_no_fin),
-    MockRead(true, ERR_IO_PENDING, 0),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 0),  // Force a pause
     CreateMockRead(*body_fin),
-    MockRead(true, ERR_IO_PENDING, 0),  // Force a pause
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING, 0),  // Force a pause
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunPreTestSetup();
@@ skipping 76 matching lines @@
   scoped_ptr<spdy::SpdyFrame> window_update2(
       ConstructSpdyWindowUpdate(2, kDeltaWindowSize));
   scoped_ptr<spdy::SpdyFrame> reply(ConstructSpdyPostSynReply(NULL, 0));
 
   MockRead reads[] = {
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
-    MockRead(true, ERR_IO_PENDING, 0),  // Wait for the RST to be written.
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING, 0),  // Wait for the RST to be written.
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
@@ skipping 85 matching lines @@
   // data.
   scoped_ptr<spdy::SpdyFrame> window_update(
       ConstructSpdyWindowUpdate(1, kUploadDataSize));
   scoped_ptr<spdy::SpdyFrame> reply(ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*reply),
     CreateMockRead(*body2),
     CreateMockRead(*body3),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(nwrites, reads, arraysize(reads),
                             writes.get(), nwrites));
 
   HttpRequestInfo request;
   request.method = "POST";
@@ skipping 41 matching lines @@
     CreateMockWrite(*req),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
     // This following read isn't used by the test, except during the
     // RunAllPending() call at the end since the SpdySession survives the
     // HttpNetworkTransaction and still tries to continue Read()'ing.  Any
     // MockRead will do here.
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   helper.ResetTrans();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataNotConsumed();
 }
 
 // Verify that the client sends a Rst Frame upon cancelling the stream.
 TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> rst(
       ConstructSpdyRstStream(1, spdy::CANCEL));
   MockWrite writes[] = {
-    CreateMockWrite(*req, 0, false),
-    CreateMockWrite(*rst, 2, false),
+    CreateMockWrite(*req, 0, SYNCHRONOUS),
+    CreateMockWrite(*rst, 2, SYNCHRONOUS),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp, 1, true),
-    MockRead(true, 0, 0, 3)  // EOF
+    CreateMockRead(*resp, 1, ASYNC),
+    MockRead(ASYNC, 0, 0, 3)  // EOF
   };
 
   scoped_refptr<DeterministicSocketData> data(
       new DeterministicSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(),
                                      GetParam());
   helper.SetDeterministic();
@@ skipping 29 matching lines @@
   // session, and calls the read callback with the incomplete data.
   const uint8 kGetBodyFrame2[] = {
     0x00, 0x00, 0x00, 0x01,
     0x01, 0x00, 0x00, 0x07,
     'h', 'e', 'l', 'l', 'o', '!',
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
-    MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
-    MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame2),
+    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
+    MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2),
              arraysize(kGetBodyFrame2), 4),
-    MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
-    MockRead(true, 0, 0, 6),  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
+    MockRead(ASYNC, 0, 0, 6),  // EOF
   };
   MockRead reads2[] = {
     CreateMockRead(*resp, 2),
-    MockRead(true, 0, 0, 3),  // EOF
+    MockRead(ASYNC, 0, 0, 3),  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_ptr<DelayedSocketData> data2(
       new DelayedSocketData(1, reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 26 matching lines @@
 // transaction. Failures will usually be valgrind errors. See
 // http://crbug.com/46925
 TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp.get(), 2),
-    MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
     CreateMockRead(*body.get(), 4),
-    MockRead(true, 0, 0, 5),  // EOF
+    MockRead(ASYNC, 0, 0, 5),  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 64 matching lines @@
       kStandardGetHeaders, arraysize(kStandardGetHeaders) / 2));
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyPacket(
       kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders) / 2,
       kStandardGetHeaders2, arraysize(kStandardGetHeaders2) / 2));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReplyRedirect(1));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
-    MockRead(true, 0, 0, 3)  // EOF
+    MockRead(ASYNC, 0, 0, 3)  // EOF
   };
 
   // Setup writes/reads to www.foo.com
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
-    MockRead(true, 0, 0, 4)  // EOF
+    MockRead(ASYNC, 0, 0, 4)  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data2(
       new OrderedSocketData(reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   HttpStreamFactory::set_force_spdy_over_ssl(false);
@@ skipping 38 matching lines @@
   MockWrite writes[] = {
     CreateMockWrite(*syn, 0),
     CreateMockWrite(*rst, 2),
   };
 
   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
   scoped_ptr<spdy::SpdyFrame>
       reply(ConstructSpdyGetSynReply(kExtraHeaders, 1, 1));
   MockRead reads[] = {
     CreateMockRead(*reply, 1),
-    MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 42 matching lines @@
                                                 spdy::HEADERS,
                                                 spdy::CONTROL_FLAG_NONE,
                                                 NULL,
                                                 0,
                                                 0));
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
@@ skipping 13 matching lines @@
   scoped_ptr<spdy::SpdyFrame>
       reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   const char* const extra_headers[] = {"X-UpperCase", "yes"};
   scoped_ptr<spdy::SpdyFrame>
       push(ConstructSpdyPush(extra_headers, 1, 2, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply, 1),
     CreateMockRead(*push, 1),
     CreateMockRead(*body, 1),
-    MockRead(true, ERR_IO_PENDING, 3),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 46 matching lines @@
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(2, spdy::CANCEL));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
     CreateMockWrite(*rst, 6),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     CreateMockRead(*rep, 3),
     CreateMockRead(*body, 4),
-    MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
-    MockRead(true, 0, 0, 7)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
+    MockRead(ASYNC, 0, 0, 7)  // EOF
   };
 
   // Setup writes/reads to www.foo.com
   const char* const kStandardGetHeaders2[] = {
     "host",
     "www.foo.com",
     "method",
     "GET",
     "scheme",
     "http",
@@ skipping 11 matching lines @@
                           kStandardGetHeaders2,
                           arraysize(kStandardGetHeaders2) / 2));
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
-    MockRead(true, 0, 0, 5)  // EOF
+    MockRead(ASYNC, 0, 0, 5)  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_ptr<OrderedSocketData> data2(
       new OrderedSocketData(reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   HttpStreamFactory::set_force_spdy_over_ssl(false);
@@ skipping 59 matching lines @@
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream1_body, 4, false),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
-    MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 29 matching lines @@
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
   scoped_ptr<spdy::SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
-    CreateMockRead(*stream1_body, 4, false),
-    MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
+    CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 27 matching lines @@
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
   scoped_ptr<spdy::SpdyFrame>
     stream2_rst(ConstructSpdyRstStream(2, spdy::PROTOCOL_ERROR));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream2_rst, 4),
-    CreateMockRead(*stream1_body, 5, false),
-    MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
+    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
+    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 55 matching lines @@
   scoped_ptr<spdy::SpdyFrame>
       stream3_syn(ConstructSpdyPush(NULL,
                                     0,
                                     4,
                                     1,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream3_syn, 4),
-    CreateMockRead(*stream1_body, 6, false),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    CreateMockRead(*stream1_body, 6, SYNCHRONOUS),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 7),
-    MockRead(true, ERR_IO_PENDING, 8),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 33 matching lines @@
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame1),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1),
              arraysize(kPushBodyFrame1), 4),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame2),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2),
              arraysize(kPushBodyFrame2) - 1, 5),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame3),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3),
              arraysize(kPushBodyFrame3) - 1, 6),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4),
              arraysize(kPushBodyFrame4) - 1, 7),
-    CreateMockRead(*stream1_body, 8, false),
-    MockRead(true, ERR_IO_PENDING, 9),  // Force a pause
+    CreateMockRead(*stream1_body, 8, SYNCHRONOUS),
+    MockRead(ASYNC, ERR_IO_PENDING, 9),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 35 matching lines @@
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame1),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1),
              arraysize(kPushBodyFrame1), 4),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame2),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2),
              arraysize(kPushBodyFrame2) - 1, 5),
-    MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame3),
+    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3),
              arraysize(kPushBodyFrame3) - 1, 7),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4),
              arraysize(kPushBodyFrame4) - 1, 8),
-    CreateMockRead(*stream1_body.get(), 9, false),
-    MockRead(true, ERR_IO_PENDING, 10)  // Force a pause.
+    CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS),
+    MockRead(ASYNC, ERR_IO_PENDING, 10)  // Force a pause.
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 30 matching lines @@
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     0,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
-    MockRead(true, ERR_IO_PENDING, 5)  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 41 matching lines @@
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     9,
                                     "http://www.google.com/foo.dat"));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
-    MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 37 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame>
       stream2_syn(ConstructSpdyPush(NULL, 0, 2, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream1_body, 4),
-    MockRead(true, ERR_IO_PENDING, 5)  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 68 matching lines @@
     MockWrite writes[] = { CreateMockWrite(*req) };
 
     scoped_ptr<spdy::SpdyFrame> resp(
         ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                  test_cases[i].num_headers,
                                  1));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 0)  // EOF
     };
 
     scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
 
@@ skipping 118 matching lines @@
       ConstructSpdyPacket(*test_cases[i].syn_reply,
                           test_cases[i].extra_headers[1],
                           test_cases[i].num_headers[1],
                           NULL,
                           0));
 
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*frame_reply),
       CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 0)  // EOF
     };
 
     // Attach the headers to the request.
     int header_count = test_cases[i].num_headers[0];
 
     HttpRequestInfo request = CreateGetRequest();
     for (int ct = 0; ct < header_count; ct++) {
       const char* header_key = test_cases[i].extra_headers[0][ct * 2];
       const char* header_value = test_cases[i].extra_headers[0][ct * 2 + 1];
       request.extra_headers.SetHeader(header_key, header_value);
@@ skipping 95 matching lines @@
 
     scoped_ptr<spdy::SpdyFrame> resp(
         ConstructSpdyPacket(kSynStartHeader,
                             NULL, 0,
                             test_cases[i].headers,
                             test_cases[i].num_headers));
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*resp),
       CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 0)  // EOF
     };
 
     scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_INCOMPLETE_SPDY_HEADERS, out.rv);
@@ skipping 11 matching lines @@
     const spdy::SpdyFrame* syn_reply;
   } test_cases[] = {
     { syn_reply_wrong_length.get(), },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     scoped_ptr<spdy::SpdyFrame> req(
         ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
     MockWrite writes[] = {
       CreateMockWrite(*req),
-      MockWrite(true, 0, 0)  // EOF
+      MockWrite(ASYNC, 0, 0)  // EOF
     };
 
     scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
       CreateMockRead(*test_cases[i].syn_reply),
       CreateMockRead(*body),
-      MockRead(true, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 0)  // EOF
     };
 
     scoped_ptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
     helper.RunToCompletion(data.get());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Test that we shutdown correctly on write errors.
 TEST_P(SpdyNetworkTransactionTest, WriteError) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = {
     // We'll write 10 bytes successfully
-    MockWrite(true, req->data(), 10),
+    MockWrite(ASYNC, req->data(), 10),
     // Followed by ERROR!
-    MockWrite(true, ERR_FAILED),
+    MockWrite(ASYNC, ERR_FAILED),
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, NULL, 0,
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_FAILED, out.rv);
   data->Reset();
 }
 
 // Test that partial writes work.
 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   const int kChunks = 5;
   scoped_array<MockWrite> writes(ChopWriteFrame(*req.get(), kChunks));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(kChunks, reads, arraysize(reads),
                             writes.get(), kChunks));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 41 matching lines @@
   };
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(kExtraHeaders, 1, false, 1,
                                                    LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded);
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequestWithUserAgent(),
                                      log.bound(), GetParam());
   helper.RunToCompletion(data.get());
@@ skipping 81 matching lines @@
   char combined_data_frames[100];
   int combined_data_frames_len =
       CombineFrames(data_frames, arraysize(data_frames),
                     combined_data_frames, arraysize(combined_data_frames));
   scoped_ptr<spdy::SpdyFrame> last_frame(
       framer.CreateDataFrame(1, "d", 1, spdy::DATA_FLAG_FIN));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
-    MockRead(true, ERR_IO_PENDING),  // Force a pause
-    MockRead(true, combined_data_frames, combined_data_frames_len),
-    MockRead(true, ERR_IO_PENDING),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
+    MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
+    MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
     CreateMockRead(*last_frame),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
 
   TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
@@ skipping 74 matching lines @@
     data_frame_fin.get()
   };
   char combined_data_frames[100];
   int combined_data_frames_len =
       CombineFrames(data_frames, arraysize(data_frames),
                     combined_data_frames, arraysize(combined_data_frames));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
-    MockRead(true, ERR_IO_PENDING),  // Force a pause
-    MockRead(true, combined_data_frames, combined_data_frames_len),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
+    MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 76 matching lines @@
     data_frame.get(),
     data_frame.get(),
     data_frame_fin.get()
   };
   char combined_frames[200];
   int combined_frames_len =
       CombineFrames(frames, arraysize(frames),
                     combined_frames, arraysize(combined_frames));
 
   MockRead reads[] = {
-    MockRead(true, combined_frames, combined_frames_len),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, combined_frames, combined_frames_len),
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 66 matching lines @@
     data_frame.get(),
     data_frame.get()
   };
   char combined_data_frames[100];
   int combined_data_frames_len =
       CombineFrames(data_frames, arraysize(data_frames),
                     combined_data_frames, arraysize(combined_data_frames));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
-    MockRead(true, ERR_IO_PENDING),  // Force a wait
-    MockRead(true, combined_data_frames, combined_data_frames_len),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
+    MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 58 matching lines @@
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // NOTE: We don't FIN the stream.
   scoped_ptr<spdy::SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, spdy::DATA_FLAG_NONE));
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
-    MockRead(true, ERR_IO_PENDING),  // Force a wait
+    MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
     CreateMockRead(*data_frame),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 108 matching lines @@
     setting.set_id(kSampleId3);
     settings.push_back(std::make_pair(setting, kSampleValue3));
     settings_frame.reset(ConstructSpdySettings(settings));
   }
 
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     CreateMockRead(*settings_frame),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 97 matching lines @@
     ConstructSpdyPacket(kSynReplyInfo,
                         kExtraHeaders,
                         arraysize(kExtraHeaders) / 2,
                         NULL,
                         0));
 
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 23 matching lines @@
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> go_away(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*go_away),
-    MockRead(true, 0, 0),  // EOF
+    MockRead(ASYNC, 0, 0),  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.AddData(data.get());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_ABORTED, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      log, GetParam());
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 33 matching lines @@
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
 
   MockWrite writes_SPDYNPN[] = {
-    MockWrite(false, kConnect443, arraysize(kConnect443) - 1, 0),
+    MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
     CreateMockWrite(*req, 2),
   };
   MockRead reads_SPDYNPN[] = {
-    MockRead(false, kHTTP200, arraysize(kHTTP200) - 1, 1),
+    MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
     CreateMockRead(*resp, 3),
     CreateMockRead(*body.get(), 4),
-    MockRead(true, 0, 0, 5),
+    MockRead(ASYNC, 0, 0, 5),
   };
 
   MockWrite writes_SPDYSSL[] = {
-    MockWrite(false, kConnect80, arraysize(kConnect80) - 1, 0),
+    MockWrite(SYNCHRONOUS, kConnect80, arraysize(kConnect80) - 1, 0),
     CreateMockWrite(*req, 2),
   };
   MockRead reads_SPDYSSL[] = {
-    MockRead(false, kHTTP200, arraysize(kHTTP200) - 1, 1),
+    MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
     CreateMockRead(*resp, 3),
     CreateMockRead(*body.get(), 4),
-    MockRead(true, 0, 0, 5),
+    MockRead(ASYNC, 0, 0, 5),
   };
 
   MockWrite writes_SPDYNOSSL[] = {
     CreateMockWrite(*req, 0),
   };
 
   MockRead reads_SPDYNOSSL[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*body.get(), 2),
-    MockRead(true, 0, 0, 3),
+    MockRead(ASYNC, 0, 0, 3),
   };
 
   scoped_ptr<OrderedSocketData> data;
   switch(GetParam()) {
     case SPDYNOSSL:
       data.reset(new OrderedSocketData(reads_SPDYNOSSL,
                                        arraysize(reads_SPDYNOSSL),
                                        writes_SPDYNOSSL,
                                        arraysize(writes_SPDYNOSSL)));
       break;
@@ skipping 59 matching lines @@
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     CreateMockRead(*body, 3),
-    MockRead(true, ERR_IO_PENDING, 4),  // Force a pause
-    MockRead(true, 0, 5)  // EOF
+    MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause
+    MockRead(ASYNC, 0, 5)  // EOF
   };
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   helper.AddData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   TransactionHelperResult out;
   out.rv = trans->Start(
@@ skipping 29 matching lines @@
   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyGet(
       "http://www.google.com/foo.dat", false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
 
   MockWrite writes_SPDYNPN[] = {
-    MockWrite(false, kConnect443, arraysize(kConnect443) - 1, 0),
+    MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
     CreateMockWrite(*req2, 2),
   };
   MockRead reads_SPDYNPN[] = {
-    MockRead(false, kHTTP200, arraysize(kHTTP200) - 1, 1),
+    MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
     CreateMockRead(*resp2, 3),
     CreateMockRead(*body2, 4),
-    MockRead(true, 0, 5)  // EOF
+    MockRead(ASYNC, 0, 5)  // EOF
   };
 
   MockWrite writes_SPDYNOSSL[] = {
     CreateMockWrite(*req2, 0),
   };
   MockRead reads_SPDYNOSSL[] = {
     CreateMockRead(*resp2, 1),
     CreateMockRead(*body2, 2),
-    MockRead(true, 0, 3)  // EOF
+    MockRead(ASYNC, 0, 3)  // EOF
   };
 
   MockWrite writes_SPDYSSL[] = {
-    MockWrite(false, kConnect80, arraysize(kConnect80) - 1, 0),
+    MockWrite(SYNCHRONOUS, kConnect80, arraysize(kConnect80) - 1, 0),
     CreateMockWrite(*req2, 2),
   };
   MockRead reads_SPDYSSL[] = {
-    MockRead(false, kHTTP200, arraysize(kHTTP200) - 1, 1),
+    MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
     CreateMockRead(*resp2, 3),
     CreateMockRead(*body2, 4),
-    MockRead(true, 0, 0, 5),
+    MockRead(ASYNC, 0, 0, 5),
   };
 
   scoped_ptr<OrderedSocketData> data_proxy;
   switch(GetParam()) {
     case SPDYNPN:
       data_proxy.reset(new OrderedSocketData(reads_SPDYNPN,
                                              arraysize(reads_SPDYNPN),
                                              writes_SPDYNPN,
                                              arraysize(writes_SPDYNPN)));
       break;
@@ skipping 56 matching lines @@
 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
 // on a new connection, if the connection was previously known to be good.
 // This can happen when a server reboots without saying goodbye, or when
 // we're behind a NAT that masked the RST.
 TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) {
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, ERR_IO_PENDING),
-    MockRead(true, ERR_CONNECTION_RESET),
+    MockRead(ASYNC, ERR_IO_PENDING),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
   };
 
   MockRead reads2[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   // This test has a couple of variants.
   enum {
     // Induce the RST while waiting for our transaction to send.
     VARIANT_RST_DURING_SEND_COMPLETION,
     // Induce the RST while waiting for our transaction to read.
     // In this case, the send completed - everything copied into the SNDBUF.
     VARIANT_RST_DURING_READ_COMPLETION
   };
@@ skipping 58 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) {
   net::HttpStreamFactory::set_spdy_enabled(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> body(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1,
                             spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   net::HttpStreamFactory::set_spdy_enabled(false);
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
-    MockRead(false, OK),
+    MockRead(SYNCHRONOUS, OK),
   };
   scoped_ptr<DelayedSocketData> data2(
       new DelayedSocketData(1, http_reads, arraysize(http_reads),
                             NULL, 0));
   NormalSpdyTransactionHelper helper2(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper2.SetSpdyDisabled();
   helper2.RunToCompletion(data2.get());
   TransactionHelperResult out2 = helper2.output();
   EXPECT_EQ(OK, out2.rv);
@@ skipping 40 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)));
   HttpRequestInfo request(CreateGetRequest());
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(request, net_log, GetParam());
 
   helper.RunPreTestSetup();
@@ skipping 82 matching lines @@
                                                 NULL,
                                                 0,
                                                 0));
 
   scoped_ptr<spdy::SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 2),
     CreateMockRead(*stream2_syn, 3),
     CreateMockRead(*stream2_headers, 4),
-    CreateMockRead(*stream1_body, 5, false),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 6),
-    MockRead(true, ERR_IO_PENDING, 7),  // Force a pause
+    MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 16 matching lines @@
   static const unsigned char kPushBodyFrame[] = {
     0x00, 0x00, 0x00, 0x02,                                      // header, ID
     0x01, 0x00, 0x00, 0x06,                                      // FIN, length
     'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
   };
   scoped_ptr<spdy::SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 0, false),
+    CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   static const char* const kInitialHeaders[] = {
     "url",
     "http://www.google.com/foo.dat",
   };
   static const char* const kLateHeaders[] = {
     "hello",
     "bye",
     "status",
@@ skipping 24 matching lines @@
                                                 0,
                                                 0));
 
   scoped_ptr<spdy::SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers, 4),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 5),
-    MockRead(true, 0, 5),  // EOF
+    MockRead(ASYNC, 0, 5),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_refptr<DeterministicSocketData> data(new DeterministicSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 69 matching lines @@
   static const unsigned char kPushBodyFrame[] = {
     0x00, 0x00, 0x00, 0x02,                                      // header, ID
     0x01, 0x00, 0x00, 0x06,                                      // FIN, length
     'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
   };
   scoped_ptr<spdy::SpdyFrame>
       stream1_syn(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame>
       stream1_body(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 0, false),
+    CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   static const char* const kInitialHeaders[] = {
     "url",
     "http://www.google.com/foo.dat",
   };
   static const char* const kMiddleHeaders[] = {
     "hello",
     "bye",
   };
@@ skipping 38 matching lines @@
                                                  0));
 
   scoped_ptr<spdy::SpdyFrame>
       stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply, 1),
     CreateMockRead(*stream2_syn, 2),
     CreateMockRead(*stream1_body, 3),
     CreateMockRead(*stream2_headers1, 4),
     CreateMockRead(*stream2_headers2, 5),
-    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
              arraysize(kPushBodyFrame), 6),
-    MockRead(true, 0, 6),  // EOF
+    MockRead(ASYNC, 0, 6),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   scoped_refptr<DeterministicSocketData> data(new DeterministicSocketData(
       reads,
       arraysize(reads),
       writes,
       arraysize(writes)));
@@ skipping 106 matching lines @@
                                                 spdy::HEADERS,
                                                 spdy::CONTROL_FLAG_NONE,
                                                 NULL,
                                                 0,
                                                 0));
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 37 matching lines @@
                                                 NULL,
                                                 0,
                                                 0));
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> stream1_body2(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_body),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body2),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
@@ skipping 37 matching lines @@
                                                 NULL,
                                                 0,
                                                 0));
   scoped_ptr<spdy::SpdyFrame> stream1_body(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<spdy::SpdyFrame> stream1_body2(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*stream1_reply),
     CreateMockRead(*stream1_body),
     CreateMockRead(*stream1_headers),
     CreateMockRead(*stream1_body2),
-    MockRead(true, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
@@ skipping 53 matching lines @@
                                       0,
                                       2,
                                       1,
                                       url_to_push));
     scoped_ptr<spdy::SpdyFrame> rst(
         ConstructSpdyRstStream(2, spdy::CANCEL));
 
     MockRead reads[] = {
       CreateMockRead(*stream1_reply, 2),
       CreateMockRead(*stream2_syn, 3),
-      CreateMockRead(*stream1_body, 5, false),
-      MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+      CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
+      MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
                arraysize(kPushBodyFrame), 6),
-      MockRead(true, ERR_IO_PENDING, 7),  // Force a pause
+      MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
     };
 
     HttpResponseInfo response;
     scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
         reads,
         arraysize(reads),
         writes,
         arraysize(writes)));
 
     HttpRequestInfo request;
@@ skipping 44 matching lines @@
   };
 
   scoped_ptr<spdy::SpdyFrame> refused(
       ConstructSpdyRstStream(1, spdy::REFUSED_STREAM));
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(3, true));
   MockRead reads[] = {
     CreateMockRead(*refused, 2),
     CreateMockRead(*resp, 4),
     CreateMockRead(*body, 5),
-    MockRead(true, 0, 6)  // EOF
+    MockRead(ASYNC, 0, 6)  // EOF
   };
 
   scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
 
   helper.RunPreTestSetup();
   helper.AddData(data.get());
@@ skipping 18 matching lines @@
                                     << " Write index: "
                                     << data->write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 }  // namespace net