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

net/http/http_pipelined_connection_impl_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_pipelined_connection_impl.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 161 matching lines @@
 TEST_F(HttpPipelinedConnectionImplTest, StreamBoundButNotUsed) {
   Initialize(NULL, 0, NULL, 0);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, SyncSingleRequest) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 3, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   TestSyncRequest(stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AsyncSingleRequest) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(true, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(true, 3, "ok.html"),
+    MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(ASYNC, 3, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, NULL, &response,
                                                 callback_.callback()));
   data_->RunFor(1);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   ExpectResponse("ok.html", stream, true);
 
   stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(true, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(true, 4, "ok.html"),
-    MockRead(true, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(true, 7, "ko.html"),
+    MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(ASYNC, 4, "ok.html"),
+    MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(ASYNC, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, NULL, &response1,
                                                  callback_.callback()));
@@ skipping 21 matching lines @@
   data_->RunFor(2);
   EXPECT_LE(OK, callback_.WaitForResult());
 
   ExpectResponse("ko.html", stream2, true);
 
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, TwoResponsesInOnePacket) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2,
+    MockRead(SYNCHRONOUS, 2,
              "HTTP/1.1 200 OK\r\n"
              "Content-Length: 7\r\n\r\n"
              "ok.html"
              "HTTP/1.1 200 OK\r\n"
              "Content-Length: 7\r\n\r\n"
              "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
@@ skipping 12 matching lines @@
   ExpectResponse("ok.html", stream1, false);
   stream1->Close(false);
 
   EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ko.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, SendOrderSwapped) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ko.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 4, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 4, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 3, "ko.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 7, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "ko.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   TestSyncRequest(stream2, "ko.html");
   TestSyncRequest(stream1, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, ReadOrderSwapped) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 7, "ko.html"),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
@@ skipping 11 matching lines @@
   stream1->Close(false);
 
   EXPECT_LE(OK, callback_.WaitForResult());
   ExpectResponse("ko.html", stream2, false);
 
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, SendWhileReading) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 7, "ko.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
   EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
 
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
   EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
                                      callback_.callback()));
 
   ExpectResponse("ok.html", stream1, false);
   stream1->Close(false);
 
   EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ko.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(true, 4, "ok.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 7, "ko.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(ASYNC, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ko.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
@@ skipping 23 matching lines @@
   stream1->Close(false);
 
   data_->StopAfter(8);
   EXPECT_LE(OK, callback2.WaitForResult());
   ExpectResponse("ko.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, UnusedStreamAllowsLaterUse) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 3, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> unused_stream(NewTestStream("unused.html"));
   unused_stream->Close(false);
 
   scoped_ptr<HttpStream> later_stream(NewTestStream("ok.html"));
   TestSyncRequest(later_stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, UnsentStreamAllowsLaterUse) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 4, "GET /ko.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 4, "GET /ko.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(true, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
-    MockRead(true, 3, "ok.html"),
-    MockRead(false, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 6, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 7, "ko.html"),
+    MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(ASYNC, 3, "ok.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "ko.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, NULL, &response,
                                                 callback_.callback()));
 
@@ skipping 16 matching lines @@
 
   stream->Close(false);
 
   data_->StopAfter(8);
   scoped_ptr<HttpStream> later_stream(NewTestStream("ko.html"));
   TestSyncRequest(later_stream, "ko.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FailedSend) {
   MockWrite writes[] = {
-    MockWrite(true, ERR_FAILED),
+    MockWrite(ASYNC, ERR_FAILED),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> failed_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> closed_stream(NewTestStream("closed.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
@@ skipping 17 matching lines @@
             rejected_stream->SendRequest(headers, NULL, &response,
                                          callback_.callback()));
 
   failed_stream->Close(true);
   evicted_stream->Close(true);
   rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 2, "GET /read_rejected.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 2, "GET /read_rejected.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   MockRead reads[] = {
-    MockRead(false, 3, "HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> closed_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> read_evicted_stream(
       NewTestStream("read_evicted.html"));
   scoped_ptr<HttpStream> read_rejected_stream(
       NewTestStream("read_rejected.html"));
   scoped_ptr<HttpStream> send_closed_stream(
       NewTestStream("send_closed.html"));
@@ skipping 43 matching lines @@
   send_evicted_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             send_rejected_stream->SendRequest(headers, NULL, &response,
                                               callback_.callback()));
   send_rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   TestCompletionCallback aborted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             aborted_stream->SendRequest(headers, NULL, &response,
                                         aborted_callback.callback()));
   TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->SendRequest(headers, NULL, &response,
                                         evicted_callback.callback()));
 
   aborted_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(aborted_callback.have_result());
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   TestCompletionCallback ok_callback;
@@ skipping 14 matching lines @@
   MessageLoop::current()->RunAllPending();
   aborted_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(aborted_callback.have_result());
   ok_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(true, ERR_FAILED, 2),
+    MockRead(ASYNC, ERR_FAILED, 2),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, aborted_stream->SendRequest(headers, NULL, &response,
@@ skipping 12 matching lines @@
   evicted_stream->Close(true);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             rejected_stream->SendRequest(headers, NULL, &response,
                                          callback_.callback()));
   rejected_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 3, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 4, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 5, "ok.html"),
+    MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 4, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 5, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> abandoned_stream(NewTestStream("abandoned.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
@@ skipping 16 matching lines @@
   ExpectResponse("ok.html", ok_stream, false);
   ok_stream->Close(false);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
   EXPECT_FALSE(evicted_stream->IsConnectionReusable());
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /rejected.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, ERR_SOCKET_NOT_CONNECTED, 5),
-    MockWrite(false, ERR_SOCKET_NOT_CONNECTED, 7),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /rejected.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockWrite(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 7),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 6),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 6),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> rejected_read_stream(NewTestStream("rejected.html"));
   scoped_ptr<HttpStream> evicted_send_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_send_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
@@ skipping 18 matching lines @@
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             rejected_send_stream->SendRequest(headers, NULL, &response,
                                               callback_.callback()));
 
   rejected_read_stream->Close(true);
   rejected_send_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
                                        callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(
       headers, NULL, &response, callback_.callback()));
 
   EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
 
   TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   ok_stream->Close(false);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
                                        callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(
       headers, NULL, &response, callback_.callback()));
 
   EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", ok_stream, false);
 
   TestCompletionCallback evicted_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
 
   ok_stream->Close(false);
   evicted_stream->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeReadCallback) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 5),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
                                        callback_.callback()));
@@ skipping 32 matching lines @@
   void OnIOComplete(int result) {
     delete stream_;
   }
 
   HttpStream* stream_;
   CompletionCallback callback_;
 };
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringSendCallback) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   HttpStream* stream(NewTestStream("ok.html"));
 
   StreamDeleter deleter(stream);
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, NULL, &response,
                                                 deleter.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringReadCallback) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpStream* stream(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
                                     callback_.callback()));
 
   StreamDeleter deleter(stream);
   EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(deleter.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest,
        CloseCalledDuringReadCallbackWithPendingRead) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /failed.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /failed.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpStream* failed_stream(NewTestStream("failed.html"));
   HttpStream* evicted_stream(NewTestStream("evicted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, failed_stream->SendRequest(headers, NULL, &response,
                                            callback_.callback()));
   EXPECT_EQ(OK, evicted_stream->SendRequest(headers, NULL, &response,
                                             callback_.callback()));
 
   StreamDeleter failed_deleter(failed_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             failed_stream->ReadResponseHeaders(failed_deleter.callback()));
   StreamDeleter evicted_deleter(evicted_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             evicted_stream->ReadResponseHeaders(evicted_deleter.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> deleter_stream(NewTestStream("deleter.html"));
   HttpStream* deleted_stream(NewTestStream("deleted.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, deleter_stream->SendRequest(headers, NULL, &response,
                                             callback_.callback()));
   EXPECT_EQ(OK, deleted_stream->SendRequest(headers, NULL, &response,
                                             callback_.callback()));
 
   StreamDeleter deleter(deleted_stream);
   EXPECT_EQ(ERR_IO_PENDING,
             deleter_stream->ReadResponseHeaders(deleter.callback()));
   EXPECT_EQ(ERR_IO_PENDING,
             deleted_stream->ReadResponseHeaders(callback_.callback()));
   data_->RunFor(1);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeSendCallbackRuns) {
   MockWrite writes[] = {
-    MockWrite(true, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
-    MockWrite(true, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
+    MockWrite(ASYNC, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
   scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
 
   scoped_ptr<TestCompletionCallback> close_callback(
       new TestCompletionCallback);
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(ERR_IO_PENDING, close_stream->SendRequest(
       headers, NULL, &response, close_callback->callback()));
 
   data_->RunFor(1);
   EXPECT_FALSE(close_callback->have_result());
 
   close_stream->Close(false);
   close_stream.reset();
   close_callback.reset();
 
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 2, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
   scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, close_stream->SendRequest(headers, NULL, &response,
                                           callback_.callback()));
 
   scoped_ptr<TestCompletionCallback> close_callback(
       new TestCompletionCallback);
   EXPECT_EQ(ERR_IO_PENDING,
             close_stream->ReadResponseHeaders(close_callback->callback()));
 
   data_->RunFor(1);
   EXPECT_FALSE(close_callback->have_result());
 
   close_stream->Close(false);
   close_stream.reset();
   close_callback.reset();
 
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, NoGapBetweenCloseAndEviction) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 2, "GET /dummy.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 2, "GET /dummy.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(true, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
   scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, close_stream->SendRequest(headers, NULL, &response,
                                           callback_.callback()));
@@ skipping 14 matching lines @@
 
   EXPECT_TRUE(dummy_callback.have_result());
   EXPECT_EQ(ERR_PIPELINE_EVICTION, dummy_callback.WaitForResult());
   dummy_stream->Close(true);
   dummy_stream.reset();
   pipeline_.reset();
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, RecoverFromDrainOnRedirect) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2,
+    MockRead(SYNCHRONOUS, 2,
              "HTTP/1.1 302 OK\r\n"
              "Content-Length: 8\r\n\r\n"
              "redirect"),
-    MockRead(false, 3,
+    MockRead(SYNCHRONOUS, 3,
              "HTTP/1.1 200 OK\r\n"
              "Content-Length: 7\r\n\r\n"
              "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
   EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
                                      callback_.callback()));
 
   EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
   EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback()));
   ExpectResponse("ok.html", stream2, false);
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2,
+    MockRead(SYNCHRONOUS, 2,
              "HTTP/1.1 302 OK\r\n\r\n"
              "redirect"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
   EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
                                      callback_.callback()));
 
   EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2,
+    MockRead(SYNCHRONOUS, 2,
              "HTTP/1.1 302 OK\r\n"
              "Content-Length: 8\r\n\r\n"),
-    MockRead(false, ERR_SOCKET_NOT_CONNECTED, 3),
+    MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 3),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
   EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
                                      callback_.callback()));
 
   EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 2,
+    MockRead(SYNCHRONOUS, 2,
              "HTTP/1.1 302 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"),
-    MockRead(false, 3,
+    MockRead(SYNCHRONOUS, 3,
              "jibberish"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html"));
   scoped_ptr<HttpStream> stream2(NewTestStream("ok.html"));
 
   HttpRequestHeaders headers1;
   HttpResponseInfo response1;
   EXPECT_EQ(OK, stream1->SendRequest(headers1, NULL, &response1,
                                      callback_.callback()));
   HttpRequestHeaders headers2;
   HttpResponseInfo response2;
   EXPECT_EQ(OK, stream2->SendRequest(headers2, NULL, &response2,
                                      callback_.callback()));
 
   EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
   stream1.release()->Drain(NULL);
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             stream2->ReadResponseHeaders(callback_.callback()));
   stream2->Close(false);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
-    MockWrite(false, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(true, 3, "HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
-    MockRead(false, OK, 5),
+    MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, OK, 5),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html"));
   scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html"));
   scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html"));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, ok_stream->SendRequest(headers, NULL, &response,
@@ skipping 20 matching lines @@
 
   EXPECT_EQ(ERR_PIPELINE_EVICTION,
             rejected_stream->ReadResponseHeaders(callback_.callback()));
   rejected_stream->Close(true);
   EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
   evicted_stream->Close(true);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnSocketError) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, ERR_FAILED, 1),
+    MockRead(SYNCHRONOUS, ERR_FAILED, 1),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(
                   pipeline_.get(),
                   HttpPipelinedConnection::PIPELINE_SOCKET_ERROR))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
                                     callback_.callback()));
   EXPECT_EQ(ERR_FAILED, stream->ReadResponseHeaders(callback_.callback()));
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoInternetConnection) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, ERR_INTERNET_DISCONNECTED, 1),
+    MockRead(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED, 1),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_, OnPipelineFeedback(_, _))
       .Times(0);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
                                     callback_.callback()));
   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
             stream->ReadResponseHeaders(callback_.callback()));
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnHttp10) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.0 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n"),
-    MockRead(false, 3, "Connection: keep-alive\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Connection: keep-alive\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(pipeline_.get(),
                                  HttpPipelinedConnection::OLD_HTTP_VERSION))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   TestSyncRequest(stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnMustClose) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n"),
-    MockRead(false, 2, "Content-Length: 7\r\n"),
-    MockRead(false, 3, "Connection: close\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Connection: close\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(
                   pipeline_.get(),
                   HttpPipelinedConnection::MUST_CLOSE_CONNECTION))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   TestSyncRequest(stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoContentLength) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead(false, 2, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 2, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(
                   pipeline_.get(),
                   HttpPipelinedConnection::MUST_CLOSE_CONNECTION))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   TestSyncRequest(stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnAuthenticationRequired) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   MockRead reads[] = {
-    MockRead(false, 1, "HTTP/1.1 401 Unauthorized\r\n"),
-    MockRead(false, 2, "WWW-Authenticate: NTLM\r\n"),
-    MockRead(false, 3, "Content-Length: 7\r\n\r\n"),
-    MockRead(false, 4, "ok.html"),
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Unauthorized\r\n"),
+    MockRead(SYNCHRONOUS, 2, "WWW-Authenticate: NTLM\r\n"),
+    MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 4, "ok.html"),
   };
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   EXPECT_CALL(delegate_,
               OnPipelineFeedback(
                   pipeline_.get(),
                   HttpPipelinedConnection::AUTHENTICATION_REQUIRED))
       .Times(1);
 
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
   TestSyncRequest(stream, "ok.html");
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacity) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   EXPECT_EQ(OK, stream->SendRequest(headers, NULL, &response,
                                     callback_.callback()));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   MessageLoop::current()->RunAllPending();
 
   stream->Close(false);
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   stream.reset(NULL);
 }
 
 TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacityWithoutSend) {
   MockWrite writes[] = {
-    MockWrite(false, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
   };
   Initialize(NULL, 0, writes, arraysize(writes));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
   scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
 
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   MessageLoop::current()->RunAllPending();
 
   stream->Close(false);
   EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
   stream.reset(NULL);
 }
 
 }  // anonymous namespace
 
 }  // namespace net