Convert the remaining three SpdyNetworkTransactionTests to SequencedSocketData

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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 250 matching lines @@
     void FinishDefaultTestWithoutVerification() {
       output_.rv = callback_.WaitForResult();
       if (output_.rv != OK)
         session_->spdy_session_pool()->CloseCurrentSessions(ERR_ABORTED);
     }
 
     // Most tests will want to call this function. In particular, the MockReads
     // should end with an empty read, and that read needs to be processed to
     // ensure proper deletion of the spdy_session_pool.
     void VerifyDataConsumed() {
-      for (DataVector::iterator it = data_vector_.begin();
-          it != data_vector_.end(); ++it) {
-        EXPECT_TRUE((*it)->at_read_eof()) << "Read count: "
-                                          << (*it)->read_count()
-                                          << " Read index: "
-                                          << (*it)->read_index();
-        EXPECT_TRUE((*it)->at_write_eof()) << "Write count: "
-                                           << (*it)->write_count()
-                                           << " Write index: "
-                                           << (*it)->write_index();
+      for (const SocketDataProvider* provider : data_vector_) {
+        EXPECT_TRUE(provider->AllReadDataConsumed());
+        EXPECT_TRUE(provider->AllWriteDataConsumed());
       }
     }
 
     // Occasionally a test will expect to error out before certain reads are
     // processed. In that case we want to explicitly ensure that the reads were
     // not processed.
     void VerifyDataNotConsumed() {
-      for (DataVector::iterator it = data_vector_.begin();
-          it != data_vector_.end(); ++it) {
-        EXPECT_TRUE(!(*it)->at_read_eof()) << "Read count: "
-                                           << (*it)->read_count()
-                                           << " Read index: "
-                                           << (*it)->read_index();
-        EXPECT_TRUE(!(*it)->at_write_eof()) << "Write count: "
-                                            << (*it)->write_count()
-                                            << " Write index: "
-                                            << (*it)->write_index();
+      for (const SocketDataProvider* provider : data_vector_) {
+        EXPECT_FALSE(provider->AllReadDataConsumed());
+        EXPECT_FALSE(provider->AllWriteDataConsumed());
       }
     }
 
-    void RunToCompletion(StaticSocketDataProvider* data) {
+    void RunToCompletion(SocketDataProvider* data) {
       RunPreTestSetup();
       AddData(data);
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void RunToCompletionWithSSLData(
-        StaticSocketDataProvider* data,
+        SocketDataProvider* data,
         scoped_ptr<SSLSocketDataProvider> ssl_provider) {
       RunPreTestSetup();
       AddDataWithSSLSocketDataProvider(data, ssl_provider.Pass());
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
-    void AddData(StaticSocketDataProvider* data) {
+    void AddData(SocketDataProvider* data) {
       scoped_ptr<SSLSocketDataProvider> ssl_provider(
           new SSLSocketDataProvider(ASYNC, OK));
       ssl_provider->cert =
           ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
       AddDataWithSSLSocketDataProvider(data, ssl_provider.Pass());
     }
 
     void AddDataWithSSLSocketDataProvider(
-        StaticSocketDataProvider* data,
+        SocketDataProvider* data,
         scoped_ptr<SSLSocketDataProvider> ssl_provider) {
       DCHECK(!deterministic_);
       data_vector_.push_back(data);
       if (ssl_provider->next_proto_status ==
           SSLClientSocket::kNextProtoUnsupported) {
         ssl_provider->SetNextProto(test_params_.protocol);
       }
 
       session_deps_->socket_factory->AddSSLSocketDataProvider(
           ssl_provider.get());
@@ skipping 47 matching lines @@
     }
     scoped_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
     int port() const { return port_; }
     SpdyNetworkTransactionTestParams test_params() const {
       return test_params_;
     }
 
    private:
-    typedef std::vector<StaticSocketDataProvider*> DataVector;
+    typedef std::vector<SocketDataProvider*> DataVector;
     typedef ScopedVector<SSLSocketDataProvider> SSLVector;
-    typedef ScopedVector<StaticSocketDataProvider> AlternateVector;
+    typedef ScopedVector<SocketDataProvider> AlternateVector;
     typedef ScopedVector<DeterministicSocketData> AlternateDeterministicVector;
     HttpRequestInfo request_;
     RequestPriority priority_;
     scoped_ptr<SpdySessionDependencies> session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
-    scoped_ptr<StaticSocketDataProvider> first_transaction_;
+    scoped_ptr<SocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback_;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
     AlternateVector alternate_vector_;
     AlternateDeterministicVector alternate_deterministic_vector_;
     const BoundNetLog log_;
     SpdyNetworkTransactionTestParams test_params_;
     int port_;
@@ skipping 146 matching lines @@
       chunked_post_request_initialized_ = true;
     }
     return chunked_post_request_;
   }
 
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
   int ReadResult(HttpNetworkTransaction* trans,
-                 StaticSocketDataProvider* data,
+                 SocketDataProvider* data,
                  std::string* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
     scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
       int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
-        // Multiple transactions may be in the data set.  Keep pulling off
-        // reads until we complete our callback.
-        while (!callback.have_result()) {
-          data->CompleteRead();
-          base::RunLoop().RunUntilIdle();
-        }
         rv = callback.WaitForResult();
       } else if (rv <= 0) {
         break;
       }
       result->append(buf->data(), rv);
       bytes_read += rv;
     }
     return bytes_read;
   }
 
   void VerifyStreamsClosed(const NormalSpdyTransactionHelper& helper) {
     // This lengthy block is reaching into the pool to dig out the active
     // session.  Once we have the session, we verify that the streams are
     // all closed and not leaked at this point.
     const GURL& url = helper.request().url;
     HostPortPair host_port_pair(url.host(), 443);
     SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                        PRIVACY_MODE_DISABLED);
     BoundNetLog log;
     const scoped_refptr<HttpNetworkSession>& session = helper.session();
     base::WeakPtr<SpdySession> spdy_session =
         session->spdy_session_pool()->FindAvailableSession(key, log);
     ASSERT_TRUE(spdy_session != NULL);
     EXPECT_EQ(0u, spdy_session->num_active_streams());
     EXPECT_EQ(0u, spdy_session->num_unclaimed_pushed_streams());
   }
 
-  void RunServerPushTest(OrderedSocketData* data,
+  void RunServerPushTest(SequencedSocketData* data,
                          HttpResponseInfo* response,
                          HttpResponseInfo* push_response,
                          const std::string& expected) {
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunPreTestSetup();
     helper.AddData(data);
 
     HttpNetworkTransaction* trans = helper.trans();
 
@@ skipping 120 matching lines @@
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 }
 
 TEST_P(SpdyNetworkTransactionTest, Get) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
        p = RequestPriority(p + 1)) {
     // Construct the request.
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, p, true));
-    MockWrite writes[] = { CreateMockWrite(*req) };
+    MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     SpdyPriority spdy_prio = 0;
     EXPECT_TRUE(GetSpdyPriority(spdy_util_.spdy_version(), *req, &spdy_prio));
     // this repeats the RequestPriority-->SpdyPriority mapping from
     // SpdyFramer::ConvertRequestPriorityToSpdyPriority to make
     // sure it's being done right.
     if (spdy_util_.spdy_version() < SPDY3) {
       switch (p) {
         case HIGHEST:
           EXPECT_EQ(0, spdy_prio);
@@ skipping 29 matching lines @@
           EXPECT_EQ(4, spdy_prio);
           break;
         default:
           FAIL();
       }
     }
 
     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
-      CreateMockRead(*resp),
-      CreateMockRead(*body),
-      MockRead(ASYNC, 0, 0)  // EOF
+        CreateMockRead(*resp, 1),
+        CreateMockRead(*body, 2),
+        MockRead(ASYNC, 0, 3)  // EOF
     };
 
-    DelayedSocketData data(1, reads, arraysize(reads),
-                              writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     HttpRequestInfo http_req = CreateGetRequest();
 
     NormalSpdyTransactionHelper helper(http_req, p, BoundNetLog(),
                                        GetParam(), NULL);
     helper.RunToCompletion(&data);
     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);
   }
@@ skipping 22 matching lines @@
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 
   scoped_ptr<SpdyFrame> req3(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, false));
   scoped_ptr<SpdyFrame> fbody3(spdy_util_.ConstructSpdyBodyFrame(5, true));
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*req2),
-    CreateMockWrite(*req3),
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*req2, 3),
+      CreateMockWrite(*req3, 6),
   };
   MockRead reads[] = {
-    CreateMockRead(*resp, 1),
-    CreateMockRead(*body),
-    CreateMockRead(*resp2, 4),
-    CreateMockRead(*body2),
-    CreateMockRead(*resp3, 7),
-    CreateMockRead(*body3),
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      CreateMockRead(*resp2, 4),
+      CreateMockRead(*body2, 5),
+      CreateMockRead(*resp3, 7),
+      CreateMockRead(*body3, 8),
 
-    CreateMockRead(*fbody),
-    CreateMockRead(*fbody2),
-    CreateMockRead(*fbody3),
+      CreateMockRead(*fbody, 9),
+      CreateMockRead(*fbody2, 10),
+      CreateMockRead(*fbody3, 11),
 
-    MockRead(ASYNC, 0, 0),  // EOF
+      MockRead(ASYNC, 0, 12),  // EOF
   };
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-  OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data_placeholder(NULL, 0, NULL, 0);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   // We require placeholder data because three get requests are sent out at
   // the same time which results in three sockets being connected. The first
   // on will negotiate SPDY and will be used for all requests.
@@ skipping 50 matching lines @@
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*req2),
+      CreateMockWrite(*req, 0), CreateMockWrite(*req2, 3),
   };
   MockRead reads[] = {
-    CreateMockRead(*resp, 1),
-    CreateMockRead(*body),
-    CreateMockRead(*resp2, 4),
-    CreateMockRead(*body2),
-    CreateMockRead(*fbody),
-    CreateMockRead(*fbody2),
-    MockRead(ASYNC, 0, 0),  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      CreateMockRead(*resp2, 4),
+      CreateMockRead(*body2, 5),
+      CreateMockRead(*fbody, 6),
+      CreateMockRead(*fbody2, 7),
+      MockRead(ASYNC, 0, 8),  // EOF
   };
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
-  OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
+  SequencedSocketData data_placeholder(NULL, 0, NULL, 0);
   data_placeholder.set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   // We require placeholder data because two requests are sent out at
   // the same time which results in two sockets being connected. The first
@@ skipping 50 matching lines @@
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*req2),
+      CreateMockWrite(*req, 0), CreateMockWrite(*req2, 3),
   };
   MockRead reads[] = {
-    CreateMockRead(*resp, 1),
-    CreateMockRead(*body),
-    CreateMockRead(*resp2, 4),
-    CreateMockRead(*body2),
-    CreateMockRead(*fbody),
-    CreateMockRead(*fbody2),
-    MockRead(ASYNC, 0, 0),  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      CreateMockRead(*resp2, 4),
+      CreateMockRead(*body2, 5),
+      CreateMockRead(*fbody, 6),
+      CreateMockRead(*fbody2, 7),
+      MockRead(ASYNC, 0, 8),  // EOF
   };
-  OrderedSocketData preconnect_data(reads, arraysize(reads),
-                                    writes, arraysize(writes));
+  SequencedSocketData preconnect_data(reads, arraysize(reads), writes,
+                                      arraysize(writes));
 
   MockConnect never_finishing_connect(ASYNC, ERR_IO_PENDING);
 
-  OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
+  SequencedSocketData data_placeholder(NULL, 0, NULL, 0);
   data_placeholder.set_connect_data(never_finishing_connect);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&preconnect_data);
   // We require placeholder data because 3 connections are attempted (first is
   // the preconnect, 2nd and 3rd are the never finished connections.
@@ skipping 81 matching lines @@
 
   SettingsMap settings;
   const uint32 max_concurrent_streams = 1;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*settings_ack, 2),
-    CreateMockWrite(*req2),
-    CreateMockWrite(*req3),
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*settings_ack, 5),
+      CreateMockWrite(*req2, 6),
+      CreateMockWrite(*req3, 10),
   };
 
   MockRead reads[] = {
-    CreateMockRead(*settings_frame, 1),
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    CreateMockRead(*fbody),
-    CreateMockRead(*resp2, 8),
-    CreateMockRead(*body2),
-    CreateMockRead(*fbody2),
-    CreateMockRead(*resp3, 13),
-    CreateMockRead(*body3),
-    CreateMockRead(*fbody3),
+      CreateMockRead(*settings_frame, 1),
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      CreateMockRead(*fbody, 4),
+      CreateMockRead(*resp2, 7),
+      CreateMockRead(*body2, 8),
+      CreateMockRead(*fbody2, 9),
+      CreateMockRead(*resp3, 11),
+      CreateMockRead(*body3, 12),
+      CreateMockRead(*fbody3, 13),
 
-    MockRead(ASYNC, 0, 0),  // EOF
+      MockRead(ASYNC, 0, 14),  // EOF
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunPreTestSetup();
     helper.AddData(&data);
     scoped_ptr<HttpNetworkTransaction> trans1(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
@@ skipping 16 matching lines @@
     // frame.
     out.rv = callback1.WaitForResult();
     ASSERT_EQ(OK, out.rv);
 
     out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
     ASSERT_EQ(out.rv, ERR_IO_PENDING);
     out.rv = callback2.WaitForResult();
     ASSERT_EQ(OK, out.rv);
-    EXPECT_EQ(7U, data.read_index());  // i.e. the third trans was queued
 
     out.rv = callback3.WaitForResult();
     ASSERT_EQ(OK, out.rv);
 
     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
     ASSERT_TRUE(response1 != NULL);
     EXPECT_TRUE(response1->headers.get() != NULL);
     EXPECT_TRUE(response1->was_fetched_via_spdy);
     out.status_line = response1->headers->GetStatusLine();
     out.response_info = *response1;
@@ skipping 53 matching lines @@
   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(7, false));
   scoped_ptr<SpdyFrame> fbody3(spdy_util_.ConstructSpdyBodyFrame(7, true));
 
   SettingsMap settings;
   const uint32 max_concurrent_streams = 1;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
-
-  MockWrite writes[] = { CreateMockWrite(*req),
-    CreateMockWrite(*settings_ack, 2),
-    CreateMockWrite(*req2),
-    CreateMockWrite(*req4),
-    CreateMockWrite(*req3),
+  MockWrite writes[] = {
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*settings_ack, 5),
+      // By making these synchronous, it guarantees that they are not *started*
+      // before their sequence number, which in turn verifies that only a single
+      // request is in-flight at a time.
+      CreateMockWrite(*req2, 6, SYNCHRONOUS),
+      CreateMockWrite(*req4, 10, SYNCHRONOUS),
+      CreateMockWrite(*req3, 13, SYNCHRONOUS),
   };
   MockRead reads[] = {
-    CreateMockRead(*settings_frame, 1),
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    CreateMockRead(*fbody),
-    CreateMockRead(*resp2, 8),
-    CreateMockRead(*body2),
-    CreateMockRead(*fbody2),
-    CreateMockRead(*resp4, 14),
-    CreateMockRead(*fbody4),
-    CreateMockRead(*resp3, 17),
-    CreateMockRead(*body3),
-    CreateMockRead(*fbody3),
+      CreateMockRead(*settings_frame, 1),
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      CreateMockRead(*fbody, 4),
+      CreateMockRead(*resp2, 7),
+      CreateMockRead(*body2, 8),
+      CreateMockRead(*fbody2, 9),
+      CreateMockRead(*resp4, 11),
+      CreateMockRead(*fbody4, 12),
+      CreateMockRead(*resp3, 14),
+      CreateMockRead(*body3, 15),
+      CreateMockRead(*fbody3, 16),
 
-    MockRead(ASYNC, 0, 0),  // EOF
+      MockRead(ASYNC, 0, 17),  // EOF
   };
-
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
+
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans3(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans4(
       new HttpNetworkTransaction(HIGHEST, helper.session().get()));
 
   TestCompletionCallback callback1;
@@ skipping 14 matching lines @@
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
   out.rv = trans4->Start(&httpreq4, callback4.callback(), log);
   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
-  EXPECT_EQ(data.read_index(), 7U);  // i.e. the third & fourth trans queued
 
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
@@ skipping 26 matching lines @@
   out.response_info = *response4;
   out.rv = ReadTransaction(trans4.get(), &out.response_data);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
   helper.VerifyDataConsumed();
   EXPECT_EQ(OK, out.rv);
 }
 
 // Similar to ThreeGetsMaxConcurrrent above, however, this test
-// deletes a session in the middle of the transaction to insure
+// deletes a session in the middle of the transaction to ensure
 // that we properly remove pendingcreatestream objects from
 // the spdy_session
 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentDelete) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 
   SettingsMap settings;
   const uint32 max_concurrent_streams = 1;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*settings_ack, 2),
-    CreateMockWrite(*req2),
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*settings_ack, 5),
+      CreateMockWrite(*req2, 6),
   };
   MockRead reads[] = {
-    CreateMockRead(*settings_frame, 1),
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    CreateMockRead(*fbody),
-    CreateMockRead(*resp2, 8),
-    CreateMockRead(*body2),
-    CreateMockRead(*fbody2),
-    MockRead(ASYNC, 0, 0),  // EOF
+      CreateMockRead(*settings_frame, 1),
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      CreateMockRead(*fbody, 4),
+      CreateMockRead(*resp2, 7),
+      CreateMockRead(*body2, 8),
+      CreateMockRead(*fbody2, 9),
+      MockRead(ASYNC, 0, 10),  // EOF
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   scoped_ptr<HttpNetworkTransaction> trans1(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   scoped_ptr<HttpNetworkTransaction> trans2(
@@ skipping 16 matching lines @@
   ASSERT_EQ(OK, out.rv);
 
   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   delete trans3.release();
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback2.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
-  EXPECT_EQ(8U, data.read_index());
-
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
   EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(trans1.get(), &out.response_data);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!hello!", out.response_data);
@@ skipping 57 matching lines @@
 
   SettingsMap settings;
   const uint32 max_concurrent_streams = 1;
   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*settings_ack, 2),
-    CreateMockWrite(*req2),
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*settings_ack, 5),
+      CreateMockWrite(*req2, 6),
   };
   MockRead reads[] = {
-    CreateMockRead(*settings_frame, 1),
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    CreateMockRead(*fin_body),
-    CreateMockRead(*resp2, 8),
-    MockRead(ASYNC, ERR_CONNECTION_RESET, 0),  // Abort!
+      CreateMockRead(*settings_frame, 1),
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      CreateMockRead(*fin_body, 4),
+      CreateMockRead(*resp2, 7),
+      MockRead(ASYNC, ERR_CONNECTION_RESET, 8),  // Abort!
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-  OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data_placeholder(NULL, 0, NULL, 0);
 
   BoundNetLog log;
   TransactionHelperResult out;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   // We require placeholder data because three get requests are sent out, so
   // there needs to be three sets of SSL connection data.
   helper.AddData(&data_placeholder);
@@ skipping 17 matching lines @@
   out.rv = callback1.WaitForResult();
   ASSERT_EQ(OK, out.rv);
 
   out.rv = trans2.Start(&httpreq2, callback2.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
   ASSERT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback3.WaitForResult();
   ASSERT_EQ(ERR_ABORTED, out.rv);
 
-  EXPECT_EQ(6U, data.read_index());
-
   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
   ASSERT_TRUE(response1 != NULL);
   EXPECT_TRUE(response1->headers.get() != NULL);
   EXPECT_TRUE(response1->was_fetched_via_spdy);
   out.status_line = response1->headers->GetStatusLine();
   out.response_info = *response1;
   out.rv = ReadTransaction(&trans1, &out.response_data);
   EXPECT_EQ(OK, out.rv);
 
   const HttpResponseInfo* response2 = trans2.GetResponseInfo();
@@ skipping 11 matching lines @@
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL(GetDefaultUrl());
 
   scoped_ptr<SpdyHeaderBlock> put_headers(
       spdy_util_.ConstructPutHeaderBlock(GetDefaultUrl(), 0));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdySyn(1, *put_headers, LOWEST, false, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
+      CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 }
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionTest, Head) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL(GetDefaultUrl());
 
   scoped_ptr<SpdyHeaderBlock> head_headers(
       spdy_util_.ConstructHeadHeaderBlock(GetDefaultUrl(), 0));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdySyn(1, *head_headers, LOWEST, false, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
+      CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
       GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*body),  // POST upload frame
+      CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(2, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreatePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
 // Test that a POST with a file works.
 TEST_P(SpdyNetworkTransactionTest, FilePost) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
       GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*body),  // POST upload frame
+      CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(2, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateFilePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
 // Test that a POST with a unreadable file fails.
 TEST_P(SpdyNetworkTransactionTest, UnreadableFilePost) {
   MockWrite writes[] = {
-    MockWrite(ASYNC, 0, 0)  // EOF
+      MockWrite(ASYNC, 0, 0)  // EOF
   };
   MockRead reads[] = {
-    MockRead(ASYNC, 0, 0)  // EOF
+      MockRead(ASYNC, 0, 1)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateUnreadableFilePostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   helper.RunDefaultTest();
 
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataNotConsumed();
   EXPECT_EQ(ERR_ACCESS_DENIED, helper.output().rv);
 }
 
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
       GetDefaultUrl(), 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*body),  // POST upload frame
+      CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),  // POST upload frame
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(2, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateComplexPostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
 // Test that a chunked POST works.
 TEST_P(SpdyNetworkTransactionTest, ChunkedPost) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*body),
+      CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(2, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   // These chunks get merged into a single frame when being sent.
   const int kFirstChunkSize = kUploadDataSize/2;
   upload_chunked_data_stream()->AppendData(kUploadData, kFirstChunkSize, false);
   upload_chunked_data_stream()->AppendData(
       kUploadData + kFirstChunkSize, kUploadDataSize - kFirstChunkSize, true);
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ(kUploadData, out.response_data);
 }
 
 // Test that a chunked POST works with chunks appended after transaction starts.
 TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk3(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*chunk1),
-    CreateMockWrite(*chunk2),
-    CreateMockWrite(*chunk3),
+      CreateMockWrite(*req, 0),
+      CreateMockWrite(*chunk1, 1),
+      CreateMockWrite(*chunk2, 2),
+      CreateMockWrite(*chunk3, 3),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*chunk1),
-    CreateMockRead(*chunk2),
-    CreateMockRead(*chunk3),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 4),
+      CreateMockRead(*chunk1, 5),
+      CreateMockRead(*chunk2, 6),
+      CreateMockRead(*chunk3, 7),
+      MockRead(ASYNC, 0, 8)  // EOF
   };
 
-  DelayedSocketData data(4, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
   ASSERT_TRUE(helper.StartDefaultTest());
 
@@ skipping 27 matching lines @@
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
   scoped_ptr<SpdyHeaderBlock> req_block(
       spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), 0));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, false, true));
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
+      CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
@@ skipping 11 matching lines @@
   request.upload_data_stream = &stream;
 
   const uint64 kContentLength = 0;
 
   scoped_ptr<SpdyHeaderBlock> req_block(
       spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), kContentLength));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, false, true));
 
   MockWrite writes[] = {
-    CreateMockWrite(*req),
+      CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
@@ skipping 82 matching lines @@
   data.SetStop(20);
   data.Run();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*body, 1), MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads), NULL, 0);
+  scoped_ptr<SpdyFrame> req(
+      spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+  scoped_ptr<SpdyFrame> rst(
+      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
+  MockWrite writes[] = {
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
+  };
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, 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<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*rst),
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*resp, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 12 matching lines @@
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*rst),
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
   };
 
   const char* const headers[] = {
     "transfer-encoding", "chunked"
   };
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(headers, 1, 1));
   scoped_ptr<SpdyFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*rst),
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   const char* const headers[] = {
     "transfer-encoding", "chunked"
   };
   scoped_ptr<SpdyFrame> push(
       spdy_util_.ConstructSpdyPush(headers, arraysize(headers) / 2, 2, 1,
                                    GetDefaultUrlWithPath("/1").c_str()));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*push),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*push, 2),
+      CreateMockRead(*body, 3),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
@@ skipping 80 matching lines @@
 
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback attempting
 // to start another transaction on a session that is closing down. See
 // http://crbug.com/47455
 TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
-  MockWrite writes2[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req)};
+  MockWrite writes2[] = {CreateMockWrite(*req, 0)};
 
   // The indicated length of this frame is longer than its actual length. When
   // the session receives an empty frame after this one, it shuts down the
   // 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<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
-    MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2),
-             arraysize(kGetBodyFrame2), 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
-    MockRead(ASYNC, 0, 0, 6),  // EOF
+      CreateMockRead(*resp, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause
+      MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2),
+               arraysize(kGetBodyFrame2), 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause
+      MockRead(ASYNC, 0, 0, 5),            // EOF
   };
   MockRead reads2[] = {
-    CreateMockRead(*resp, 2),
-    MockRead(ASYNC, 0, 0, 3),  // EOF
+      CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 0, 2),  // EOF
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-  DelayedSocketData data2(1, reads2, arraysize(reads2),
-                          writes2, arraysize(writes2));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data2(reads2, arraysize(reads2), writes2,
+                            arraysize(writes2));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   helper.AddData(&data2);
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   const int kSize = 3000;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(), kSize,
       base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
                  helper.session(), GURL(GetDefaultUrl())));
+  ASSERT_EQ(ERR_IO_PENDING, rv);
   // This forces an err_IO_pending, which sets the callback.
   data.CompleteRead();
   // This finishes the read.
   data.CompleteRead();
   helper.VerifyDataConsumed();
 }
 
 // Verify that the client can correctly deal with the user callback deleting the
 // transaction. Failures will usually be valgrind errors. See
 // http://crbug.com/46925
 TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp.get(), 2),
-    MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
-    CreateMockRead(*body.get(), 4),
-    MockRead(ASYNC, 0, 0, 5),  // EOF
+      CreateMockRead(*resp.get(), 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause
+      CreateMockRead(*body.get(), 3),
+      MockRead(ASYNC, 0, 0, 4),  // EOF
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
@@ skipping 46 matching lines @@
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 4)  // EOF
   };
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-  OrderedSocketData data2(reads2, arraysize(reads2),
-                          writes2, arraysize(writes2));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data2(reads2, arraysize(reads2), writes2,
+                            arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   {
     SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
     scoped_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         GURL(GetDefaultUrl()), DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
     spdy_url_request_context.socket_factory().
@@ skipping 59 matching lines @@
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 5)  // EOF
   };
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
-  OrderedSocketData data2(reads2, arraysize(reads2),
-                          writes2, arraysize(writes2));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data2(reads2, arraysize(reads2), writes2,
+                            arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   TestDelegate d2;
   SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
   {
     scoped_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         GURL(GetDefaultUrl()), DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
         AddSocketDataProvider(&data);
@@ skipping 16 matching lines @@
     EXPECT_EQ(1, d2.received_redirect_count());
 
     r2->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.response_started_count());
     EXPECT_FALSE(d2.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r2->status().status());
     std::string contents2("hello!");
     EXPECT_EQ(contents2, d2.data_received());
   }
-  data.CompleteRead();
-  data2.CompleteRead();
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data2.at_read_eof());
-  EXPECT_TRUE(data2.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data2.AllReadDataConsumed());
+  EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   scoped_ptr<SpdyFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
-    CreateMockRead(*stream2_body, 5),
-    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream1_body, 3, SYNCHRONOUS),
+      CreateMockRead(*stream2_body, 4),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   scoped_ptr<SpdyFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
-    CreateMockRead(*stream2_syn, 2),
-    CreateMockRead(*stream1_reply, 3),
-    CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
-    CreateMockRead(*stream2_body, 5),
-    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
+      CreateMockRead(*stream2_syn, 1),
+      CreateMockRead(*stream1_reply, 2),
+      CreateMockRead(*stream1_body, 3, SYNCHRONOUS),
+      CreateMockRead(*stream2_body, 4),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*stream1_syn, 1), };
+  MockWrite writes[] = {
+      CreateMockWrite(*stream1_syn, 0),
+  };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   scoped_ptr<SpdyFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   scoped_ptr<SpdyFrame>
       stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream2_body, 4),
-    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream2_body, 3),
+      CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream2_rst, 4),
-    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream2_rst, 3),
+      CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 // Verify that we don't leak streams and that we properly send a reset
 // if the server pushes the same stream twice.
 TEST_P(SpdyNetworkTransactionTest, ServerPushDuplicate) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream3_rst(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
-    CreateMockWrite(*stream3_rst, 5),
+      CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream3_rst, 4),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   scoped_ptr<SpdyFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   scoped_ptr<SpdyFrame> stream3_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 4, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream3_syn, 4),
-    CreateMockRead(*stream1_body, 6, SYNCHRONOUS),
-    CreateMockRead(*stream2_body, 7),
-    MockRead(ASYNC, ERR_IO_PENDING, 8),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream3_syn, 3),
+      CreateMockRead(*stream1_body, 5),
+      CreateMockRead(*stream2_body, 6),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   static const char kPushedData[] = "pushed my darling hello my baby";
   scoped_ptr<SpdyFrame> stream2_body_base(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   const size_t kChunkSize = strlen(kPushedData) / 4;
   scoped_ptr<SpdyFrame> stream2_body1(
       new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body2(
       new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body3(
       new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
                     kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body4(
       new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
                     stream2_body_base->size() - 3 * kChunkSize, false));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream2_body1, 4),
-    CreateMockRead(*stream2_body2, 5),
-    CreateMockRead(*stream2_body3, 6),
-    CreateMockRead(*stream2_body4, 7),
-    CreateMockRead(*stream1_body, 8, SYNCHRONOUS),
-    MockRead(ASYNC, ERR_IO_PENDING, 9),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream2_body1, 3),
+      CreateMockRead(*stream2_body2, 4),
+      CreateMockRead(*stream2_body3, 5),
+      CreateMockRead(*stream2_body4, 6),
+      CreateMockRead(*stream1_body, 7, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   static const char kPushedData[] = "pushed my darling hello my baby";
   scoped_ptr<SpdyFrame> stream2_body_base(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   const size_t kChunkSize = strlen(kPushedData) / 4;
   scoped_ptr<SpdyFrame> stream2_body1(
       new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body2(
       new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body3(
       new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
                     kChunkSize, false));
   scoped_ptr<SpdyFrame> stream2_body4(
       new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
                     stream2_body_base->size() - 3 * kChunkSize, false));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream2_body1, 4),
-    CreateMockRead(*stream2_body2, 5),
-    MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
-    CreateMockRead(*stream2_body3, 7),
-    CreateMockRead(*stream2_body4, 8),
-    CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS),
-    MockRead(ASYNC, ERR_IO_PENDING, 10)  // Force a pause.
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream2_body1, 3),
+      CreateMockRead(*stream2_body2, 4),
+      CreateMockRead(*stream2_body3, 5),
+      CreateMockRead(*stream2_body4, 6),
+      CreateMockRead(*stream1_body.get(), 7, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8)  // Force a pause.
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
   if (spdy_util_.spdy_version() == SPDY4) {
     // PUSH_PROMISE with stream id 0 is connection-level error.
     // TODO(baranovich): Test session going away.
     return;
   }
 
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
-    CreateMockWrite(*stream2_rst, 4),
+      CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 0, GetDefaultUrlWithPath("/foo.dat").c_str()));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream1_body, 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream1_body, 4),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5)  // Force a pause
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_INVALID_STREAM));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
-    CreateMockWrite(*stream2_rst, 4),
+      CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 9, GetDefaultUrlWithPath("/foo.dat").c_str()));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream1_body, 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream1_body, 4),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
-    CreateMockWrite(*stream2_rst, 4),
+      CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyHeaderBlock> incomplete_headers(new SpdyHeaderBlock());
   (*incomplete_headers)["hello"] = "bye";
   (*incomplete_headers)[spdy_util_.GetStatusKey()] = "200 OK";
   (*incomplete_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructInitialSpdyPushFrame(
       incomplete_headers.Pass(), 2, 1));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream1_body, 4),
-    MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream1_body, 4),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5)  // Force a pause
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
+
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 // Verify that various SynReply headers parse correctly through the
 // HTTP layer.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) {
@@ skipping 37 matching lines @@
   if (spdy_util_.spdy_version() < SPDY4) {
     // SPDY4/HTTP2 eliminates use of the :version header.
     test_cases[0].expected_headers["version"] = "HTTP/1.1";
     test_cases[1].expected_headers["version"] = "HTTP/1.1";
     test_cases[2].expected_headers["version"] = "HTTP/1.1";
   }
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-    MockWrite writes[] = { CreateMockWrite(*req) };
+    MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     scoped_ptr<SpdyFrame> resp(
         spdy_util_.ConstructSpdyGetSynReply(test_cases[i].extra_headers,
                                  test_cases[i].num_headers,
                                  1));
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
-      CreateMockRead(*resp),
-      CreateMockRead(*body),
-      MockRead(ASYNC, 0, 0)  // EOF
+        CreateMockRead(*resp, 1),
+        CreateMockRead(*body, 2),
+        MockRead(ASYNC, 0, 3)  // EOF
     };
 
-    DelayedSocketData data(1, reads, arraysize(reads),
-                           writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     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);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
@@ skipping 83 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     // Construct the request.
     scoped_ptr<SpdyFrame> frame_req(
         spdy_util_.ConstructSpdyGet(test_cases[i].extra_headers[0],
                                     test_cases[i].num_headers[0],
                                     false, 1, LOWEST, true));
 
     MockWrite writes[] = {
-      CreateMockWrite(*frame_req),
+        CreateMockWrite(*frame_req, 0),
     };
 
     // Construct the reply.
     SpdyHeaderBlock reply_headers;
     AppendToHeaderBlock(test_cases[i].extra_headers[1],
                         test_cases[i].num_headers[1],
                         &reply_headers);
     scoped_ptr<SpdyFrame> frame_reply(
         spdy_util_.ConstructSpdyReply(1, reply_headers));
 
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
-      CreateMockRead(*frame_reply),
-      CreateMockRead(*body),
-      MockRead(ASYNC, 0, 0)  // EOF
+        CreateMockRead(*frame_reply, 1),
+        CreateMockRead(*body, 2),
+        MockRead(ASYNC, 0, 3)  // 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);
     }
 
-    DelayedSocketData data(1, reads, arraysize(reads),
-                           writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
 
     EXPECT_EQ(OK, out.rv) << i;
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line) << i;
     EXPECT_EQ("hello!", out.response_data) << i;
 
     // Test the response information.
@@ skipping 44 matching lines @@
     // SYN_REPLY with no headers
     { 0, { NULL }, },
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
-      CreateMockWrite(*req),
-      CreateMockWrite(*rst),
+        CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
     };
 
     // Construct the reply.
     SpdyHeaderBlock reply_headers;
     AppendToHeaderBlock(
         test_cases[i].headers, test_cases[i].num_headers, &reply_headers);
     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyReply(1, reply_headers));
     MockRead reads[] = {
-      CreateMockRead(*resp),
-      MockRead(ASYNC, 0, 0)  // EOF
+        CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 3)  // EOF
     };
 
-    DelayedSocketData data(1, reads, arraysize(reads),
-                           writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Verify that we don't crash on some corrupt frames.
 // TODO(jgraettinger): SPDY4 and up treats a header decompression failure as a
@@ skipping 20 matching lines @@
   } test_cases[] = {
     { syn_reply_wrong_length.get(), },
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
         spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
-      CreateMockWrite(*req),
-      CreateMockWrite(*rst),
+        CreateMockWrite(*req, 0), CreateMockWrite(*rst, 3),
     };
 
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
-      MockRead(ASYNC, test_cases[i].syn_reply->data(), wrong_size),
-      CreateMockRead(*body),
-      MockRead(ASYNC, 0, 0)  // EOF
+        MockRead(ASYNC, test_cases[i].syn_reply->data(), wrong_size, 1),
+        CreateMockRead(*body, 2),
+        MockRead(ASYNC, 0, 4)  // EOF
     };
 
-    DelayedSocketData data(1, reads, arraysize(reads),
-                           writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // SPDY4 treats a header decompression failure as a connection-level error.
 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionErrorSpdy4) {
   if (spdy_util_.spdy_version() < SPDY4) {
     return;
   }
   // This is the length field that's too short.
   scoped_ptr<SpdyFrame> syn_reply_wrong_length(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   size_t right_size =
       syn_reply_wrong_length->size() - framer.GetControlFrameHeaderSize();
   size_t wrong_size = right_size - 4;
   test::SetFrameLength(syn_reply_wrong_length.get(),
                        wrong_size,
                        spdy_util_.spdy_version());
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
-  MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
+  MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    MockRead(ASYNC, syn_reply_wrong_length->data(),
-             syn_reply_wrong_length->size() - 4),
+      MockRead(ASYNC, syn_reply_wrong_length->data(),
+               syn_reply_wrong_length->size() - 4, 1),
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnDecompressionFailure) {
   if (GetParam().protocol < kProtoSPDY4MinimumVersion) {
     // Decompression failures are a stream error in SPDY3 and above.
     return;
   }
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
-  MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
+  MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read HEADERS with corrupted payload.
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   memset(resp->data() + 12, 0xff, resp->size() - 12);
-  MockRead reads[] = {CreateMockRead(*resp)};
+  MockRead reads[] = {CreateMockRead(*resp, 1)};
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnFrameSizeError) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_PROTOCOL_ERROR, "Framer error: 1 (INVALID_CONTROL_FRAME)."));
-  MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
+  MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2)};
 
   // Read WINDOW_UPDATE with incorrectly-sized payload.
   // TODO(jgraettinger): SpdyFramer signals this as an INVALID_CONTROL_FRAME,
   // which is mapped to a protocol error, and not a frame size error.
   scoped_ptr<SpdyFrame> bad_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, 1));
   test::SetFrameLength(bad_window_update.get(),
                        bad_window_update->size() - 1,
                        spdy_util_.spdy_version());
-  MockRead reads[] = {CreateMockRead(*bad_window_update)};
+  MockRead reads[] = {CreateMockRead(*bad_window_update, 1)};
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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<SpdyFrame> req(
@@ skipping 28 matching lines @@
   EXPECT_EQ(ERR_FAILED, out.rv);
 }
 
 // Test that partial writes work.
 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   const int kChunks = 5;
   scoped_ptr<MockWrite[]> writes(ChopWriteFrame(*req.get(), kChunks));
+  for (int i = 0; i < kChunks; ++i) {
+    writes[i].sequence_number = i;
+  }
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, kChunks),
+      CreateMockRead(*body, kChunks + 1),
+      MockRead(ASYNC, 0, kChunks + 2)  // EOF
   };
 
-  DelayedSocketData data(kChunks, reads, arraysize(reads),
-                         writes.get(), kChunks);
+  SequencedSocketData data(reads, arraysize(reads), writes.get(), kChunks);
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 }
 
 // In this test, we enable compression, but get a uncompressed SynReply from
 // the server.  Verify that teardown is all clean.
 TEST_P(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
   if (spdy_util_.spdy_version() >= SPDY4) {
     // HPACK doesn't use deflate compression.
     return;
   }
   scoped_ptr<SpdyFrame> compressed(
       spdy_util_.ConstructSpdyGet(NULL, 0, true, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
-  MockWrite writes[] = {CreateMockWrite(*compressed), CreateMockWrite(*goaway)};
+  MockWrite writes[] = {CreateMockWrite(*compressed, 0),
+                        CreateMockWrite(*goaway, 2)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
+      CreateMockRead(*resp, 1),
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   SpdySessionDependencies* session_deps =
       CreateSpdySessionDependencies(GetParam());
   session_deps->enable_compression = true;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), session_deps);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
   data.Reset();
 }
 
 // Test that the NetLog contains good data for a simple GET request.
 TEST_P(SpdyNetworkTransactionTest, NetLog) {
   static const char* const kExtraHeaders[] = {
     "user-agent",   "Chrome",
   };
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(kExtraHeaders, 1, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
   BoundTestNetLog log;
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequestWithUserAgent(),
                                      DEFAULT_PRIORITY,
                                      log.bound(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 
   // Check that the NetLog was filled reasonably.
@@ skipping 58 matching lines @@
 
 // Since we buffer the IO from the stream to the renderer, this test verifies
 // that when we read out the maximum amount of data (e.g. we received 50 bytes
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
 TEST_P(SpdyNetworkTransactionTest, BufferFull) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 2 data frames in a single read.
   scoped_ptr<SpdyFrame> data_frame_1(
       framer.CreateDataFrame(1, "goodby", 6, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_2(
       framer.CreateDataFrame(1, "e worl", 6, DATA_FLAG_NONE));
   const SpdyFrame* data_frames[2] = {
     data_frame_1.get(),
     data_frame_2.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<SpdyFrame> last_frame(
       framer.CreateDataFrame(1, "d", 1, DATA_FLAG_FIN));
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    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(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause
+      MockRead(ASYNC, combined_data_frames, combined_data_frames_len, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause
+      CreateMockRead(*last_frame, 5),
+      MockRead(ASYNC, 0, 6)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
@@ skipping 44 matching lines @@
 }
 
 // Verify that basic buffering works; when multiple data frames arrive
 // at the same time, ensure that we don't notify a read completion for
 // each data frame individually.
 TEST_P(SpdyNetworkTransactionTest, Buffering) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 4 data frames in a single read.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
   const SpdyFrame* data_frames[4] = {
     data_frame.get(),
     data_frame.get(),
     data_frame.get(),
     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<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
-    MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause
+      MockRead(ASYNC, combined_data_frames, combined_data_frames_len, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
@@ skipping 47 matching lines @@
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data but read it after it has been buffered.
 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // 5 data frames in a single read.
   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   scoped_ptr<SpdyFrame> data_frame_fin(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
   const SpdyFrame* frames[5] = {reply.get(), data_frame.get(), 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(ASYNC, combined_frames, combined_frames_len),
-    MockRead(ASYNC, 0, 0)  // EOF
+      MockRead(ASYNC, combined_frames, combined_frames_len, 1),
+      MockRead(ASYNC, 0, 2)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
@@ skipping 43 matching lines @@
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
 
 // Verify the case where we buffer data and close the connection.
 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // All data frames in a single read.
   // NOTE: We don't FIN the stream.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
   const SpdyFrame* data_frames[4] = {
     data_frame.get(),
     data_frame.get(),
     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<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
-    MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a wait
+      MockRead(ASYNC, combined_data_frames, combined_data_frames_len, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(
@@ skipping 47 matching lines @@
 }
 
 // Verify the case where we buffer data and cancel the transaction.
 TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
-  MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*rst)};
+  MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4)};
 
   // NOTE: We don't FIN the stream.
   scoped_ptr<SpdyFrame> data_frame(
       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
-    CreateMockRead(*data_frame),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a wait
+      CreateMockRead(*data_frame, 3),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
@@ skipping 60 matching lines @@
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.example.org", helper.port());
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
       host_port_pair).empty());
 
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // Construct the reply.
   scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
   (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
   (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> reply(
     spdy_util_.ConstructSpdyFrame(kSynReplyInfo, reply_headers.Pass()));
 
   const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
@@ skipping 12 matching lines @@
     settings[kSampleId2] =
         SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kSampleValue2);
     // Next add another persisted setting.
     settings[kSampleId3] =
         SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue3);
     settings_frame.reset(spdy_util_.ConstructSpdySettings(settings));
   }
 
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*reply),
-    CreateMockRead(*body),
-    CreateMockRead(*settings_frame),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*reply, 1),
+      CreateMockRead(*body, 2),
+      CreateMockRead(*settings_frame, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.AddData(&data);
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   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);
 
   {
     // Verify we had two persisted settings.
@@ skipping 88 matching lines @@
   const SettingsMap& settings =
       spdy_session_pool->http_server_properties()->GetSpdySettings(
           host_port_pair);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
 
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 
-  std::vector<MockWrite> writes;
-  if ((GetParam().protocol >= kProtoSPDY4MinimumVersion) &&
-      (GetParam().protocol <= kProtoSPDY4MaximumVersion)) {
-    writes.push_back(
-        MockWrite(ASYNC,
-                  kHttp2ConnectionHeaderPrefix,
-                  kHttp2ConnectionHeaderPrefixSize));
-  }
-  writes.push_back(CreateMockWrite(*initial_settings_frame));
-  writes.push_back(CreateMockWrite(*settings_frame));
-  writes.push_back(CreateMockWrite(*req));
+  MockWrite writes[] = {
+      CreateMockWrite(*initial_settings_frame, 0),
+      CreateMockWrite(*settings_frame, 1),
+      CreateMockWrite(*req, 2),
+  };
 
   // Construct the reply.
   scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
   (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
   (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> reply(
     spdy_util_.ConstructSpdyFrame(kSynReplyInfo, reply_headers.Pass()));
 
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*reply),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*reply, 3),
+      CreateMockRead(*body, 4),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  DelayedSocketData data(2, reads, arraysize(reads),
-                         vector_as_array(&writes), writes.size());
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.AddData(&data);
   helper.RunDefaultTest();
   helper.VerifyDataConsumed();
   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);
 
   {
     // Verify we had two persisted settings.
@@ skipping 14 matching lines @@
     EXPECT_TRUE(it2 != settings_map.end());
     SettingsFlagsAndValue flags_and_value2 = it2->second;
     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value2.first);
     EXPECT_EQ(kSampleValue2, flags_and_value2.second);
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway());
   MockRead reads[] = {
-    CreateMockRead(*go_away),
+      CreateMockRead(*go_away, 1),
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_ABORTED, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite writes[] = { CreateMockWrite(*req) };
+  MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    MockRead(SYNCHRONOUS, 0, 0)  // EOF
+      CreateMockRead(*resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      log, GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   TransactionHelperResult out;
   out.rv = trans->Start(&CreateGetRequest(), callback.callback(), log);
@@ skipping 17 matching lines @@
   // HTTP_1_1_REQUIRED is only supported by SPDY4.
   if (spdy_util_.spdy_version() < SPDY4)
     return;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), nullptr);
 
   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads[] = {
-      CreateMockRead(*go_away),
+      CreateMockRead(*go_away, 0),
   };
-  DelayedSocketData data(0, reads, arraysize(reads), nullptr, 0);
+  SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
 
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_HTTP_1_1_REQUIRED, out.rv);
 }
 
 // Retry with HTTP/1.1 when receiving HTTP_1_1_REQUIRED.  Note that no actual
 // protocol negotiation happens, instead this test forces protocols for both
 // sockets.
 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
@@ skipping 13 matching lines @@
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   session_deps->next_protos = SpdyNextProtos();
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), session_deps.release());
 
   // First socket: HTTP/2 request rejected with HTTP_1_1_REQUIRED.
   const char* url = request.url.spec().c_str();
   scoped_ptr<SpdyHeaderBlock> headers(spdy_util_.ConstructGetHeaderBlock(url));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true));
-  MockWrite writes0[] = {CreateMockWrite(*req)};
+  MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
-  MockRead reads0[] = {CreateMockRead(*go_away)};
-  DelayedSocketData data0(1, reads0, arraysize(reads0), writes0,
-                          arraysize(writes0));
+  MockRead reads0[] = {CreateMockRead(*go_away, 1)};
+  SequencedSocketData data0(reads0, arraysize(reads0), writes0,
+                            arraysize(writes0));
 
   scoped_ptr<SSLSocketDataProvider> ssl_provider0(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect HTTP/2 protocols too in SSLConfig.
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY31);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_14);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4);
   // Force SPDY.
   ssl_provider0->SetNextProto(GetParam().protocol);
   helper.AddDataWithSSLSocketDataProvider(&data0, ssl_provider0.Pass());
 
   // Second socket: falling back to HTTP/1.1.
-  MockWrite writes1[] = {MockWrite(
-      "GET / HTTP/1.1\r\n"
-      "Host: www.example.org\r\n"
-      "Connection: keep-alive\r\n\r\n")};
-  MockRead reads1[] = {MockRead(
-      "HTTP/1.1 200 OK\r\n"
-      "Content-Length: 5\r\n\r\n"
-      "hello")};
-  DelayedSocketData data1(1, reads1, arraysize(reads1), writes1,
-                          arraysize(writes1));
+  MockWrite writes1[] = {MockWrite(ASYNC, 0,
+                                   "GET / HTTP/1.1\r\n"
+                                   "Host: www.example.org\r\n"
+                                   "Connection: keep-alive\r\n\r\n")};
+  MockRead reads1[] = {MockRead(ASYNC, 1,
+                                "HTTP/1.1 200 OK\r\n"
+                                "Content-Length: 5\r\n\r\n"
+                                "hello")};
+  SequencedSocketData data1(reads1, arraysize(reads1), writes1,
+                            arraysize(writes1));
 
   scoped_ptr<SSLSocketDataProvider> ssl_provider1(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect only HTTP/1.1 protocol in SSLConfig.
   ssl_provider1->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   // Force HTTP/1.1.
   ssl_provider1->SetNextProto(kProtoHTTP11);
   helper.AddDataWithSSLSocketDataProvider(&data1, ssl_provider1.Pass());
 
   base::WeakPtr<HttpServerProperties> http_server_properties =
@@ skipping 42 matching lines @@
           GetParam(),
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70")));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   session_deps->next_protos = SpdyNextProtos();
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), session_deps.release());
 
   // First socket: HTTP/2 CONNECT rejected with HTTP_1_1_REQUIRED.
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect(
       nullptr, 0, 1, LOWEST, HostPortPair("www.example.org", 443)));
-  MockWrite writes0[] = {CreateMockWrite(*req)};
+  MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
-  MockRead reads0[] = {CreateMockRead(*go_away)};
-  DelayedSocketData data0(1, reads0, arraysize(reads0), writes0,
-                          arraysize(writes0));
+  MockRead reads0[] = {CreateMockRead(*go_away, 1)};
+  SequencedSocketData data0(reads0, arraysize(reads0), writes0,
+                            arraysize(writes0));
 
   scoped_ptr<SSLSocketDataProvider> ssl_provider0(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect HTTP/2 protocols too in SSLConfig.
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY31);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_14);
   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4);
   // Force SPDY.
   ssl_provider0->SetNextProto(GetParam().protocol);
   helper.AddDataWithSSLSocketDataProvider(&data0, ssl_provider0.Pass());
 
   // Second socket: retry using HTTP/1.1.
   MockWrite writes1[] = {
-      MockWrite(ASYNC, 1,
+      MockWrite(ASYNC, 0,
                 "CONNECT www.example.org:443 HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Proxy-Connection: keep-alive\r\n\r\n"),
-      MockWrite(ASYNC, 3,
+      MockWrite(ASYNC, 2,
                 "GET / HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead reads1[] = {
-      MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n\r\n"),
-      MockRead(ASYNC, 4,
+      MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n\r\n"),
+      MockRead(ASYNC, 3,
                "HTTP/1.1 200 OK\r\n"
                "Content-Length: 5\r\n\r\n"
                "hello"),
   };
-  DelayedSocketData data1(1, reads1, arraysize(reads1), writes1,
-                          arraysize(writes1));
+  SequencedSocketData data1(reads1, arraysize(reads1), writes1,
+                            arraysize(writes1));
 
   scoped_ptr<SSLSocketDataProvider> ssl_provider1(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect only HTTP/1.1 protocol in SSLConfig.
   ssl_provider1->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
   // Force HTTP/1.1.
   ssl_provider1->SetNextProto(kProtoHTTP11);
   helper.AddDataWithSSLSocketDataProvider(&data1, ssl_provider1.Pass());
 
   // A third socket is needed for the tunnelled connection.
@@ skipping 53 matching lines @@
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
       CreateMockWrite(*req, 2),
   };
   MockRead reads[] = {
       MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
       CreateMockRead(*resp, 3),
       CreateMockRead(*body.get(), 4),
       MockRead(ASYNC, 0, 0, 5),
   };
-  scoped_ptr<OrderedSocketData> data(new OrderedSocketData(
+  scoped_ptr<SequencedSocketData> data(new SequencedSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
 
   helper.AddData(data.get());
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 29 matching lines @@
   helper.SetSession(make_scoped_refptr(
       SpdySessionDependencies::SpdyCreateSession(helper.session_deps().get())));
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   helper.RunPreTestSetup();
 
   // Construct and send a simple GET request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req, 1),
+      CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    CreateMockRead(*body, 3),
-    MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause
-    MockRead(ASYNC, 0, 5)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3),  // Force a pause
   };
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   TransactionHelperResult out;
   out.rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
@@ skipping 34 matching lines @@
       MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
       CreateMockWrite(*req2, 2),
   };
   MockRead reads2[] = {
       MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
       CreateMockRead(*resp2, 3),
       CreateMockRead(*body2, 4),
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  scoped_ptr<OrderedSocketData> data_proxy(new OrderedSocketData(
+  scoped_ptr<SequencedSocketData> data_proxy(new SequencedSocketData(
       reads2, arraysize(reads2), writes2, arraysize(writes2)));
 
   // Create another request to www.example.org, but this time through a proxy.
   HttpRequestInfo request_proxy;
   request_proxy.method = "GET";
   request_proxy.url = GURL(GetDefaultUrlWithPath("/foo.dat"));
   request_proxy.load_flags = 0;
   scoped_ptr<SpdySessionDependencies> ssd_proxy(
       CreateSpdySessionDependencies(GetParam()));
   // Ensure that this transaction uses the same SpdySessionPool.
@@ skipping 19 matching lines @@
   EXPECT_EQ(0, rv);
 
   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
   EXPECT_TRUE(response_proxy.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data));
   EXPECT_EQ("hello!", response_data);
 
-  data.CompleteRead();
   helper_proxy.VerifyDataConsumed();
 }
 
 // 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<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, ERR_IO_PENDING),
-    MockRead(ASYNC, ERR_CONNECTION_RESET),
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, ERR_IO_PENDING, 3),
+      MockRead(ASYNC, ERR_CONNECTION_RESET, 4),
   };
 
   MockRead reads2[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
+  scoped_ptr<SpdyFrame> req(
+      spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+  scoped_ptr<SpdyFrame> req3(
+      spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
+  MockWrite writes1[] = {CreateMockWrite(*req, 0), CreateMockWrite(*req3, 5)};
+  MockWrite writes2[] = {CreateMockWrite(*req, 0)};
+
   // This test has a couple of variants.
   enum {
     // Induce the RST while waiting for our transaction to send.
-    VARIANT_RST_DURING_SEND_COMPLETION,
+    VARIANT_RST_DURING_SEND_COMPLETION = 0,
     // 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
+    VARIANT_RST_DURING_READ_COMPLETION = 1
   };
 
   for (int variant = VARIANT_RST_DURING_SEND_COMPLETION;
        variant <= VARIANT_RST_DURING_READ_COMPLETION;
        ++variant) {
-    DelayedSocketData data1(1, reads, arraysize(reads), NULL, 0);
+    SequencedSocketData data1(reads, arraysize(reads), writes1, 1 + variant);
 
-    DelayedSocketData data2(1, reads2, arraysize(reads2), NULL, 0);
+    SequencedSocketData data2(reads2, arraysize(reads2), writes2,
+                              arraysize(writes2));
 
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.AddData(&data1);
     helper.AddData(&data2);
     helper.RunPreTestSetup();
 
     for (int i = 0; i < 2; ++i) {
       scoped_ptr<HttpNetworkTransaction> trans(
           new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 
       TestCompletionCallback callback;
       int rv = trans->Start(
           &helper.request(), callback.callback(), BoundNetLog());
       EXPECT_EQ(ERR_IO_PENDING, rv);
       // On the second transaction, we trigger the RST.
       if (i == 1) {
         if (variant == VARIANT_RST_DURING_READ_COMPLETION) {
           // Writes to the socket complete asynchronously on SPDY by running
           // through the message loop.  Complete the write here.
           base::RunLoop().RunUntilIdle();
         }
 
         // Now schedule the ERR_CONNECTION_RESET.
-        EXPECT_EQ(3u, data1.read_index());
         data1.CompleteRead();
-        EXPECT_EQ(4u, data1.read_index());
       }
       rv = callback.WaitForResult();
       EXPECT_EQ(OK, rv);
 
       const HttpResponseInfo* response = trans->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
       EXPECT_TRUE(response->headers.get() != NULL);
       EXPECT_TRUE(response->was_fetched_via_spdy);
       std::string response_data;
       rv = ReadTransaction(trans.get(), &response_data);
       EXPECT_EQ(OK, rv);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
+      base::RunLoop().RunUntilIdle();
     }
 
     helper.VerifyDataConsumed();
+    base::RunLoop().RunUntilIdle();
   }
 }
 
 // Test that turning SPDY on and off works properly.
 TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) {
   HttpStreamFactory::set_spdy_enabled(true);
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  MockWrite spdy_writes[] = { CreateMockWrite(*req) };
+  MockWrite spdy_writes[] = {CreateMockWrite(*req, 0)};
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
-    CreateMockRead(*resp),
-    CreateMockRead(*body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*resp, 1),
+      CreateMockRead(*body, 2),
+      MockRead(ASYNC, 0, 3)  // EOF
   };
 
-  DelayedSocketData data(1, spdy_reads, arraysize(spdy_reads),
-                         spdy_writes, arraysize(spdy_writes));
+  SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes,
+                           arraysize(spdy_writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   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);
 
   HttpStreamFactory::set_spdy_enabled(false);
+  MockWrite http_writes[] = {
+      MockWrite(SYNCHRONOUS, 0,
+                "GET / HTTP/1.1\r\n"
+                "Host: www.example.org\r\n"
+                "Connection: keep-alive\r\n\r\n"),
+  };
+
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello from http"),
-    MockRead(SYNCHRONOUS, OK),
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
+      MockRead(SYNCHRONOUS, 2, "hello from http"),
+      MockRead(SYNCHRONOUS, OK, 3),
   };
-  DelayedSocketData data2(1, http_reads, arraysize(http_reads), NULL, 0);
+  SequencedSocketData data2(http_reads, arraysize(http_reads), http_writes,
+                            arraysize(http_writes));
   NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper2.SetSpdyDisabled();
   helper2.RunToCompletion(&data2);
   TransactionHelperResult out2 = helper2.output();
   EXPECT_EQ(OK, out2.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
   EXPECT_EQ("hello from http", out2.response_data);
 
   HttpStreamFactory::set_spdy_enabled(true);
 }
 
 // Tests that Basic authentication works over SPDY
 TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) {
   HttpStreamFactory::set_spdy_enabled(true);
 
   // The first request will be a bare GET, the second request will be a
   // GET with an Authorization header.
   scoped_ptr<SpdyFrame> req_get(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   const char* const kExtraAuthorizationHeaders[] = {
     "authorization", "Basic Zm9vOmJhcg=="
   };
   scoped_ptr<SpdyFrame> req_get_authorization(
       spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders,
                                   arraysize(kExtraAuthorizationHeaders) / 2,
                                   false, 3, LOWEST, true));
   MockWrite spdy_writes[] = {
-    CreateMockWrite(*req_get, 1),
-    CreateMockWrite(*req_get_authorization, 4),
+      CreateMockWrite(*req_get, 0), CreateMockWrite(*req_get_authorization, 3),
   };
 
   // The first response is a 401 authentication challenge, and the second
   // response will be a 200 response since the second request includes a valid
   // Authorization header.
   const char* const kExtraAuthenticationHeaders[] = {
     "www-authenticate",
     "Basic realm=\"MyRealm\""
   };
   scoped_ptr<SpdyFrame> resp_authentication(
       spdy_util_.ConstructSpdySynReplyError(
           "401 Authentication Required",
           kExtraAuthenticationHeaders,
           arraysize(kExtraAuthenticationHeaders) / 2,
           1));
   scoped_ptr<SpdyFrame> body_authentication(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   scoped_ptr<SpdyFrame> resp_data(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body_data(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
-    CreateMockRead(*resp_authentication, 2),
-    CreateMockRead(*body_authentication, 3),
-    CreateMockRead(*resp_data, 5),
-    CreateMockRead(*body_data, 6),
-    MockRead(ASYNC, 0, 7),
+      CreateMockRead(*resp_authentication, 1),
+      CreateMockRead(*body_authentication, 2),
+      CreateMockRead(*resp_data, 4),
+      CreateMockRead(*body_data, 5),
+      MockRead(ASYNC, 0, 6),
   };
 
-  OrderedSocketData data(spdy_reads, arraysize(spdy_reads),
-                         spdy_writes, arraysize(spdy_writes));
+  SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes,
+                           arraysize(spdy_writes));
   HttpRequestInfo request(CreateGetRequest());
   BoundNetLog net_log;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      net_log, GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
   const int rv_start = trans->Start(&request, callback.callback(), net_log);
@@ skipping 30 matching lines @@
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*stream1_syn, 1),
+      CreateMockWrite(*stream1_syn, 0),
   };
 
   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  initial_headers.get());
   scoped_ptr<SpdyFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
   (*late_headers)["hello"] = "bye";
   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
   (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   scoped_ptr<SpdyFrame> stream2_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            2,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
 
   scoped_ptr<SpdyFrame>
       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   const char kPushedData[] = "pushed";
   scoped_ptr<SpdyFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(
           2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply, 2),
-    CreateMockRead(*stream2_syn, 3),
-    CreateMockRead(*stream2_headers, 4),
-    CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-    CreateMockRead(*stream2_body, 5),
-    MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream2_syn, 2),
+      CreateMockRead(*stream2_headers, 3),
+      CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
+      CreateMockRead(*stream2_body, 5),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the SYN_REPLY.
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
@@ skipping 365 matching lines @@
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-      CreateMockWrite(*req), CreateMockWrite(*rst),
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
   };
 
   scoped_ptr<SpdyFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
   (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream1_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            1,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply),
-    CreateMockRead(*stream1_headers),
-    CreateMockRead(*stream1_body),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream1_headers, 2),
+      CreateMockRead(*stream1_body, 3),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*rst),
+      CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
   };
 
   scoped_ptr<SpdyFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
   (*late_headers)["hello"] = "bye";
   scoped_ptr<SpdyFrame> stream1_headers(
       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
                                            false,
                                            1,
                                            LOWEST,
                                            HEADERS,
                                            CONTROL_FLAG_NONE,
                                            0));
   scoped_ptr<SpdyFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> stream1_body2(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
-    CreateMockRead(*stream1_reply),
-    CreateMockRead(*stream1_body),
-    CreateMockRead(*stream1_headers),
-    CreateMockRead(*stream1_body2),
-    MockRead(ASYNC, 0, 0)  // EOF
+      CreateMockRead(*stream1_reply, 1),
+      CreateMockRead(*stream1_body, 2),
+      CreateMockRead(*stream1_headers, 3),
+      CreateMockRead(*stream1_body2, 5),
+      MockRead(ASYNC, 0, 6)  // EOF
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
   // Running these tests via Alt-Svc is too complicated to be worthwhile.
   if (GetParam().ssl_type != HTTPS_SPDY_VIA_NPN)
@@ skipping 27 matching lines @@
     const char* url_to_fetch = kTestCases[index];
     const char* url_to_push = kTestCases[index + 1];
 
     scoped_ptr<SpdyFrame> stream1_syn(
         spdy_util_.ConstructSpdyGet(url_to_fetch, false, 1, LOWEST));
     scoped_ptr<SpdyFrame> stream1_body(
         spdy_util_.ConstructSpdyBodyFrame(1, true));
     scoped_ptr<SpdyFrame> push_rst(
         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
     MockWrite writes[] = {
-      CreateMockWrite(*stream1_syn, 1),
-      CreateMockWrite(*push_rst, 4),
+        CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*push_rst, 3),
     };
 
     scoped_ptr<SpdyFrame>
         stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<SpdyFrame>
         stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                                  0,
                                                  2,
                                                  1,
                                                  url_to_push));
     const char kPushedData[] = "pushed";
     scoped_ptr<SpdyFrame> stream2_body(
         spdy_util_.ConstructSpdyBodyFrame(
             2, kPushedData, strlen(kPushedData), true));
     scoped_ptr<SpdyFrame> rst(
         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
 
     MockRead reads[] = {
-      CreateMockRead(*stream1_reply, 2),
-      CreateMockRead(*stream2_syn, 3),
-      CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
-      CreateMockRead(*stream2_body, 6),
-      MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
+        CreateMockRead(*stream1_reply, 1),
+        CreateMockRead(*stream2_syn, 2),
+        CreateMockRead(*stream1_body, 4),
+        CreateMockRead(*stream2_body, 5),
+        MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
     };
 
     HttpResponseInfo response;
-    OrderedSocketData data(reads, arraysize(reads),
-                           writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL(url_to_fetch);
     request.load_flags = 0;
 
     // Enable cross-origin push. Since we are not using a proxy, this should
     // not actually enable cross-origin SPDY push.
     scoped_ptr<SpdySessionDependencies> session_deps(
         CreateSpdySessionDependencies(GetParam()));
@@ skipping 33 matching lines @@
   }
 }
 
 TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) {
   // Construct the request.
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req, 1),
-    CreateMockWrite(*req2, 3),
+      CreateMockWrite(*req, 0), CreateMockWrite(*req2, 2),
   };
 
   scoped_ptr<SpdyFrame> refused(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM));
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead reads[] = {
-    CreateMockRead(*refused, 2),
-    CreateMockRead(*resp, 4),
-    CreateMockRead(*body, 5),
-    MockRead(ASYNC, 0, 6)  // EOF
+      CreateMockRead(*refused, 1),
+      CreateMockRead(*resp, 3),
+      CreateMockRead(*body, 4),
+      MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  OrderedSocketData data(reads, arraysize(reads),
-                         writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(
       &CreateGetRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
 }
 
 TEST_P(SpdyNetworkTransactionTest, OutOfOrderSynStream) {
   // This first request will start to establish the SpdySession.
   // Then we will start the second (MEDIUM priority) and then third
@@ skipping 240 matching lines @@
       spdy_util_.ConstructSpdyWindowUpdate(0, session_window_update_delta));
   scoped_ptr<SpdyFrame> stream_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, stream_window_update_delta));
 
   std::vector<MockWrite> writes;
   if ((GetParam().protocol >= kProtoSPDY4MinimumVersion) &&
       (GetParam().protocol <= kProtoSPDY4MaximumVersion)) {
     writes.push_back(MockWrite(ASYNC, kHttp2ConnectionHeaderPrefix,
                                kHttp2ConnectionHeaderPrefixSize, 0));
   }
-  writes.push_back(CreateMockWrite(*initial_settings_frame));
-  writes.push_back(CreateMockWrite(*initial_window_update));
-  writes.push_back(CreateMockWrite(*req));
-  writes.push_back(CreateMockWrite(*session_window_update));
-  writes.push_back(CreateMockWrite(*stream_window_update));
+  writes.push_back(CreateMockWrite(*initial_settings_frame, writes.size()));
+  writes.push_back(CreateMockWrite(*initial_window_update, writes.size()));
+  writes.push_back(CreateMockWrite(*req, writes.size()));
 
   std::vector<MockRead> reads;
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  reads.push_back(CreateMockRead(*resp));
+  reads.push_back(CreateMockRead(*resp, writes.size() + reads.size()));
 
   ScopedVector<SpdyFrame> body_frames;
   const std::string body_data(kChunkSize, 'x');
   for (size_t remaining = kTargetSize; remaining != 0;) {
     size_t frame_size = std::min(remaining, body_data.size());
     body_frames.push_back(spdy_util_.ConstructSpdyBodyFrame(
         1, body_data.data(), frame_size, false));
-    reads.push_back(CreateMockRead(*body_frames.back()));
+    reads.push_back(
+        CreateMockRead(*body_frames.back(), writes.size() + reads.size()));
     remaining -= frame_size;
   }
-  reads.push_back(MockRead(ASYNC, ERR_IO_PENDING, 0));  // Yield.
+  reads.push_back(
+      MockRead(ASYNC, ERR_IO_PENDING, writes.size() + reads.size()));  // Yield.
 
-  DelayedSocketData data(2, vector_as_array(&reads), reads.size(),
-                         vector_as_array(&writes), writes.size());
+  writes.push_back(
+      CreateMockWrite(*session_window_update, writes.size() + reads.size()));
+  writes.push_back(
+      CreateMockWrite(*stream_window_update, writes.size() + reads.size()));
+
+  SequencedSocketData data(vector_as_array(&reads), reads.size(),
+                           vector_as_array(&writes), writes.size());
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
   pool_peer.SetEnableSendingInitialData(true);
   pool_peer.SetSessionMaxRecvWindowSize(session_max_recv_window_size);
@@ skipping 101 matching lines @@
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult());
   helper.VerifyDataConsumed();
 }
 
 // Test that after hitting a send window size of 0, the write process
 // stalls and upon receiving WINDOW_UPDATE frame write resumes.
 
 // This test constructs a POST request followed by enough data frames
 // containing 'a' that would make the window size 0, followed by another
 // data frame containing default content (which is "hello!") and this frame
-// also contains a FIN flag.  DelayedSocketData is used to enforce all
-// writes go through before a read could happen.  However, the last frame
-// ("hello!")  is not supposed to go through since by the time its turn
+// also contains a FIN flag.  SequencedSocketData is used to enforce all
+// writes, save the last, go through before a read could happen.  The last frame
+// ("hello!") is not permitted to go through since by the time its turn
 // arrives, window size is 0.  At this point MessageLoop::Run() called via
 // callback would block.  Therefore we call MessageLoop::RunUntilIdle()
 // which returns after performing all possible writes.  We use DCHECKS to
 // ensure that last data frame is still there and stream has stalled.
 // After that, next read is artifically enforced, which causes a
 // WINDOW_UPDATE to be read and I/O process resumes.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) {
   const int32 initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
   // Number of frames we need to send to zero out the window size: data
@@ skipping 21 matching lines @@
   scoped_ptr<SpdyFrame> body2(
       spdy_util_.ConstructSpdyBodyFrame(
           1, content.c_str(), last_frame_size, false));
 
   // Data frame to be sent once WINDOW_UPDATE frame is received.
   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   // Fill in mock writes.
   scoped_ptr<MockWrite[]> writes(new MockWrite[num_writes]);
   size_t i = 0;
-  writes[i] = CreateMockWrite(*req);
+  writes[i] = CreateMockWrite(*req, i);
   for (i = 1; i < num_writes - 2; i++)
-    writes[i] = CreateMockWrite(*body1);
-  writes[i++] = CreateMockWrite(*body2);
-  writes[i] = CreateMockWrite(*body3);
+    writes[i] = CreateMockWrite(*body1, i);
+  writes[i] = CreateMockWrite(*body2, i);
+  // The last write must not be attempted until after the WINDOW_UPDATES
+  // have been received.
+  writes[i + 1] = CreateMockWrite(*body3, i + 4, SYNCHRONOUS);
 
   // Construct read frame, give enough space to upload the rest of the
   // data.
   scoped_ptr<SpdyFrame> session_window_update(
       spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize));
   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   MockRead reads[] = {
-    CreateMockRead(*session_window_update),
-    CreateMockRead(*session_window_update),
-    CreateMockRead(*window_update),
-    CreateMockRead(*window_update),
-    CreateMockRead(*reply),
-    CreateMockRead(*body2),
-    CreateMockRead(*body3),
-    MockRead(ASYNC, 0, 0)  // EOF
+      MockRead(ASYNC, ERR_IO_PENDING, i + 1),  // Force a pause
+      CreateMockRead(*session_window_update, i + 2),
+      CreateMockRead(*window_update, i + 3),
+      // Now the last write will occur.
+      CreateMockRead(*reply, i + 5),
+      CreateMockRead(*body2, i + 6),
+      CreateMockRead(*body3, i + 7),
+      MockRead(ASYNC, 0, i + 8)  // EOF
   };
 
-  // Skip the session window updates unless we're using SPDY/3.1 and
-  // above.
-  size_t read_offset = (GetParam().protocol >= kProtoSPDY31) ? 0 : 2;
-  size_t num_reads = arraysize(reads) - read_offset;
-
-  // Force all writes to happen before any read, last write will not
-  // actually queue a frame, due to window size being 0.
-  DelayedSocketData data(num_writes, reads + read_offset, num_reads,
-                         writes.get(), num_writes);
+  SequencedSocketData data(reads, arraysize(reads), writes.get(), num_writes);
 
   ScopedVector<UploadElementReader> element_readers;
   std::string upload_data_string(initial_window_size, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size()));
   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ skipping 17 matching lines @@
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
   // All the body data should have been read.
   // TODO(satorux): This is because of the weirdness in reading the request
   // body in OnSendBodyComplete(). See crbug.com/113107.
   EXPECT_TRUE(upload_data_stream.IsEOF());
   // But the body is not yet fully sent (kUploadData is not yet sent)
   // since we're send-stalled.
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
-  data.ForceNextRead();   // Read in WINDOW_UPDATE frame.
+  data.CompleteRead();  // Read in WINDOW_UPDATE frame.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in
 // unstalling the send window.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) {
   const int32 initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
 
@@ skipping 242 matching lines @@
   MockRead reads[] = {CreateMockRead(*push, 1)};
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_PROTOCOL_ERROR, "Odd push stream id."));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2),
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest,
        GoAwayOnPushStreamIdLesserOrEqualThanLastAccepted) {
   if (spdy_util_.spdy_version() < SPDY3)
@@ skipping 13 matching lines @@
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       4,
       GOAWAY_PROTOCOL_ERROR,
       "New push stream id must be greater than the last accepted."));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 3),
   };
 
-  DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 class SpdyNetworkTransactionNoTLSUsageCheckTest
     : public SpdyNetworkTransactionTest {
  protected:
   void RunNoTLSUsageCheckTest(scoped_ptr<SSLSocketDataProvider> ssl_provider) {
     // Construct the request.
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-    MockWrite writes[] = {CreateMockWrite(*req)};
+    MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
-        CreateMockRead(*resp), CreateMockRead(*body),
-        MockRead(ASYNC, 0, 0)  // EOF
+        CreateMockRead(*resp, 1),
+        CreateMockRead(*body, 2),
+        MockRead(ASYNC, 0, 3)  // EOF
     };
 
-    DelayedSocketData data(
-        1, reads, arraysize(reads), writes, arraysize(writes));
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("https://www.example.org/");
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, ssl_provider.Pass());
     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);
@@ skipping 31 matching lines @@
 }
 
 class SpdyNetworkTransactionTLSUsageCheckTest
     : public SpdyNetworkTransactionTest {
  protected:
   void RunTLSUsageCheckTest(scoped_ptr<SSLSocketDataProvider> ssl_provider) {
     scoped_ptr<SpdyFrame> goaway(
         spdy_util_.ConstructSpdyGoAway(0, GOAWAY_INADEQUATE_SECURITY, ""));
     MockWrite writes[] = {CreateMockWrite(*goaway)};
 
-    DelayedSocketData data(1, NULL, 0, writes, arraysize(writes));
+    StaticSocketDataProvider data(NULL, 0, writes, arraysize(writes));
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("https://www.example.org/");
     NormalSpdyTransactionHelper helper(
         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletionWithSSLData(&data, ssl_provider.Pass());
     TransactionHelperResult out = helper.output();
     EXPECT_EQ(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, out.rv);
   }
 };
@@ skipping 17 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net