Use SequencedSocketData in HttpStreamParserTests.

net/http/http_stream_parser_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_parser.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 25 matching lines @@
 namespace {
 
 const size_t kOutputSize = 1024;  // Just large enough for this test.
 // The number of bytes that can fit in a buffer of kOutputSize.
 const size_t kMaxPayloadSize =
     kOutputSize - HttpStreamParser::kChunkHeaderFooterSize;
 
 // Helper method to create a connected ClientSocketHandle using |data|.
 // Modifies |data|.
 scoped_ptr<ClientSocketHandle> CreateConnectedSocketHandle(
-    DeterministicSocketData* data) {
+    SequencedSocketData* data) {
   data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
 
-  scoped_ptr<DeterministicMockTCPClientSocket> transport(
-      new DeterministicMockTCPClientSocket(nullptr, data));
-  data->set_delegate(transport->AsWeakPtr());
+  scoped_ptr<MockTCPClientSocket> socket(
+      new MockTCPClientSocket(net::AddressList(), nullptr, data));
+  data->set_socket(socket.get());
 
   TestCompletionCallback callback;
-  EXPECT_EQ(OK, transport->Connect(callback.callback()));
+  EXPECT_EQ(OK, socket->Connect(callback.callback()));
 
   scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
-  socket_handle->SetSocket(transport.Pass());
+  socket_handle->SetSocket(socket.Pass());
   return socket_handle.Pass();
 }
 
 // The empty payload is how the last chunk is encoded.
 TEST(HttpStreamParser, EncodeChunk_EmptyPayload) {
   char output[kOutputSize];
 
   const base::StringPiece kPayload = "";
   const base::StringPiece kExpected = "0\r\n\r\n";
   const int num_bytes_written =
@@ skipping 154 matching lines @@
   MockRead reads[] = {
       MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
 
-  DeterministicSocketData data(reads, arraysize(reads), writes,
-                               arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   scoped_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
-  // Complete the initial request write.
-  data.RunFor(1);
+  // Complete the initial request write.  Callback should not have been invoked.
+  base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
-  // Now append the only chunk.
+  // Now append the only chunk and wait for the callback.
   upload_stream.AppendData(kChunk, arraysize(kChunk) - 1, true);
-  // Write the chunk.
-  data.RunFor(1);
-  ASSERT_FALSE(callback.have_result());
-
-  // Write the trailer.
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Attempt to read the response status and the response headers.
   ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_GT(callback.WaitForResult(), 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when sending a request with a chunked body with only one chunk that is
 // available synchronously.
 TEST(HttpStreamParser, SyncSingleChunkAndAsyncSocket) {
   static const char kChunk[] = "Chunk";
 
   MockWrite writes[] = {
@@ skipping 13 matching lines @@
       MockRead(ASYNC, 4, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 5, "one.html"),
       MockRead(SYNCHRONOUS, 0, 6),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
   // Append the only chunk.
   upload_stream.AppendData(kChunk, arraysize(kChunk) - 1, true);
 
-  DeterministicSocketData data(reads, arraysize(reads), writes,
-                               arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   scoped_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
-
-  // Write the request and the only chunk.
-  data.RunFor(2);
-
-  // Write the trailer.
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Attempt to read the response status and the response headers.
   ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_GT(callback.WaitForResult(), 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when sending a request with a chunked body, where chunks become available
 // asynchronously, over a socket where writes may also complete
 // asynchronously.
 // This is a regression test for http://crbug.com/132243
 TEST(HttpStreamParser, AsyncChunkAndAsyncSocketWithMultipleChunks) {
   // The chunks that will be written in the request, as reflected in the
@@ skipping 20 matching lines @@
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 6, "Content-Length: 8\r\n\r\n"),
     MockRead(ASYNC, 7, "one.html"),
     MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   upload_stream.AppendData(kChunk1, arraysize(kChunk1) - 1, false);
   ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
 
-  DeterministicSocketData data(reads, arraysize(reads), writes,
-                               arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   scoped_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(
       socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
-
-  // Complete the initial request write. Additionally, this should enqueue the
-  // first chunk.
-  data.RunFor(1);
   ASSERT_FALSE(callback.have_result());
 
-  // Now append another chunk (while the first write is still pending), which
-  // should not confuse the state machine.
+  // Sending the request and the first chunk completes.
+  base::RunLoop().RunUntilIdle();
+  ASSERT_FALSE(callback.have_result());
+
+  // Now append another chunk.
   upload_stream.AppendData(kChunk2, arraysize(kChunk2) - 1, false);
   ASSERT_FALSE(callback.have_result());
 
-  // Complete writing the first chunk, which should then enqueue the second
-  // chunk for writing and return, because it is set to complete
-  // asynchronously.
-  data.RunFor(1);
-  ASSERT_FALSE(callback.have_result());
-
-  // Complete writing the second chunk. However, because no chunks are
-  // available yet, no further writes should be called until a new chunk is
-  // added.
-  data.RunFor(1);
-  ASSERT_FALSE(callback.have_result());
-
-  // Add the final chunk. This will enqueue another write, but it will not
-  // complete due to the async nature.
+  // Add the final chunk, while the write for the second is still pending,
+  // which should not confuse the state machine.
   upload_stream.AppendData(kChunk3, arraysize(kChunk3) - 1, true);
   ASSERT_FALSE(callback.have_result());
 
-  // Finalize writing the last chunk, which will enqueue the trailer.
-  data.RunFor(1);
-  ASSERT_FALSE(callback.have_result());
-
-  // Finalize writing the trailer.
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
+  // Wait for writes to complete.
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Attempt to read the response status and the response headers.
   ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_GT(callback.WaitForResult(), 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when there's only one "chunk" with 0 bytes, and is received from the
 // UploadStream only after sending the request headers successfully.
 TEST(HttpStreamParser, AsyncEmptyChunkedUpload) {
   MockWrite writes[] = {
       MockWrite(ASYNC, 0,
                 "GET /one.html HTTP/1.1\r\n"
                 "Transfer-Encoding: chunked\r\n\r\n"),
       MockWrite(ASYNC, 1, "0\r\n\r\n"),
   };
 
   // The size of the response body, as reflected in the Content-Length of the
   // MockRead below.
   const int kBodySize = 8;
 
   MockRead reads[] = {
       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
 
-  DeterministicSocketData data(reads, arraysize(reads), writes,
-                               arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   scoped_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
-  // Complete writing the request headers.
-  data.RunFor(1);
-  ASSERT_FALSE(callback.have_result());
-
   // Now append the terminal 0-byte "chunk".
   upload_stream.AppendData(nullptr, 0, true);
   ASSERT_FALSE(callback.have_result());
 
-  // Finalize writing the trailer.
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Attempt to read the response status and the response headers.
   ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_GT(callback.WaitForResult(), 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 }
 
 // Test to ensure the HttpStreamParser state machine does not get confused
 // when there's only one "chunk" with 0 bytes, which was already appended before
 // the request was started.
 TEST(HttpStreamParser, SyncEmptyChunkedUpload) {
   MockWrite writes[] = {
       MockWrite(ASYNC, 0,
                 "GET /one.html HTTP/1.1\r\n"
@@ skipping 10 matching lines @@
       MockRead(ASYNC, 3, "Content-Length: 8\r\n\r\n"),
       MockRead(ASYNC, 4, "one.html"),
       MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
   ChunkedUploadDataStream upload_stream(0);
   ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
   // Append final empty chunk.
   upload_stream.AppendData(nullptr, 0, true);
 
-  DeterministicSocketData data(reads, arraysize(reads), writes,
-                               arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   scoped_ptr<ClientSocketHandle> socket_handle =
       CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.upload_data_stream = &upload_stream;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), &request_info, read_buffer.get(),
                           BoundNetLog());
 
   HttpRequestHeaders request_headers;
   request_headers.SetHeader("Transfer-Encoding", "chunked");
 
   HttpResponseInfo response_info;
   TestCompletionCallback callback;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   ASSERT_EQ(ERR_IO_PENDING,
             parser.SendRequest("GET /one.html HTTP/1.1\r\n", request_headers,
                                &response_info, callback.callback()));
 
   // Complete writing the request headers and body.
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(OK, callback.WaitForResult());
 
   // Attempt to read the response status and the response headers.
   ASSERT_EQ(ERR_IO_PENDING, parser.ReadResponseHeaders(callback.callback()));
-  data.RunFor(2);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_GT(callback.WaitForResult(), 0);
 
   // Finally, attempt to read the response body.
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(ERR_IO_PENDING,
             parser.ReadResponseBody(body_buffer.get(), kBodySize,
                                     callback.callback()));
-  data.RunFor(1);
-  ASSERT_TRUE(callback.have_result());
   ASSERT_EQ(kBodySize, callback.WaitForResult());
 }
 
 TEST(HttpStreamParser, TruncatedHeaders) {
   MockRead truncated_status_reads[] = {
     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 20"),
     MockRead(SYNCHRONOUS, 0, 2),  // EOF
   };
 
   MockRead truncated_after_status_reads[] = {
@@ skipping 38 matching lines @@
     HTTP = 0,
     HTTPS,
     NUM_PROTOCOLS,
   };
 
   for (size_t protocol = 0; protocol < NUM_PROTOCOLS; protocol++) {
     SCOPED_TRACE(protocol);
 
     for (size_t i = 0; i < arraysize(reads); i++) {
       SCOPED_TRACE(i);
-      DeterministicSocketData data(reads[i], 2, writes, arraysize(writes));
-      data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
-      data.SetStop(3);
-
-      scoped_ptr<DeterministicMockTCPClientSocket> transport(
-          new DeterministicMockTCPClientSocket(NULL, &data));
-      data.set_delegate(transport->AsWeakPtr());
-
-      TestCompletionCallback callback;
-      int rv = transport->Connect(callback.callback());
-      ASSERT_EQ(OK, rv);
-
-      scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
-      socket_handle->SetSocket(transport.Pass());
+      SequencedSocketData data(reads[i], 2, writes, arraysize(writes));
+      scoped_ptr<ClientSocketHandle> socket_handle(
+          CreateConnectedSocketHandle(&data));
 
       HttpRequestInfo request_info;
       request_info.method = "GET";
       if (protocol == HTTP) {
         request_info.url = GURL("http://localhost");
       } else {
         request_info.url = GURL("https://localhost");
       }
       request_info.load_flags = LOAD_NORMAL;
 
       scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
       HttpStreamParser parser(
           socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
       HttpRequestHeaders request_headers;
       HttpResponseInfo response_info;
-      rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
-                              &response_info, callback.callback());
-      ASSERT_EQ(OK, rv);
+      TestCompletionCallback callback;
+      ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
+                                       &response_info, callback.callback()));
 
-      rv = parser.ReadResponseHeaders(callback.callback());
+      int rv = parser.ReadResponseHeaders(callback.callback());
       if (i == arraysize(reads) - 1) {
         EXPECT_EQ(OK, rv);
         EXPECT_TRUE(response_info.headers.get());
       } else {
         if (protocol == HTTP) {
           EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
           EXPECT_TRUE(response_info.headers.get());
         } else {
           EXPECT_EQ(ERR_RESPONSE_HEADERS_TRUNCATED, rv);
           EXPECT_FALSE(response_info.headers.get());
@@ skipping 12 matching lines @@
              "Upgrade: websocket\r\n"
              "Connection: Upgrade\r\n"
              "\r\n"
              "a fake websocket frame"),
   };
 
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n\r\n"),
   };
 
-  DeterministicSocketData data(reads, arraysize(reads),
-                               writes, arraysize(writes));
-  data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
-  data.SetStop(2);
-
-  scoped_ptr<DeterministicMockTCPClientSocket> transport(
-      new DeterministicMockTCPClientSocket(NULL, &data));
-  data.set_delegate(transport->AsWeakPtr());
-
-  TestCompletionCallback callback;
-  int rv = transport->Connect(callback.callback());
-  ASSERT_EQ(OK, rv);
-
-  scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
-  socket_handle->SetSocket(transport.Pass());
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://localhost");
   request_info.load_flags = LOAD_NORMAL;
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(
       socket_handle.get(), &request_info, read_buffer.get(), BoundNetLog());
 
   HttpRequestHeaders request_headers;
   HttpResponseInfo response_info;
-  rv = parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
-                          &response_info, callback.callback());
-  ASSERT_EQ(OK, rv);
+  TestCompletionCallback callback;
+  ASSERT_EQ(OK, parser.SendRequest("GET / HTTP/1.1\r\n", request_headers,
+                                   &response_info, callback.callback()));
 
-  rv = parser.ReadResponseHeaders(callback.callback());
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(OK, parser.ReadResponseHeaders(callback.callback()));
   ASSERT_TRUE(response_info.headers.get());
   EXPECT_EQ(101, response_info.headers->response_code());
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Connection", "Upgrade"));
   EXPECT_TRUE(response_info.headers->HasHeaderValue("Upgrade", "websocket"));
   EXPECT_EQ(read_buffer->capacity(), read_buffer->offset());
   EXPECT_EQ("a fake websocket frame",
             base::StringPiece(read_buffer->StartOfBuffer(),
                               read_buffer->capacity()));
 }
 
@@ skipping 17 matching lines @@
     read_buffer_->set_offset(offset + size);
   }
 
   void AddRead(const std::string& data) {
     reads_.push_back(MockRead(SYNCHRONOUS, sequence_number_++, data.data()));
   }
 
   void SetupParserAndSendRequest() {
     reads_.push_back(MockRead(SYNCHRONOUS, 0, sequence_number_++));  // EOF
 
-    socket_handle_.reset(new ClientSocketHandle);
-    data_.reset(new DeterministicSocketData(
-        &reads_.front(), reads_.size(), &writes_.front(), writes_.size()));
-    data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
-    data_->SetStop(reads_.size() + writes_.size());
-
-    transport_.reset(new DeterministicMockTCPClientSocket(NULL, data_.get()));
-    data_->set_delegate(transport_->AsWeakPtr());
-
-    TestCompletionCallback callback;
-    int rv = transport_->Connect(callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(OK, rv);
-
-    socket_handle_->SetSocket(transport_.Pass());
+    data_.reset(new SequencedSocketData(&reads_.front(), reads_.size(),
+                                        &writes_.front(), writes_.size()));
+    socket_handle_ = CreateConnectedSocketHandle(data_.get());
 
     request_info_.method = "GET";
     request_info_.url = GURL("http://localhost");
     request_info_.load_flags = LOAD_NORMAL;
 
     parser_.reset(new HttpStreamParser(
         socket_handle_.get(), &request_info_, read_buffer(), BoundNetLog()));
 
-    rv = parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
-                              &response_info_, callback.callback());
-    ASSERT_EQ(OK, rv);
+    TestCompletionCallback callback;
+    ASSERT_EQ(OK, parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
+                                       &response_info_, callback.callback()));
   }
 
   void ReadHeaders() {
     TestCompletionCallback callback;
     EXPECT_EQ(OK, parser_->ReadResponseHeaders(callback.callback()));
   }
 
   void ReadBody(int user_buf_len, int* read_lengths) {
     TestCompletionCallback callback;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(user_buf_len);
@@ skipping 10 matching lines @@
   }
 
  private:
   HttpRequestHeaders request_headers_;
   HttpResponseInfo response_info_;
   HttpRequestInfo request_info_;
   scoped_refptr<GrowableIOBuffer> read_buffer_;
   std::vector<MockRead> reads_;
   std::vector<MockWrite> writes_;
   scoped_ptr<ClientSocketHandle> socket_handle_;
-  scoped_ptr<DeterministicSocketData> data_;
-  scoped_ptr<DeterministicMockTCPClientSocket> transport_;
+  scoped_ptr<SequencedSocketData> data_;
   scoped_ptr<HttpStreamParser> parser_;
   int sequence_number_;
 };
 
 // Test that HTTP/0.9 response size is correctly calculated.
 TEST(HttpStreamParser, ReceivedBytesNoHeaders) {
   std::string response = "hello\r\nworld\r\n";
 
   SimpleGetRunner get_runner;
   get_runner.AddRead(response);
@@ skipping 218 matching lines @@
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
 }
 
 // Test that an HttpStreamParser can be read from after it's received headers
 // and data structures owned by its owner have been deleted.  This happens
 // when a ResponseBodyDrainer is used.
 TEST(HttpStreamParser, ReadAfterUnownedObjectsDestroyed) {
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0,
               "GET /foo.html HTTP/1.1\r\n\r\n"),
-    MockWrite(SYNCHRONOUS, 1, "1"),
   };
 
   const int kBodySize = 1;
   MockRead reads[] = {
-    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
-    MockRead(SYNCHRONOUS, 6, "Content-Length: 1\r\n\r\n"),
-    MockRead(SYNCHRONOUS, 6, "Connection: Keep-Alive\r\n\r\n"),
-    MockRead(SYNCHRONOUS, 7, "1"),
-    MockRead(SYNCHRONOUS, 0, 8),  // EOF
+      MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+      MockRead(SYNCHRONOUS, 2, "Content-Length: 1\r\n\r\n"),
+      MockRead(SYNCHRONOUS, 3, "Connection: Keep-Alive\r\n\r\n"),
+      MockRead(SYNCHRONOUS, 4, "1"),
+      MockRead(SYNCHRONOUS, 0, 5),  // EOF
   };
 
-  StaticSocketDataProvider data(reads, arraysize(reads), writes,
-                                arraysize(writes));
-  data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
-
-  scoped_ptr<MockTCPClientSocket> transport(
-      new MockTCPClientSocket(AddressList(), NULL, &data));
-
-  TestCompletionCallback callback;
-  ASSERT_EQ(OK, transport->Connect(callback.callback()));
-
-  scoped_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle);
-  socket_handle->SetSocket(transport.Pass());
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  scoped_ptr<ClientSocketHandle> socket_handle =
+      CreateConnectedSocketHandle(&data);
 
   scoped_ptr<HttpRequestInfo> request_info(new HttpRequestInfo());
   request_info->method = "GET";
   request_info->url = GURL("http://somewhere/foo.html");
 
   scoped_refptr<GrowableIOBuffer> read_buffer(new GrowableIOBuffer);
   HttpStreamParser parser(socket_handle.get(), request_info.get(),
                           read_buffer.get(), BoundNetLog());
 
   scoped_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
   scoped_ptr<HttpResponseInfo> response_info(new HttpResponseInfo());
+  TestCompletionCallback callback;
   ASSERT_EQ(OK, parser.SendRequest("GET /foo.html HTTP/1.1\r\n",
             *request_headers, response_info.get(), callback.callback()));
   ASSERT_EQ(OK, parser.ReadResponseHeaders(callback.callback()));
 
   // If the object that owns the HttpStreamParser is deleted, it takes the
   // objects passed to the HttpStreamParser with it.
   request_info.reset();
   request_headers.reset();
   response_info.reset();
 
   scoped_refptr<IOBuffer> body_buffer(new IOBuffer(kBodySize));
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 }
 
 }  // namespace
 
 }  // namespace net