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

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 56 matching lines @@
 // {async, result}.
 typedef MockRead MockWrite;
 
 struct MockWriteResult {
   MockWriteResult(bool async, int result) : async(async), result(result) {}
 
   bool async;
   int result;
 };
 
-class MockSocket {
+// The SocketDataProvider is an interface used by the MockClientSocket
+// for getting data about individual reads and writes on the socket.
+class SocketDataProvider {
  public:
-  MockSocket() {}
+  SocketDataProvider() {}
 
-  virtual ~MockSocket() {}
+  virtual ~SocketDataProvider() {}
   virtual MockRead GetNextRead() = 0;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset() = 0;
 
   MockConnect connect_data() const { return connect_; }
 
  private:
   MockConnect connect_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockSocket);
+  DISALLOW_COPY_AND_ASSIGN(SocketDataProvider);
 };
 
-// MockSocket which responds based on static tables of mock reads and writes.
-class StaticMockSocket : public MockSocket {
+// SocketDataProvider which responds based on static tables of mock reads and
+// writes.
+class StaticSocketDataProvider : public SocketDataProvider {
  public:
-  StaticMockSocket() : reads_(NULL), read_index_(0),
+  StaticSocketDataProvider() : reads_(NULL), read_index_(0),
       writes_(NULL), write_index_(0) {}
-  StaticMockSocket(MockRead* r, MockWrite* w) : reads_(r), read_index_(0),
-      writes_(w), write_index_(0) {}
+  StaticSocketDataProvider(MockRead* r, MockWrite* w) : reads_(r),
+      read_index_(0), writes_(w), write_index_(0) {}
 
-  // MockSocket methods:
+  // SocketDataProvider methods:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data);
   virtual void Reset();
 
   // If the test wishes to verify that all data is consumed, it can include
   // a EOF MockRead or MockWrite, which is a zero-length Read or Write.
   // The test can then call at_read_eof() or at_write_eof() to verify that
   // all data has been consumed.
   bool at_read_eof() const { return reads_[read_index_].data_len == 0; }
   bool at_write_eof() const { return writes_[write_index_].data_len == 0; }
 
  private:
   MockRead* reads_;
   int read_index_;
   MockWrite* writes_;
   int write_index_;
 
-  DISALLOW_COPY_AND_ASSIGN(StaticMockSocket);
+  DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
 };
 
-// MockSocket which can make decisions about next mock reads based on
-// received writes. It can also be used to enforce order of operations,
-// for example that tested code must send the "Hello!" message before
-// receiving response. This is useful for testing conversation-like
-// protocols like FTP.
-class DynamicMockSocket : public MockSocket {
+// SocketDataProvider which can make decisions about next mock reads based on
+// received writes. It can also be used to enforce order of operations, for
+// example that tested code must send the "Hello!" message before receiving
+// response. This is useful for testing conversation-like protocols like FTP.
+class DynamicSocketDataProvider : public SocketDataProvider {
  public:
-  DynamicMockSocket();
+  DynamicSocketDataProvider();
 
-  // MockSocket methods:
+  // SocketDataProvider methods:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset();
 
   int short_read_limit() const { return short_read_limit_; }
   void set_short_read_limit(int limit) { short_read_limit_ = limit; }
 
   void allow_unconsumed_reads(bool allow) { allow_unconsumed_reads_ = allow; }
 
  protected:
   // The next time there is a read from this socket, it will return |data|.
   // Before calling SimulateRead next time, the previous data must be consumed.
   void SimulateRead(const char* data);
 
  private:
   std::deque<MockRead> reads_;
 
   // Max number of bytes we will read at a time. 0 means no limit.
   int short_read_limit_;
 
   // If true, we'll not require the client to consume all data before we
   // mock the next read.
   bool allow_unconsumed_reads_;
 
-  DISALLOW_COPY_AND_ASSIGN(DynamicMockSocket);
+  DISALLOW_COPY_AND_ASSIGN(DynamicSocketDataProvider);
 };
 
-// MockSSLSockets only need to keep track of the return code from calls to
-// Connect().
-struct  MockSSLSocket {
-  MockSSLSocket(bool async, int result) : connect(async, result) { }
+// SSLSocketDataProviders only need to keep track of the return code from calls
+// to Connect().
+struct SSLSocketDataProvider {
+  SSLSocketDataProvider(bool async, int result) : connect(async, result) { }
 
   MockConnect connect;
 };
 
-// Holds an array of Mock{SSL,}Socket elements.  As Mock{TCP,SSL}ClientSocket
+// Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}ClientSocket
 // objects get instantiated, they take their data from the i'th element of this
 // array.
 template<typename T>
-class MockSocketArray {
+class SocketDataProviderArray {
  public:
-  MockSocketArray() : next_index_(0) {
+  SocketDataProviderArray() : next_index_(0) {
   }
 
   T* GetNext() {
-    DCHECK(next_index_ < sockets_.size());
-    return sockets_[next_index_++];
+    DCHECK(next_index_ < data_providers_.size());
+    return data_providers_[next_index_++];
   }
 
-  void Add(T* socket) {
-    DCHECK(socket);
-    sockets_.push_back(socket);
+  void Add(T* data_provider) {
+    DCHECK(data_provider);
+    data_providers_.push_back(data_provider);
   }
 
   void ResetNextIndex() {
     next_index_ = 0;
   }
 
  private:
-  // Index of the next |sockets| element to use. Not an iterator because those
-  // are invalidated on vector reallocation.
+  // Index of the next |data_providers_| element to use. Not an iterator
+  // because those are invalidated on vector reallocation.
   size_t next_index_;
 
-  // Mock sockets to be returned.
-  std::vector<T*> sockets_;
+  // SocketDataProviders to be returned.
+  std::vector<T*> data_providers_;
 };
 
 class MockTCPClientSocket;
 class MockSSLClientSocket;
 
 // ClientSocketFactory which contains arrays of sockets of each type.
 // You should first fill the arrays using AddMock{SSL,}Socket. When the factory
 // is asked to create a socket, it takes next entry from appropriate array.
 // You can use ResetNextMockIndexes to reset that next entry index for all mock
 // socket types.
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
-  void AddMockSocket(MockSocket* socket);
-  void AddMockSSLSocket(MockSSLSocket* socket);
+  void AddSocketDataProvider(SocketDataProvider* socket);
+  void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   // Return |index|-th MockTCPClientSocket (starting from 0) that the factory
   // created.
   MockTCPClientSocket* GetMockTCPClientSocket(int index) const;
 
   // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
   // created.
   MockSSLClientSocket* GetMockSSLClientSocket(int index) const;
 
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocket* transport_socket,
       const std::string& hostname,
       const SSLConfig& ssl_config);
 
  private:
-  MockSocketArray<MockSocket> mock_sockets_;
-  MockSocketArray<MockSSLSocket> mock_ssl_sockets_;
+  SocketDataProviderArray<SocketDataProvider> mock_data_;
+  SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<MockTCPClientSocket*> tcp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public net::SSLClientSocket {
  public:
   MockClientSocket();
 
@@ skipping 24 matching lines @@
   void RunCallbackAsync(net::CompletionCallback* callback, int result);
   void RunCallback(net::CompletionCallback*, int result);
 
   ScopedRunnableMethodFactory<MockClientSocket> method_factory_;
   bool connected_;
 };
 
 class MockTCPClientSocket : public MockClientSocket {
  public:
   MockTCPClientSocket(const net::AddressList& addresses,
-                      net::MockSocket* socket);
+                      net::SocketDataProvider* socket);
 
   // ClientSocket methods:
   virtual int Connect(net::CompletionCallback* callback,
                       LoadLog* load_log);
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
   net::AddressList addresses() const { return addresses_; }
 
  private:
   net::AddressList addresses_;
 
-  net::MockSocket* data_;
+  net::SocketDataProvider* data_;
   int read_offset_;
   net::MockRead read_data_;
   bool need_read_data_;
 };
 
 class MockSSLClientSocket : public MockClientSocket {
  public:
   MockSSLClientSocket(
       net::ClientSocket* transport_socket,
       const std::string& hostname,
       const net::SSLConfig& ssl_config,
-      net::MockSSLSocket* socket);
+      net::SSLSocketDataProvider* socket);
   ~MockSSLClientSocket();
 
   virtual void GetSSLInfo(net::SSLInfo* ssl_info);
 
   virtual int Connect(net::CompletionCallback* callback, LoadLog* load_log);
   virtual void Disconnect();
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
  private:
   class ConnectCallback;
 
   scoped_ptr<ClientSocket> transport_;
-  net::MockSSLSocket* data_;
+  net::SSLSocketDataProvider* data_;
 };
 
 class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
  public:
   TestSocketRequest(
       std::vector<TestSocketRequest*>* request_order,
       size_t* completion_count)
       : request_order_(request_order),
         completion_count_(completion_count) {
     DCHECK(request_order);
@@ skipping 58 matching lines @@
   void ReleaseAllConnections(KeepAlive keep_alive);
 
   ScopedVector<TestSocketRequest> requests_;
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_