There was confusion in the mock socket classes due to...

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2009 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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/completion_callback.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/ssl_config_service_defaults.h"
@@ skipping 85 matching lines @@
 
     SessionDependencies session_deps;
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(CreateSession(&session_deps)));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
-    StaticMockSocket data(data_reads, NULL);
-    session_deps.socket_factory.AddMockSocket(&data);
+    StaticSocketDataProvider data(data_reads, NULL);
+    session_deps.socket_factory.AddSocketDataProvider(&data);
 
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, &callback, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     out.rv = callback.WaitForResult();
     if (out.rv != OK)
       return out;
 
@@ skipping 247 matching lines @@
   };
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Server: Blah\r\n"),
     MockRead("Content-Length: 1234\r\n\r\n"),
 
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 23 matching lines @@
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session = CreateSession(&session_deps);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
     MockRead(false, OK),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
     HttpRequestInfo request;
     request.method = "GET";
@@ skipping 32 matching lines @@
   request.upload_data = new UploadData;
   request.upload_data->AppendBytes("foo", 3);
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 100 Continue\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 20 matching lines @@
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n"
              "HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 18 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data1_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     read_failure,  // Now, we reuse the connection and fail the first read.
   };
-  StaticMockSocket data1(data1_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data1_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   MockRead data2_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
     MockRead(true, OK),
   };
-  StaticMockSocket data2(data2_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  StaticSocketDataProvider data2(data2_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
@@ skipping 35 matching lines @@
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead(true, ERR_CONNECTION_RESET),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
     MockRead(false, OK),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 61 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 38 matching lines @@
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
     MockRead(false, ERR_FAILED),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_FALSE(response == NULL);
@@ skipping 32 matching lines @@
     MockRead("Content-Length: 14\r\n\r\n"),
     MockRead("Unauthorized\r\n"),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 55 matching lines @@
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 58 matching lines @@
     MockRead("Content-Length: 5134\r\n\r\n"),
     MockRead(true, large_body_string.data(), large_body_string.size()),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 60 matching lines @@
     MockRead("0123456789"),
 
     // Wrong credentials (wrong password).
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 59 matching lines @@
   };
 
   // The proxy responds to the connect with a 407.
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 30 matching lines @@
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     status,
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(expected_status, rv);
 }
 
@@ skipping 233 matching lines @@
   };
 
   // Lastly we get the desired content.
   MockRead data_reads3[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  StaticMockSocket data3(data_reads3, data_writes3);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
-  session_deps.socket_factory.AddMockSocket(&data3);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  StaticSocketDataProvider data3(data_reads3, data_writes3);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
+  session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 113 matching lines @@
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 146 matching lines @@
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  StaticMockSocket data3(data_reads3, data_writes3);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
-  session_deps.socket_factory.AddMockSocket(&data3);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  StaticSocketDataProvider data3(data_reads3, data_writes3);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
+  session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 72 matching lines @@
   // Respond with 300 kb of headers (we should fail after 256 kb).
   std::string large_headers_string;
   FillLargeHeadersString(&large_headers_string, 300 * 1024);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead(true, large_headers_string.data(), large_headers_string.size()),
     MockRead("\r\nBODY"),
     MockRead(false, OK),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 25 matching lines @@
 
   // The proxy responds to the connect with a 404, using a persistent
   // connection. Usually a proxy would return 501 (not implemented),
   // or 200 (tunnel established).
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 27 matching lines @@
   MockRead data_reads[] = {
     // A part of the response body is received with the response headers.
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\nhel"),
     // The rest of the response body is received in two parts.
     MockRead("lo"),
     MockRead(" world"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 35 matching lines @@
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n"
              "Content-Length: 0\r\n"
              "Content-Type: text/html\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 47 matching lines @@
     MockRead("hello world"),
     MockRead(false, OK),
   };
   // The mock write results of transaction 1 and the first attempt of
   // transaction 2.
   MockWrite data_writes1[] = {
     MockWrite(false, 64),  // GET
     MockWrite(false, 93),  // POST
     MockWrite(false, ERR_CONNECTION_ABORTED),  // POST data
   };
-  StaticMockSocket data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
 
   // The second socket is used for the second attempt of transaction 2.
 
   // The response of transaction 2.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 7\r\n\r\n"),
     MockRead("welcome"),
     MockRead(false, OK),
   };
   // The mock write results of the second attempt of transaction 2.
   MockWrite data_writes2[] = {
     MockWrite(false, 93),  // POST
     MockWrite(false, 3),  // POST data
   };
-  StaticMockSocket data2(data_reads2, data_writes2);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
 
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   const char* kExpectedResponseData[] = {
     "hello world", "welcome"
   };
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(session));
 
     TestCompletionCallback callback;
@@ skipping 57 matching lines @@
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJAcg==\r\n\r\n"),
   };
 
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 69 matching lines @@
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   MockRead data_reads3[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  StaticMockSocket data2(data_reads2, data_writes2);
-  StaticMockSocket data3(data_reads3, data_writes3);
-  session_deps.socket_factory.AddMockSocket(&data1);
-  session_deps.socket_factory.AddMockSocket(&data2);
-  session_deps.socket_factory.AddMockSocket(&data3);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  StaticSocketDataProvider data3(data_reads3, data_writes3);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
+  session_deps.socket_factory.AddSocketDataProvider(&data3);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 67 matching lines @@
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
-    StaticMockSocket data1(data_reads1, data_writes1);
-    StaticMockSocket data2(data_reads2, data_writes2);
-    session_deps.socket_factory.AddMockSocket(&data1);
-    session_deps.socket_factory.AddMockSocket(&data2);
+    StaticSocketDataProvider data1(data_reads1, data_writes1);
+    StaticSocketDataProvider data2(data_reads2, data_writes2);
+    session_deps.socket_factory.AddSocketDataProvider(&data1);
+    session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 59 matching lines @@
                 "Authorization: Basic Zm9vMjpiYXIy\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
-    StaticMockSocket data1(data_reads1, data_writes1);
-    StaticMockSocket data2(data_reads2, data_writes2);
-    session_deps.socket_factory.AddMockSocket(&data1);
-    session_deps.socket_factory.AddMockSocket(&data2);
+    StaticSocketDataProvider data1(data_reads1, data_writes1);
+    StaticSocketDataProvider data2(data_reads2, data_writes2);
+    session_deps.socket_factory.AddSocketDataProvider(&data1);
+    session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 42 matching lines @@
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the preemptive authorization
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
-    StaticMockSocket data1(data_reads1, data_writes1);
-    session_deps.socket_factory.AddMockSocket(&data1);
+    StaticSocketDataProvider data1(data_reads1, data_writes1);
+    session_deps.socket_factory.AddSocketDataProvider(&data1);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 36 matching lines @@
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
-    StaticMockSocket data1(data_reads1, data_writes1);
-    StaticMockSocket data2(data_reads2, data_writes2);
-    session_deps.socket_factory.AddMockSocket(&data1);
-    session_deps.socket_factory.AddMockSocket(&data2);
+    StaticSocketDataProvider data1(data_reads1, data_writes1);
+    StaticSocketDataProvider data2(data_reads2, data_writes2);
+    session_deps.socket_factory.AddSocketDataProvider(&data1);
+    session_deps.socket_factory.AddSocketDataProvider(&data2);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 60 matching lines @@
                 "Authorization: Basic Zm9vMzpiYXIz\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads3[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
-    StaticMockSocket data1(data_reads1, data_writes1);
-    StaticMockSocket data2(data_reads2, data_writes2);
-    StaticMockSocket data3(data_reads3, data_writes3);
-    session_deps.socket_factory.AddMockSocket(&data1);
-    session_deps.socket_factory.AddMockSocket(&data2);
-    session_deps.socket_factory.AddMockSocket(&data3);
+    StaticSocketDataProvider data1(data_reads1, data_writes1);
+    StaticSocketDataProvider data2(data_reads2, data_writes2);
+    StaticSocketDataProvider data3(data_reads3, data_writes3);
+    session_deps.socket_factory.AddSocketDataProvider(&data1);
+    session_deps.socket_factory.AddSocketDataProvider(&data2);
+    session_deps.socket_factory.AddSocketDataProvider(&data3);
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1, NULL);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
@@ skipping 91 matching lines @@
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket ssl_bad_certificate;
-  StaticMockSocket data(data_reads, data_writes);
-  MockSSLSocket ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
-  MockSSLSocket ssl(true, OK);
+  StaticSocketDataProvider ssl_bad_certificate;
+  StaticSocketDataProvider data(data_reads, data_writes);
+  SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
+  SSLSocketDataProvider ssl(true, OK);
 
-  session_deps.socket_factory.AddMockSocket(&ssl_bad_certificate);
-  session_deps.socket_factory.AddMockSocket(&data);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl_bad);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl);
+  session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
   rv = trans->RestartIgnoringLastError(&callback);
@@ skipping 39 matching lines @@
   };
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket ssl_bad_certificate(proxy_reads, proxy_writes);
-  StaticMockSocket data(data_reads, data_writes);
-  MockSSLSocket ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
-  MockSSLSocket ssl(true, OK);
+  StaticSocketDataProvider ssl_bad_certificate(proxy_reads, proxy_writes);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  SSLSocketDataProvider ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
+  SSLSocketDataProvider ssl(true, OK);
 
-  session_deps.socket_factory.AddMockSocket(&ssl_bad_certificate);
-  session_deps.socket_factory.AddMockSocket(&data);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl_bad);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl);
+  session_deps.socket_factory.AddSocketDataProvider(&ssl_bad_certificate);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_bad);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   for (int i = 0; i < 2; i++) {
     session_deps.socket_factory.ResetNextMockIndexes();
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(CreateSession(&session_deps)));
 
     int rv = trans->Start(&request, &callback, NULL);
@@ skipping 33 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 16 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 14 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 14 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 14 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 16 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 16 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 15 matching lines @@
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
@@ skipping 13 matching lines @@
   char read_buffer[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
 
   MockWrite data_writes[] = {
     MockWrite(true, write_buffer, arraysize(write_buffer)),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n")
   };
 
   MockRead data_reads[] = {
-    MockWrite(true, read_buffer, arraysize(read_buffer)),
+    MockRead(true, read_buffer, arraysize(read_buffer)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 30 matching lines @@
 
   MockRead data_reads[] = {
     MockWrite(true, reinterpret_cast<char*>(read_buffer),
               arraysize(read_buffer)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  MockSSLSocket ssl(true, OK);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl);
+  SSLSocketDataProvider ssl(true, OK);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 34 matching lines @@
 
   MockRead data_reads[] = {
     MockWrite(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
     MockWrite(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 35 matching lines @@
 
   MockRead data_reads[] = {
     MockWrite(true, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
     MockWrite(true, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
-  StaticMockSocket data(data_reads, data_writes);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, data_writes);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
-  MockSSLSocket ssl(true, OK);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl);
+  SSLSocketDataProvider ssl(true, OK);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 145 matching lines @@
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(&session_deps)));
 
   // Attach an observer to watch the host resolutions being made.
   session_deps.host_resolver->AddObserver(&resolution_observer);
 
   // Connect up a mock socket which will fail when reading.
   MockRead data_reads[] = {
     MockRead(false, ERR_FAILED),
   };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Issue a request, containing an HTTP referrer.
   HttpRequestInfo request;
   request.method = "GET";
   request.referrer = referrer;
   request.url = GURL("http://www.google.com/");
 
   // Run the request until it fails reading from the socket.
   TestCompletionCallback callback;
   int rv = trans->Start(&request, &callback, NULL);
@@ skipping 33 matching lines @@
   ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
   // we can tell if the next lookup hit the cache, or the "network".
   // (cache --> success, "network" --> failure).
   session_deps.host_resolver->rules()->AddSimulatedFailure("www.google.com");
 
   // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
   // first read -- this won't be reached as the host resolution will fail first.
   MockRead data_reads[] = { MockRead(false, ERR_UNEXPECTED) };
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = LOAD_BYPASS_CACHE;
   request.url = GURL("http://www.google.com/");
 
   // Run the request.
   TestCompletionCallback callback;
   rv = trans->Start(&request, &callback, NULL);
@@ skipping 11 matching lines @@
   scoped_refptr<HttpNetworkSession> session = CreateSession(&session_deps);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockWrite write_failure[] = {
     MockWrite(true, ERR_CONNECTION_RESET),
   };
-  StaticMockSocket data(NULL, write_failure);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(NULL, write_failure);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 }
 
 // Check that a connection closed after the start of the headers finishes ok.
 TEST_F(HttpNetworkTransactionTest, ConnectionClosedAfterStartOfHeaders) {
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session = CreateSession(&session_deps);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1."),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data(data_reads, NULL);
-  session_deps.socket_factory.AddMockSocket(&data);
+  StaticSocketDataProvider data(data_reads, NULL);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ skipping 31 matching lines @@
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 14\r\n\r\n"),
     MockRead("Unauth"),
     MockRead(true, ERR_CONNECTION_RESET),
   };
 
-  StaticMockSocket data1(data_reads1, data_writes1);
-  session_deps.socket_factory.AddMockSocket(&data1);
+  StaticSocketDataProvider data1(data_reads1, data_writes1);
+  session_deps.socket_factory.AddSocketDataProvider(&data1);
 
   // After calling trans->RestartWithAuth(), this is the request we should
   // be issuing -- the final header line contains the credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
-  StaticMockSocket data2(data_reads2, data_writes2);
-  session_deps.socket_factory.AddMockSocket(&data2);
+  StaticSocketDataProvider data2(data_reads2, data_writes2);
+  session_deps.socket_factory.AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 27 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockRead proxy_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\nExtra data"),
     MockRead(false, OK)
   };
 
-  StaticMockSocket data(proxy_reads, NULL);
-  MockSSLSocket ssl(true, OK);
+  StaticSocketDataProvider data(proxy_reads, NULL);
+  SSLSocketDataProvider ssl(true, OK);
 
-  session_deps.socket_factory.AddMockSocket(&data);
-  session_deps.socket_factory.AddMockSSLSocket(&ssl);
+  session_deps.socket_factory.AddSocketDataProvider(&data);
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   session_deps.socket_factory.ResetNextMockIndexes();
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(CreateSession(&session_deps)));
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 }
 
 }  // namespace net