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

net/socket/socket_test_util.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 "net/socket/socket_test_util.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 44 matching lines @@
           &MockClientSocket::RunCallback, callback, result));
 }
 
 void MockClientSocket::RunCallback(net::CompletionCallback* callback,
                                    int result) {
   if (callback)
     callback->Run(result);
 }
 
 MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses,
-                                         net::MockSocket* socket)
+                                         net::SocketDataProvider* data)
     : addresses_(addresses),
-      data_(socket),
+      data_(data),
       read_offset_(0),
       read_data_(true, net::ERR_UNEXPECTED),
       need_read_data_(true) {
   DCHECK(data_);
   data_->Reset();
 }
 
 int MockTCPClientSocket::Connect(net::CompletionCallback* callback,
                                  LoadLog* load_log) {
   if (connected_)
@@ skipping 78 matching lines @@
 
   MockSSLClientSocket* ssl_client_socket_;
   net::CompletionCallback* user_callback_;
   int rv_;
 };
 
 MockSSLClientSocket::MockSSLClientSocket(
     net::ClientSocket* transport_socket,
     const std::string& hostname,
     const net::SSLConfig& ssl_config,
-    net::MockSSLSocket* socket)
+    net::SSLSocketDataProvider* data)
     : transport_(transport_socket),
-      data_(socket) {
+      data_(data) {
   DCHECK(data_);
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
 void MockSSLClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
   ssl_info->Reset();
 }
@@ skipping 25 matching lines @@
 int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* callback) {
   return transport_->Read(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* callback) {
   return transport_->Write(buf, buf_len, callback);
 }
 
-MockRead StaticMockSocket::GetNextRead() {
+MockRead StaticSocketDataProvider::GetNextRead() {
   return reads_[read_index_++];
 }
 
-MockWriteResult StaticMockSocket::OnWrite(const std::string& data) {
+MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(false, data.length());
   }
 
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
   net::MockWrite* w = &writes_[write_index_++];
   int result = w->result;
   if (w->data) {
     std::string expected_data(w->data, w->data_len);
     EXPECT_EQ(expected_data, data);
     if (expected_data != data)
       return MockWriteResult(false, net::ERR_UNEXPECTED);
     if (result == net::OK)
       result = w->data_len;
   }
   return MockWriteResult(w->async, result);
 }
 
-void StaticMockSocket::Reset() {
+void StaticSocketDataProvider::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
-DynamicMockSocket::DynamicMockSocket()
+DynamicSocketDataProvider::DynamicSocketDataProvider()
     : short_read_limit_(0),
       allow_unconsumed_reads_(false) {
 }
 
-MockRead DynamicMockSocket::GetNextRead() {
+MockRead DynamicSocketDataProvider::GetNextRead() {
   if (reads_.empty())
     return MockRead(true, ERR_UNEXPECTED);
   MockRead result = reads_.front();
   if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
     reads_.pop_front();
   } else {
     result.data_len = short_read_limit_;
     reads_.front().data += result.data_len;
     reads_.front().data_len -= result.data_len;
   }
   return result;
 }
 
-void DynamicMockSocket::Reset() {
+void DynamicSocketDataProvider::Reset() {
   reads_.clear();
 }
 
-void DynamicMockSocket::SimulateRead(const char* data) {
+void DynamicSocketDataProvider::SimulateRead(const char* data) {
   if (!allow_unconsumed_reads_) {
     EXPECT_TRUE(reads_.empty()) << "Unconsumed read: " << reads_.front().data;
   }
   reads_.push_back(MockRead(data));
 }
 
-void MockClientSocketFactory::AddMockSocket(MockSocket* socket) {
-  mock_sockets_.Add(socket);
+void MockClientSocketFactory::AddSocketDataProvider(
+    SocketDataProvider* data) {
+  mock_data_.Add(data);
 }
 
-void MockClientSocketFactory::AddMockSSLSocket(MockSSLSocket* socket) {
-  mock_ssl_sockets_.Add(socket);
+void MockClientSocketFactory::AddSSLSocketDataProvider(
+    SSLSocketDataProvider* data) {
+  mock_ssl_data_.Add(data);
 }
 
 void MockClientSocketFactory::ResetNextMockIndexes() {
-  mock_sockets_.ResetNextIndex();
-  mock_ssl_sockets_.ResetNextIndex();
+  mock_data_.ResetNextIndex();
+  mock_ssl_data_.ResetNextIndex();
 }
 
 MockTCPClientSocket* MockClientSocketFactory::GetMockTCPClientSocket(
     int index) const {
   return tcp_client_sockets_[index];
 }
 
 MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket(
     int index) const {
   return ssl_client_sockets_[index];
 }
 
 ClientSocket* MockClientSocketFactory::CreateTCPClientSocket(
     const AddressList& addresses) {
   MockTCPClientSocket* socket =
-      new MockTCPClientSocket(addresses, mock_sockets_.GetNext());
+      new MockTCPClientSocket(addresses, mock_data_.GetNext());
   tcp_client_sockets_.push_back(socket);
   return socket;
 }
 
 SSLClientSocket* MockClientSocketFactory::CreateSSLClientSocket(
     ClientSocket* transport_socket,
     const std::string& hostname,
     const SSLConfig& ssl_config) {
   MockSSLClientSocket* socket =
       new MockSSLClientSocket(transport_socket, hostname, ssl_config,
-                              mock_ssl_sockets_.GetNext());
+                              mock_ssl_data_.GetNext());
   ssl_client_sockets_.push_back(socket);
   return socket;
 }
 
 int TestSocketRequest::WaitForResult() {
   return callback_.WaitForResult();
 }
 
 void TestSocketRequest::RunWithParams(const Tuple1<int>& params) {
   callback_.RunWithParams(params);
@@ skipping 53 matching lines @@
 }
 
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 }  // namespace net