Remove DeterministicSocketData, replacing it with SequencedSocketData.

DeterministicSocketData is dificult to debug, and does a number of weird
and unfortunate things, including using a weird way of spinning message
loops.  It also fails to keep tests honest - tests with bugs in some of
their set up code can still pass, which can reduce test coverage.

SequencedSocketData was written a while back to replace it.

This CL replaces all remaining uses of DeterministicSocketData (All for
HTTP/2 testing) with SequencedSocketData.

BUG=492684, 492688, 492691, 492697

Review URL: https://codereview.chromium.org/1538973003

Cr-Commit-Position: refs/heads/master@{#366262}

3 files changed, 0 insertions, 1363 deletions

diff --git a/net/socket/deterministic_socket_data_unittest.cc b/net/socket/deterministic_socket_data_unittest.cc
deleted file mode 100644
index 9a95e1e..0000000
--- a/net/socket/deterministic_socket_data_unittest.cc
+++ /dev/null
@@ -1,621 +0,0 @@
-// 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/socket/socket_test_util.h"
-
-#include <string.h>
-
-#include "base/memory/ref_counted.h"
-#include "testing/platform_test.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-//-----------------------------------------------------------------------------
-
-namespace {
-
-static const char kMsg1[] = "\0hello!\xff";
-static const int kLen1 = arraysize(kMsg1);
-static const char kMsg2[] = "\0a2345678\0";
-static const int kLen2 = arraysize(kMsg2);
-static const char kMsg3[] = "bye!";
-static const int kLen3 = arraysize(kMsg3);
-
-}  // anonymous namespace
-
-namespace net {
-
-class DeterministicSocketDataTest : public PlatformTest {
- public:
-  DeterministicSocketDataTest();
-
-  void TearDown() override;
-
-  void ReentrantReadCallback(int len, int rv);
-  void ReentrantWriteCallback(const char* data, int len, int rv);
-
- protected:
-  void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
-                  size_t writes_count);
-
-  void AssertSyncReadEquals(const char* data, int len);
-  void AssertAsyncReadEquals(const char* data, int len);
-  void AssertReadReturns(const char* data, int len, int rv);
-  void AssertReadBufferEquals(const char* data, int len);
-
-  void AssertSyncWriteEquals(const char* data, int len);
-  void AssertAsyncWriteEquals(const char* data, int len);
-  void AssertWriteReturns(const char* data, int len, int rv);
-
-  TestCompletionCallback read_callback_;
-  TestCompletionCallback write_callback_;
-  StreamSocket* sock_;
-  scoped_ptr<DeterministicSocketData> data_;
-
- private:
-  scoped_refptr<IOBuffer> read_buf_;
-  MockConnect connect_data_;
-
-  HostPortPair endpoint_;
-  scoped_refptr<TransportSocketParams> tcp_params_;
-  DeterministicMockClientSocketFactory socket_factory_;
-  MockTransportClientSocketPool socket_pool_;
-  ClientSocketHandle connection_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest);
-};
-
-DeterministicSocketDataTest::DeterministicSocketDataTest()
-    : sock_(NULL),
-      read_buf_(NULL),
-      connect_data_(SYNCHRONOUS, OK),
-      endpoint_("www.google.com", 443),
-      tcp_params_(new TransportSocketParams(
-          endpoint_,
-          false,
-          false,
-          OnHostResolutionCallback(),
-          TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
-      socket_pool_(10, 10, &socket_factory_) {
-}
-
-void DeterministicSocketDataTest::TearDown() {
-  // Empty the current queue.
-  base::MessageLoop::current()->RunUntilIdle();
-  PlatformTest::TearDown();
-}
-
-void DeterministicSocketDataTest::Initialize(MockRead* reads,
-                                           size_t reads_count,
-                                           MockWrite* writes,
-                                           size_t writes_count) {
-  data_.reset(new DeterministicSocketData(reads, reads_count,
-                                          writes, writes_count));
-  data_->set_connect_data(connect_data_);
-  socket_factory_.AddSocketDataProvider(data_.get());
-
-  // Perform the TCP connect
-  EXPECT_EQ(OK,
-            connection_.Init(endpoint_.ToString(),
-                tcp_params_,
-                LOWEST,
-                CompletionCallback(),
-                reinterpret_cast<TransportClientSocketPool*>(&socket_pool_),
-                BoundNetLog()));
-  sock_ = connection_.socket();
-}
-
-void DeterministicSocketDataTest::AssertSyncReadEquals(const char* data,
-                                                       int len) {
-  // Issue the read, which will complete immediately
-  AssertReadReturns(data, len, len);
-  AssertReadBufferEquals(data, len);
-}
-
-void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data,
-                                                        int len) {
-  // Issue the read, which will be completed asynchronously
-  AssertReadReturns(data, len, ERR_IO_PENDING);
-
-  EXPECT_FALSE(read_callback_.have_result());
-  EXPECT_TRUE(sock_->IsConnected());
-  data_->RunFor(1);  // Runs 1 step, to cause the callbacks to be invoked
-
-  // Now the read should complete
-  ASSERT_EQ(len, read_callback_.WaitForResult());
-  AssertReadBufferEquals(data, len);
-}
-
-void DeterministicSocketDataTest::AssertReadReturns(const char* data,
-                                                    int len, int rv) {
-  read_buf_ = new IOBuffer(len);
-  ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback()));
-}
-
-void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
-                                                         int len) {
-  ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
-}
-
-void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data,
-                                                         int len) {
-  scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  memcpy(buf->data(), data, len);
-
-  // Issue the write, which will complete immediately
-  ASSERT_EQ(len, sock_->Write(buf.get(), len, write_callback_.callback()));
-}
-
-void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data,
-                                                         int len) {
-  // Issue the read, which will be completed asynchronously
-  AssertWriteReturns(data, len, ERR_IO_PENDING);
-
-  EXPECT_FALSE(read_callback_.have_result());
-  EXPECT_TRUE(sock_->IsConnected());
-  data_->RunFor(1);  // Runs 1 step, to cause the callbacks to be invoked
-
-  ASSERT_EQ(len, write_callback_.WaitForResult());
-}
-
-void DeterministicSocketDataTest::AssertWriteReturns(const char* data,
-                                                     int len, int rv) {
-  scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  memcpy(buf->data(), data, len);
-
-  // Issue the read, which will complete asynchronously
-  ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback()));
-}
-
-void DeterministicSocketDataTest::ReentrantReadCallback(int len, int rv) {
-  scoped_refptr<IOBuffer> read_buf(new IOBuffer(len));
-  EXPECT_EQ(len,
-            sock_->Read(
-                read_buf.get(),
-                len,
-                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                           base::Unretained(this),
-                           len)));
-}
-
-void DeterministicSocketDataTest::ReentrantWriteCallback(
-    const char* data, int len, int rv) {
-  scoped_refptr<IOBuffer> write_buf(new IOBuffer(len));
-  memcpy(write_buf->data(), data, len);
-  EXPECT_EQ(len,
-            sock_->Write(
-                write_buf.get(),
-                len,
-                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                           base::Unretained(this),
-                           data,
-                           len)));
-}
-
-// ----------- Read
-
-TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) {
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(SYNCHRONOUS, 0, 1),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  data_->SetStopped(true);
-  AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) {
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 1),  // Sync Read
-    MockRead(SYNCHRONOUS, 0, 2),  // EOF
-  };
-
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, 0, 0)
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  data_->StopAfter(2);
-  ASSERT_FALSE(data_->stopped());
-  AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleSyncRead) {
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(SYNCHRONOUS, 0, 1),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-  // Make sure we don't stop before we've read all the data
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MultipleSyncReads) {
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg3, kLen3, 3),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg3, kLen3, 5),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Read
-    MockRead(SYNCHRONOUS, 0, 7),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  // Make sure we don't stop before we've read all the data
-  data_->StopAfter(10);
-  AssertSyncReadEquals(kMsg1, kLen1);
-  AssertSyncReadEquals(kMsg2, kLen2);
-  AssertSyncReadEquals(kMsg3, kLen3);
-  AssertSyncReadEquals(kMsg3, kLen3);
-  AssertSyncReadEquals(kMsg2, kLen2);
-  AssertSyncReadEquals(kMsg3, kLen3);
-  AssertSyncReadEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleAsyncRead) {
-  MockRead reads[] = {
-    MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
-    MockRead(SYNCHRONOUS, 0, 1),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  AssertAsyncReadEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) {
-  MockRead reads[] = {
-      MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
-      MockRead(ASYNC, kMsg2, kLen2, 1),  // Async Read
-      MockRead(ASYNC, kMsg3, kLen3, 2),  // Async Read
-      MockRead(ASYNC, kMsg3, kLen3, 3),  // Async Read
-      MockRead(ASYNC, kMsg2, kLen2, 4),  // Async Read
-      MockRead(ASYNC, kMsg3, kLen3, 5),  // Async Read
-      MockRead(ASYNC, kMsg1, kLen1, 6),  // Async Read
-      MockRead(SYNCHRONOUS, 0, 7),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  AssertAsyncReadEquals(kMsg1, kLen1);
-  AssertAsyncReadEquals(kMsg2, kLen2);
-  AssertAsyncReadEquals(kMsg3, kLen3);
-  AssertAsyncReadEquals(kMsg3, kLen3);
-  AssertAsyncReadEquals(kMsg2, kLen2);
-  AssertAsyncReadEquals(kMsg3, kLen3);
-  AssertAsyncReadEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MixedReads) {
-  MockRead reads[] = {
-      MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-      MockRead(ASYNC, kMsg2, kLen2, 1),   // Async Read
-      MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Read
-      MockRead(ASYNC, kMsg3, kLen3, 3),   // Async Read
-      MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Read
-      MockRead(ASYNC, kMsg3, kLen3, 5),   // Async Read
-      MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Read
-      MockRead(SYNCHRONOUS, 0, 7),  // EOF
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-  AssertAsyncReadEquals(kMsg2, kLen2);
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg3, kLen3);
-  AssertAsyncReadEquals(kMsg3, kLen3);
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg2, kLen2);
-  AssertAsyncReadEquals(kMsg3, kLen3);
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, SyncReadFromCompletionCallback) {
-  MockRead reads[] = {
-      MockRead(ASYNC, kMsg1, kLen1, 0),   // Async Read
-      MockRead(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Read
-  };
-
-  Initialize(reads, arraysize(reads), NULL, 0);
-
-  data_->StopAfter(2);
-
-  scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Read(
-                read_buf.get(),
-                kLen1,
-                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                           base::Unretained(this),
-                           kLen2)));
-  data_->Run();
-}
-
-// ----------- Write
-
-TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) {
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  data_->SetStopped(true);
-  AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) {
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1),  // Sync Write
-  };
-
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, 0, 0)
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  data_->StopAfter(2);
-  ASSERT_FALSE(data_->stopped());
-  AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleSyncWrite) {
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  // Make sure we don't stop before we've read all the data
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) {
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  // Make sure we don't stop before we've read all the data
-  data_->StopAfter(10);
-  AssertSyncWriteEquals(kMsg1, kLen1);
-  AssertSyncWriteEquals(kMsg2, kLen2);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-  AssertSyncWriteEquals(kMsg2, kLen2);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-  AssertSyncWriteEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) {
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg1, kLen1, 0),  // Async Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  AssertAsyncWriteEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) {
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg1, kLen1, 0),  // Async Write
-    MockWrite(ASYNC, kMsg2, kLen2, 1),  // Async Write
-    MockWrite(ASYNC, kMsg3, kLen3, 2),  // Async Write
-    MockWrite(ASYNC, kMsg3, kLen3, 3),  // Async Write
-    MockWrite(ASYNC, kMsg2, kLen2, 4),  // Async Write
-    MockWrite(ASYNC, kMsg3, kLen3, 5),  // Async Write
-    MockWrite(ASYNC, kMsg1, kLen1, 6),  // Async Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  AssertAsyncWriteEquals(kMsg1, kLen1);
-  AssertAsyncWriteEquals(kMsg2, kLen2);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  AssertAsyncWriteEquals(kMsg2, kLen2);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  AssertAsyncWriteEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, MixedWrites) {
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
-    MockWrite(ASYNC, kMsg2, kLen2, 1),   // Async Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
-    MockWrite(ASYNC, kMsg3, kLen3, 3),   // Async Write
-    MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Write
-    MockWrite(ASYNC, kMsg3, kLen3, 5),   // Async Write
-    MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg1, kLen1);
-  AssertAsyncWriteEquals(kMsg2, kLen2);
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg2, kLen2);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg1, kLen1);
-}
-
-TEST_F(DeterministicSocketDataTest, SyncWriteFromCompletionCallback) {
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg1, kLen1, 0),   // Async Write
-    MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Write
-  };
-
-  Initialize(NULL, 0, writes, arraysize(writes));
-
-  data_->StopAfter(2);
-
-  scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
-  memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Write(
-                write_buf.get(),
-                kLen1,
-                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                           base::Unretained(this),
-                           kMsg2,
-                           kLen2)));
-  data_->Run();
-}
-
-// ----------- Mixed Reads and Writes
-
-TEST_F(DeterministicSocketDataTest, MixedSyncOperations) {
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(SYNCHRONOUS, kMsg2, kLen2, 3),  // Sync Read
-    MockRead(SYNCHRONOUS, 0, 4),  // EOF
-  };
-
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  // Make sure we don't stop before we've read/written everything
-  data_->StopAfter(10);
-  AssertSyncReadEquals(kMsg1, kLen1);
-  AssertSyncWriteEquals(kMsg2, kLen2);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-  AssertSyncReadEquals(kMsg2, kLen2);
-}
-
-TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) {
-  MockRead reads[] = {
-    MockRead(ASYNC, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(ASYNC, kMsg2, kLen2, 3),  // Sync Read
-    MockRead(ASYNC, 0, 4),  // EOF
-  };
-
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg2, kLen2, 1),  // Sync Write
-    MockWrite(ASYNC, kMsg3, kLen3, 2),  // Sync Write
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  AssertAsyncReadEquals(kMsg1, kLen1);
-  AssertAsyncWriteEquals(kMsg2, kLen2);
-  AssertAsyncWriteEquals(kMsg3, kLen3);
-  AssertAsyncReadEquals(kMsg2, kLen2);
-}
-
-TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) {
-  // Order of completion is read, write, write, read
-  MockRead reads[] = {
-    MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
-    MockRead(ASYNC, kMsg2, kLen2, 3),  // Async Read
-    MockRead(ASYNC, 0, 4),  // EOF
-  };
-
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg2, kLen2, 1),  // Async Write
-    MockWrite(ASYNC, kMsg3, kLen3, 2),  // Async Write
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  // Issue the write, which will block until the read completes
-  AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
-
-  // Issue the read which will return first
-  AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING);
-
-  data_->RunFor(1);
-  ASSERT_TRUE(read_callback_.have_result());
-  ASSERT_EQ(kLen1, read_callback_.WaitForResult());
-  AssertReadBufferEquals(kMsg1, kLen1);
-
-  data_->RunFor(1);
-  ASSERT_TRUE(write_callback_.have_result());
-  ASSERT_EQ(kLen2, write_callback_.WaitForResult());
-
-  data_->StopAfter(1);
-  // Issue the read, which will block until the write completes
-  AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
-
-  // Issue the writes which will return first
-  AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
-
-  data_->RunFor(1);
-  ASSERT_TRUE(write_callback_.have_result());
-  ASSERT_EQ(kLen3, write_callback_.WaitForResult());
-
-  data_->RunFor(1);
-  ASSERT_TRUE(read_callback_.have_result());
-  ASSERT_EQ(kLen2, read_callback_.WaitForResult());
-  AssertReadBufferEquals(kMsg2, kLen2);
-}
-
-TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) {
-  // Order of completion is read, write, write, read
-  MockRead reads[] = {
-    MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
-    MockRead(ASYNC, kMsg2, kLen2, 3),   // Async Read
-    MockRead(SYNCHRONOUS, 0, 4),  // EOF
-  };
-
-  MockWrite writes[] = {
-    MockWrite(ASYNC, kMsg2, kLen2, 1),   // Async Write
-    MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
-  };
-
-  Initialize(reads, arraysize(reads), writes, arraysize(writes));
-
-  // Issue the write, which will block until the read completes
-  AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
-
-  // Issue the writes which will complete immediately
-  data_->StopAfter(1);
-  AssertSyncReadEquals(kMsg1, kLen1);
-
-  data_->RunFor(1);
-  ASSERT_TRUE(write_callback_.have_result());
-  ASSERT_EQ(kLen2, write_callback_.WaitForResult());
-
-  // Issue the read, which will block until the write completes
-  AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
-
-  // Issue the writes which will complete immediately
-  data_->StopAfter(1);
-  AssertSyncWriteEquals(kMsg3, kLen3);
-
-  data_->RunFor(1);
-  ASSERT_TRUE(read_callback_.have_result());
-  ASSERT_EQ(kLen2, read_callback_.WaitForResult());
-  AssertReadBufferEquals(kMsg2, kLen2);
-}
-
-}  // namespace net
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 0d44135..b9771ce 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -679,210 +679,6 @@ void SequencedSocketData::OnWriteComplete() {
 SequencedSocketData::~SequencedSocketData() {
 }
 
-DeterministicSocketData::DeterministicSocketData(MockRead* reads,
-                                                 size_t reads_count,
-                                                 MockWrite* writes,
-                                                 size_t writes_count)
-    : helper_(reads, reads_count, writes, writes_count),
-      sequence_number_(0),
-      current_read_(),
-      current_write_(),
-      stopping_sequence_number_(0),
-      stopped_(false),
-      print_debug_(false),
-      is_running_(false) {
-  VerifyCorrectSequenceNumbers(reads, reads_count, writes, writes_count);
-}
-
-DeterministicSocketData::~DeterministicSocketData() {}
-
-void DeterministicSocketData::Run() {
-  DCHECK(!is_running_);
-  is_running_ = true;
-
-  SetStopped(false);
-  int counter = 0;
-  // Continue to consume data until all data has run out, or the stopped_ flag
-  // has been set. Consuming data requires two separate operations -- running
-  // the tasks in the message loop, and explicitly invoking the read/write
-  // callbacks (simulating network I/O). We check our conditions between each,
-  // since they can change in either.
-  while ((!AllWriteDataConsumed() || !AllReadDataConsumed()) && !stopped()) {
-    if (counter % 2 == 0)
-      base::RunLoop().RunUntilIdle();
-    if (counter % 2 == 1) {
-      InvokeCallbacks();
-    }
-    counter++;
-  }
-  // We're done consuming new data, but it is possible there are still some
-  // pending callbacks which we expect to complete before returning.
-  while (delegate_.get() &&
-         (delegate_->WritePending() || delegate_->ReadPending()) &&
-         !stopped()) {
-    InvokeCallbacks();
-    base::RunLoop().RunUntilIdle();
-  }
-  SetStopped(false);
-  is_running_ = false;
-}
-
-void DeterministicSocketData::RunFor(int steps) {
-  StopAfter(steps);
-  Run();
-}
-
-void DeterministicSocketData::SetStop(int seq) {
-  DCHECK_LT(sequence_number_, seq);
-  stopping_sequence_number_ = seq;
-  stopped_ = false;
-}
-
-void DeterministicSocketData::StopAfter(int seq) {
-  SetStop(sequence_number_ + seq);
-}
-
-MockRead DeterministicSocketData::OnRead() {
-  current_read_ = helper_.PeekRead();
-
-  // Synchronous read while stopped is an error
-  if (stopped() && current_read_.mode == SYNCHRONOUS) {
-    LOG(ERROR) << "Unable to perform synchronous IO while stopped";
-    return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
-  }
-
-  // Async read which will be called back in a future step.
-  if (sequence_number_ < current_read_.sequence_number) {
-    NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": I/O Pending";
-    MockRead result = MockRead(SYNCHRONOUS, ERR_IO_PENDING);
-    if (current_read_.mode == SYNCHRONOUS) {
-      LOG(ERROR) << "Unable to perform synchronous read: "
-          << current_read_.sequence_number
-          << " at stage: " << sequence_number_;
-      result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
-    }
-    if (print_debug_)
-      DumpMockReadWrite(result);
-    return result;
-  }
-
-  NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": Read "
-                         << helper_.read_index();
-  if (print_debug_)
-    DumpMockReadWrite(current_read_);
-
-  // Increment the sequence number if IO is complete
-  if (current_read_.mode == SYNCHRONOUS)
-    NextStep();
-
-  DCHECK_NE(ERR_IO_PENDING, current_read_.result);
-
-  helper_.AdvanceRead();
-  return current_read_;
-}
-
-MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) {
-  const MockWrite& next_write = helper_.PeekWrite();
-  current_write_ = next_write;
-
-  // Synchronous write while stopped is an error
-  if (stopped() && next_write.mode == SYNCHRONOUS) {
-    LOG(ERROR) << "Unable to perform synchronous IO while stopped";
-    return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
-  }
-
-  // Async write which will be called back in a future step.
-  if (sequence_number_ < next_write.sequence_number) {
-    NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": I/O Pending";
-    if (next_write.mode == SYNCHRONOUS) {
-      LOG(ERROR) << "Unable to perform synchronous write: "
-          << next_write.sequence_number << " at stage: " << sequence_number_;
-      return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
-    }
-  } else {
-    NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": Write "
-                           << helper_.write_index();
-  }
-
-  if (print_debug_)
-    DumpMockReadWrite(next_write);
-
-  // Move to the next step if I/O is synchronous, since the operation will
-  // complete when this method returns.
-  if (next_write.mode == SYNCHRONOUS)
-    NextStep();
-
-  // Check that what we are writing matches the expectation.
-  // Then give the mocked return value.
-  if (!helper_.VerifyWriteData(data))
-    return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
-
-  helper_.AdvanceWrite();
-
-  // In the case that the write was successful, return the number of bytes
-  // written. Otherwise return the error code.
-  int result =
-      next_write.result == OK ? next_write.data_len : next_write.result;
-  return MockWriteResult(next_write.mode, result);
-}
-
-bool DeterministicSocketData::AllReadDataConsumed() const {
-  return helper_.AllReadDataConsumed();
-}
-
-bool DeterministicSocketData::AllWriteDataConsumed() const {
-  return helper_.AllWriteDataConsumed();
-}
-
-void DeterministicSocketData::InvokeCallbacks() {
-  if (delegate_.get() && delegate_->WritePending() &&
-      (current_write().sequence_number == sequence_number())) {
-    NextStep();
-    delegate_->CompleteWrite();
-    return;
-  }
-  if (delegate_.get() && delegate_->ReadPending() &&
-      (current_read().sequence_number == sequence_number())) {
-    NextStep();
-    delegate_->CompleteRead();
-    return;
-  }
-}
-
-void DeterministicSocketData::NextStep() {
-  // Invariant: Can never move *past* the stopping step.
-  DCHECK_LT(sequence_number_, stopping_sequence_number_);
-  sequence_number_++;
-  if (sequence_number_ == stopping_sequence_number_)
-    SetStopped(true);
-}
-
-void DeterministicSocketData::VerifyCorrectSequenceNumbers(
-    MockRead* reads, size_t reads_count,
-    MockWrite* writes, size_t writes_count) {
-  size_t read = 0;
-  size_t write = 0;
-  int expected = 0;
-  while (read < reads_count || write < writes_count) {
-    // Check to see that we have a read or write at the expected
-    // state.
-    if (read < reads_count  && reads[read].sequence_number == expected) {
-      ++read;
-      ++expected;
-      continue;
-    }
-    if (write < writes_count && writes[write].sequence_number == expected) {
-      ++write;
-      ++expected;
-      continue;
-    }
-    NOTREACHED() << "Missing sequence number: " << expected;
-    return;
-  }
-  DCHECK_EQ(read, reads_count);
-  DCHECK_EQ(write, writes_count);
-}
-
 MockClientSocketFactory::MockClientSocketFactory() {}
 
 MockClientSocketFactory::~MockClientSocketFactory() {}
@@ -1316,198 +1112,6 @@ int MockTCPClientSocket::CompleteRead() {
   return result;
 }
 
-DeterministicSocketHelper::DeterministicSocketHelper(
-    NetLog* net_log,
-    DeterministicSocketData* data)
-    : write_pending_(false),
-      write_result_(0),
-      read_data_(),
-      read_buf_(NULL),
-      read_buf_len_(0),
-      read_pending_(false),
-      data_(data),
-      was_used_to_convey_data_(false),
-      peer_closed_connection_(false),
-      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_NONE)) {
-}
-
-DeterministicSocketHelper::~DeterministicSocketHelper() {}
-
-void DeterministicSocketHelper::CompleteWrite() {
-  was_used_to_convey_data_ = true;
-  write_pending_ = false;
-  write_callback_.Run(write_result_);
-}
-
-int DeterministicSocketHelper::CompleteRead() {
-  DCHECK_GT(read_buf_len_, 0);
-  DCHECK_LE(read_data_.data_len, read_buf_len_);
-  DCHECK(read_buf_);
-
-  was_used_to_convey_data_ = true;
-
-  if (read_data_.result == ERR_IO_PENDING)
-    read_data_ = data_->OnRead();
-  DCHECK_NE(ERR_IO_PENDING, read_data_.result);
-  // If read_data_.mode is ASYNC, we do not need to wait, since this is already
-  // the callback. Therefore we don't even bother to check it.
-  int result = read_data_.result;
-
-  if (read_data_.data_len > 0) {
-    DCHECK(read_data_.data);
-    result = std::min(read_buf_len_, read_data_.data_len);
-    memcpy(read_buf_->data(), read_data_.data, result);
-  }
-
-  if (read_pending_) {
-    read_pending_ = false;
-    read_callback_.Run(result);
-  }
-
-  return result;
-}
-
-int DeterministicSocketHelper::Write(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
-  DCHECK(buf);
-  DCHECK_GT(buf_len, 0);
-
-  std::string data(buf->data(), buf_len);
-  MockWriteResult write_result = data_->OnWrite(data);
-
-  if (write_result.mode == ASYNC) {
-    write_callback_ = callback;
-    write_result_ = write_result.result;
-    DCHECK(!write_callback_.is_null());
-    write_pending_ = true;
-    return ERR_IO_PENDING;
-  }
-
-  was_used_to_convey_data_ = true;
-  write_pending_ = false;
-  return write_result.result;
-}
-
-int DeterministicSocketHelper::Read(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
-  read_data_ = data_->OnRead();
-  // The buffer should always be big enough to contain all the MockRead data. To
-  // use small buffers, split the data into multiple MockReads.
-  DCHECK_LE(read_data_.data_len, buf_len);
-
-  if (read_data_.result == ERR_CONNECTION_CLOSED) {
-    // This MockRead is just a marker to instruct us to set
-    // peer_closed_connection_.
-    peer_closed_connection_ = true;
-  }
-  if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
-    // This MockRead is just a marker to instruct us to set
-    // peer_closed_connection_.  Skip it and get the next one.
-    read_data_ = data_->OnRead();
-    peer_closed_connection_ = true;
-  }
-
-  read_buf_ = buf;
-  read_buf_len_ = buf_len;
-  read_callback_ = callback;
-
-  if (read_data_.mode == ASYNC || (read_data_.result == ERR_IO_PENDING)) {
-    read_pending_ = true;
-    DCHECK(!read_callback_.is_null());
-    return ERR_IO_PENDING;
-  }
-
-  was_used_to_convey_data_ = true;
-  return CompleteRead();
-}
-
-DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
-    net::NetLog* net_log,
-    DeterministicSocketData* data)
-    : MockClientSocket(BoundNetLog::Make(net_log, NetLog::SOURCE_NONE)),
-      helper_(net_log, data) {
-  peer_addr_ = data->connect_data().peer_addr;
-}
-
-DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
-
-bool DeterministicMockTCPClientSocket::WritePending() const {
-  return helper_.write_pending();
-}
-
-bool DeterministicMockTCPClientSocket::ReadPending() const {
-  return helper_.read_pending();
-}
-
-void DeterministicMockTCPClientSocket::CompleteWrite() {
-  helper_.CompleteWrite();
-}
-
-int DeterministicMockTCPClientSocket::CompleteRead() {
-  return helper_.CompleteRead();
-}
-
-int DeterministicMockTCPClientSocket::Write(
-    IOBuffer* buf,
-    int buf_len,
-    const CompletionCallback& callback) {
-  if (!connected_)
-    return ERR_UNEXPECTED;
-
-  return helper_.Write(buf, buf_len, callback);
-}
-
-int DeterministicMockTCPClientSocket::Read(
-    IOBuffer* buf,
-    int buf_len,
-    const CompletionCallback& callback) {
-  if (!connected_)
-    return ERR_UNEXPECTED;
-
-  return helper_.Read(buf, buf_len, callback);
-}
-
-// TODO(erikchen): Support connect sequencing.
-int DeterministicMockTCPClientSocket::Connect(
-    const CompletionCallback& callback) {
-  if (connected_)
-    return OK;
-  connected_ = true;
-  if (helper_.data()->connect_data().mode == ASYNC) {
-    RunCallbackAsync(callback, helper_.data()->connect_data().result);
-    return ERR_IO_PENDING;
-  }
-  return helper_.data()->connect_data().result;
-}
-
-void DeterministicMockTCPClientSocket::Disconnect() {
-  MockClientSocket::Disconnect();
-}
-
-bool DeterministicMockTCPClientSocket::IsConnected() const {
-  return connected_ && !helper_.peer_closed_connection();
-}
-
-bool DeterministicMockTCPClientSocket::IsConnectedAndIdle() const {
-  return IsConnected();
-}
-
-bool DeterministicMockTCPClientSocket::WasEverUsed() const {
-  return helper_.was_used_to_convey_data();
-}
-
-bool DeterministicMockTCPClientSocket::UsingTCPFastOpen() const {
-  return false;
-}
-
-bool DeterministicMockTCPClientSocket::WasNpnNegotiated() const {
-  return false;
-}
-
-bool DeterministicMockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
-  return false;
-}
-
 // static
 void MockSSLClientSocket::ConnectCallback(
     MockSSLClientSocket* ssl_client_socket,
@@ -2020,71 +1624,6 @@ void MockTransportClientSocketPool::ReleaseSocket(
   release_count_++;
 }
 
-DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {}
-
-DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {}
-
-void DeterministicMockClientSocketFactory::AddSocketDataProvider(
-    DeterministicSocketData* data) {
-  mock_data_.Add(data);
-}
-
-void DeterministicMockClientSocketFactory::AddSSLSocketDataProvider(
-    SSLSocketDataProvider* data) {
-  mock_ssl_data_.Add(data);
-}
-
-void DeterministicMockClientSocketFactory::ResetNextMockIndexes() {
-  mock_data_.ResetNextIndex();
-  mock_ssl_data_.ResetNextIndex();
-}
-
-MockSSLClientSocket* DeterministicMockClientSocketFactory::
-    GetMockSSLClientSocket(size_t index) const {
-  DCHECK_LT(index, ssl_client_sockets_.size());
-  return ssl_client_sockets_[index];
-}
-
-scoped_ptr<DatagramClientSocket>
-DeterministicMockClientSocketFactory::CreateDatagramClientSocket(
-    DatagramSocket::BindType bind_type,
-    const RandIntCallback& rand_int_cb,
-    NetLog* net_log,
-    const NetLog::Source& source) {
-  NOTREACHED();
-  return nullptr;
-}
-
-scoped_ptr<StreamSocket>
-DeterministicMockClientSocketFactory::CreateTransportClientSocket(
-    const AddressList& addresses,
-    NetLog* net_log,
-    const NetLog::Source& source) {
-  DeterministicSocketData* data_provider = mock_data().GetNext();
-  scoped_ptr<DeterministicMockTCPClientSocket> socket(
-      new DeterministicMockTCPClientSocket(net_log, data_provider));
-  data_provider->set_delegate(socket->AsWeakPtr());
-  tcp_client_sockets().push_back(socket.get());
-  return socket.Pass();
-}
-
-scoped_ptr<SSLClientSocket>
-DeterministicMockClientSocketFactory::CreateSSLClientSocket(
-    scoped_ptr<ClientSocketHandle> transport_socket,
-    const HostPortPair& host_and_port,
-    const SSLConfig& ssl_config,
-    const SSLClientSocketContext& context) {
-  scoped_ptr<MockSSLClientSocket> socket(
-      new MockSSLClientSocket(transport_socket.Pass(),
-                              host_and_port, ssl_config,
-                              mock_ssl_data_.GetNext()));
-  ssl_client_sockets_.push_back(socket.get());
-  return socket.Pass();
-}
-
-void DeterministicMockClientSocketFactory::ClearSSLSessionCache() {
-}
-
 MockSOCKSClientSocketPool::MockSOCKSClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index 73e73a0..c25221f 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -447,154 +447,6 @@ class SequencedSocketData : public SocketDataProvider {
   DISALLOW_COPY_AND_ASSIGN(SequencedSocketData);
 };
 
-class DeterministicMockTCPClientSocket;
-
-// This class gives the user full control over the network activity,
-// specifically the timing of the COMPLETION of I/O operations.  Regardless of
-// the order in which I/O operations are initiated, this class ensures that they
-// complete in the correct order.
-//
-// Network activity is modeled as a sequence of numbered steps which is
-// incremented whenever an I/O operation completes.  This can happen under two
-// different circumstances:
-//
-// 1) Performing a synchronous I/O operation.  (Invoking Read() or Write()
-//    when the corresponding MockRead or MockWrite is marked !async).
-// 2) Running the Run() method of this class.  The run method will invoke
-//    the current MessageLoop, running all pending events, and will then
-//    invoke any pending IO callbacks.
-//
-// In addition, this class allows for I/O processing to "stop" at a specified
-// step, by calling SetStop(int) or StopAfter(int).  Initiating an I/O operation
-// by calling Read() or Write() while stopped is permitted if the operation is
-// asynchronous.  It is an error to perform synchronous I/O while stopped.
-//
-// When creating the MockReads and MockWrites, note that the sequence number
-// refers to the number of the step in which the I/O will complete.  In the
-// case of synchronous I/O, this will be the same step as the I/O is initiated.
-// However, in the case of asynchronous I/O, this I/O may be initiated in
-// a much earlier step. Furthermore, when the a Read() or Write() is separated
-// from its completion by other Read() or Writes()'s, it can not be marked
-// synchronous.  If it is, ERR_UNUEXPECTED will be returned indicating that a
-// synchronous Read() or Write() could not be completed synchronously because of
-// the specific ordering constraints.
-//
-// Sequence numbers are preserved across both reads and writes. There should be
-// no gaps in sequence numbers, and no repeated sequence numbers. i.e.
-//  MockRead reads[] = {
-//    MockRead(false, "first read", length, 0)   // sync
-//    MockRead(true, "second read", length, 2)   // async
-//  };
-//  MockWrite writes[] = {
-//    MockWrite(true, "first write", length, 1),    // async
-//    MockWrite(false, "second write", length, 3),  // sync
-//  };
-//
-// Example control flow:
-// Read() is called.  The current step is 0.  The first available read is
-// synchronous, so the call to Read() returns length.  The current step is
-// now 1.  Next, Read() is called again.  The next available read can
-// not be completed until step 2, so Read() returns ERR_IO_PENDING.  The current
-// step is still 1.  Write is called().  The first available write is able to
-// complete in this step, but is marked asynchronous.  Write() returns
-// ERR_IO_PENDING.  The current step is still 1.  At this point RunFor(1) is
-// called which will cause the write callback to be invoked, and will then
-// stop.  The current state is now 2.  RunFor(1) is called again, which
-// causes the read callback to be invoked, and will then stop.  Then current
-// step is 2.  Write() is called again.  Then next available write is
-// synchronous so the call to Write() returns length.
-//
-// For examples of how to use this class, see:
-//   deterministic_socket_data_unittests.cc
-class DeterministicSocketData {
- public:
-  // The Delegate is an abstract interface which handles the communication from
-  // the DeterministicSocketData to the Deterministic MockSocket.  The
-  // MockSockets directly store a pointer to the DeterministicSocketData,
-  // whereas the DeterministicSocketData only stores a pointer to the
-  // abstract Delegate interface.
-  class Delegate {
-   public:
-    // Returns true if there is currently a write pending. That is to say, if
-    // an asynchronous write has been started but the callback has not been
-    // invoked.
-    virtual bool WritePending() const = 0;
-    // Returns true if there is currently a read pending. That is to say, if
-    // an asynchronous read has been started but the callback has not been
-    // invoked.
-    virtual bool ReadPending() const = 0;
-    // Called to complete an asynchronous write to execute the write callback.
-    virtual void CompleteWrite() = 0;
-    // Called to complete an asynchronous read to execute the read callback.
-    virtual int CompleteRead() = 0;
-
-   protected:
-    virtual ~Delegate() {}
-  };
-
-  // |reads| the list of MockRead completions.
-  // |writes| the list of MockWrite completions.
-  DeterministicSocketData(MockRead* reads,
-                          size_t reads_count,
-                          MockWrite* writes,
-                          size_t writes_count);
-  ~DeterministicSocketData();
-
-  // Consume all the data up to the give stop point (via SetStop()).
-  void Run();
-
-  // Set the stop point to be |steps| from now, and then invoke Run().
-  void RunFor(int steps);
-
-  // Stop at step |seq|, which must be in the future.
-  void SetStop(int seq);
-
-  // Stop |seq| steps after the current step.
-  void StopAfter(int seq);
-
-  bool stopped() const { return stopped_; }
-  void SetStopped(bool val) { stopped_ = val; }
-  MockRead& current_read() { return current_read_; }
-  MockWrite& current_write() { return current_write_; }
-  int sequence_number() const { return sequence_number_; }
-  void set_delegate(base::WeakPtr<Delegate> delegate) { delegate_ = delegate; }
-  MockConnect connect_data() const { return connect_; }
-  void set_connect_data(const MockConnect& connect) { connect_ = connect; }
-
-  // When the socket calls Read(), that calls OnRead(), and expects either
-  // ERR_IO_PENDING or data.
-  MockRead OnRead();
-
-  // When the socket calls Write(), it always completes synchronously. OnWrite()
-  // checks to make sure the written data matches the expected data. The
-  // callback will not be invoked until its sequence number is reached.
-  MockWriteResult OnWrite(const std::string& data);
-
-  bool AllReadDataConsumed() const;
-  bool AllWriteDataConsumed() const;
-
- private:
-  // Invoke the read and write callbacks, if the timing is appropriate.
-  void InvokeCallbacks();
-
-  void NextStep();
-
-  void VerifyCorrectSequenceNumbers(MockRead* reads,
-                                    size_t reads_count,
-                                    MockWrite* writes,
-                                    size_t writes_count);
-  StaticSocketDataHelper helper_;
-  MockConnect connect_;
-  int sequence_number_;
-  MockRead current_read_;
-  MockWrite current_write_;
-  int stopping_sequence_number_;
-  bool stopped_;
-  base::WeakPtr<Delegate> delegate_;
-  bool print_debug_;
-  bool is_running_;
-};
-
 // Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}StreamSocket
 // objects get instantiated, they take their data from the i'th element of this
 // array.
@@ -807,91 +659,6 @@ class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
   DISALLOW_COPY_AND_ASSIGN(MockTCPClientSocket);
 };
 
-// DeterministicSocketHelper is a helper class that can be used
-// to simulate Socket::Read() and Socket::Write()
-// using deterministic |data|.
-// Note: This is provided as a common helper class because
-// of the inheritance hierarchy of DeterministicMock[UDP,TCP]ClientSocket and a
-// desire not to introduce an additional common base class.
-class DeterministicSocketHelper {
- public:
-  DeterministicSocketHelper(NetLog* net_log, DeterministicSocketData* data);
-  virtual ~DeterministicSocketHelper();
-
-  bool write_pending() const { return write_pending_; }
-  bool read_pending() const { return read_pending_; }
-
-  void CompleteWrite();
-  int CompleteRead();
-
-  int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
-  int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
-
-  const BoundNetLog& net_log() const { return net_log_; }
-
-  bool was_used_to_convey_data() const { return was_used_to_convey_data_; }
-
-  bool peer_closed_connection() const { return peer_closed_connection_; }
-
-  DeterministicSocketData* data() const { return data_; }
-
- private:
-  bool write_pending_;
-  CompletionCallback write_callback_;
-  int write_result_;
-
-  MockRead read_data_;
-
-  IOBuffer* read_buf_;
-  int read_buf_len_;
-  bool read_pending_;
-  CompletionCallback read_callback_;
-  DeterministicSocketData* data_;
-  bool was_used_to_convey_data_;
-  bool peer_closed_connection_;
-  BoundNetLog net_log_;
-};
-
-// Mock TCP socket to be used in conjunction with DeterministicSocketData.
-class DeterministicMockTCPClientSocket
-    : public MockClientSocket,
-      public DeterministicSocketData::Delegate,
-      public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
- public:
-  DeterministicMockTCPClientSocket(net::NetLog* net_log,
-                                   DeterministicSocketData* data);
-  ~DeterministicMockTCPClientSocket() override;
-
-  // DeterministicSocketData::Delegate:
-  bool WritePending() const override;
-  bool ReadPending() const override;
-  void CompleteWrite() override;
-  int CompleteRead() override;
-
-  // Socket:
-  int Write(IOBuffer* buf,
-            int buf_len,
-            const CompletionCallback& callback) override;
-  int Read(IOBuffer* buf,
-           int buf_len,
-           const CompletionCallback& callback) override;
-
-  // StreamSocket:
-  int Connect(const CompletionCallback& callback) override;
-  void Disconnect() override;
-  bool IsConnected() const override;
-  bool IsConnectedAndIdle() const override;
-  bool WasEverUsed() const override;
-  bool UsingTCPFastOpen() const override;
-  bool WasNpnNegotiated() const override;
-  bool GetSSLInfo(SSLInfo* ssl_info) override;
-
- private:
-  DeterministicSocketHelper helper_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeterministicMockTCPClientSocket);
-};
-
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(scoped_ptr<ClientSocketHandle> transport_socket,
@@ -1164,54 +931,6 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
   DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketPool);
 };
 
-class DeterministicMockClientSocketFactory : public ClientSocketFactory {
- public:
-  DeterministicMockClientSocketFactory();
-  ~DeterministicMockClientSocketFactory() override;
-
-  void AddSocketDataProvider(DeterministicSocketData* socket);
-  void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
-  void ResetNextMockIndexes();
-
-  // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
-  // created.
-  MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
-
-  SocketDataProviderArray<DeterministicSocketData>& mock_data() {
-    return mock_data_;
-  }
-  std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
-    return tcp_client_sockets_;
-  }
-
-  // ClientSocketFactory
-  scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
-      DatagramSocket::BindType bind_type,
-      const RandIntCallback& rand_int_cb,
-      NetLog* net_log,
-      const NetLog::Source& source) override;
-  scoped_ptr<StreamSocket> CreateTransportClientSocket(
-      const AddressList& addresses,
-      NetLog* net_log,
-      const NetLog::Source& source) override;
-  scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
-      scoped_ptr<ClientSocketHandle> transport_socket,
-      const HostPortPair& host_and_port,
-      const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) override;
-  void ClearSSLSessionCache() override;
-
- private:
-  SocketDataProviderArray<DeterministicSocketData> mock_data_;
-  SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
-
-  // Store pointers to handed out sockets in case the test wants to get them.
-  std::vector<DeterministicMockTCPClientSocket*> tcp_client_sockets_;
-  std::vector<MockSSLClientSocket*> ssl_client_sockets_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeterministicMockClientSocketFactory);
-};
-
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
  public:
   MockSOCKSClientSocketPool(int max_sockets,