Give MockRead and MockWrite distinct types.

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 54 matching lines @@
   // |peer_addr| 192.0.2.33.
   MockConnect(IoMode io_mode, int r);
   MockConnect(IoMode io_mode, int r, IPEndPoint addr);
   ~MockConnect();
 
   IoMode mode;
   int result;
   IPEndPoint peer_addr;
 };
 
-struct MockRead {
+// MockRead and MockWrite shares the same interface and members, but we'd like
+// to have distinct types because we don't want to have them used
+// interchangably. To do this, a struct template is defined, and MockRead and
+// MockWrite are instantiated by using this template. Template parameter |type|
+// is not used in the struct definition (it purely exists for creating a new
+// type).
+//
+// |data| in MockRead and MockWrite has different meanings: |data| in MockRead
+// is the data returned from the socket when MockTCPClientSocket::Read() is
+// attempted, while |data| in MockWrite is the expected data that should be
+// given in MockTCPClientSocket::Write().
+enum MockReadWriteType {
+  MOCK_READ,
+  MOCK_WRITE
+};
+
+template <MockReadWriteType type>
+struct MockReadWrite {
   // Flag to indicate that the message loop should be terminated.
   enum {
     STOPLOOP = 1 << 31
   };
 
   // Default
-  MockRead() : mode(SYNCHRONOUS), result(0), data(NULL), data_len(0),
+  MockReadWrite() : mode(SYNCHRONOUS), result(0), data(NULL), data_len(0),
       sequence_number(0), time_stamp(base::Time::Now()) {}
 
-  // Read failure (no data).
-  MockRead(IoMode io_mode, int result) : mode(io_mode), result(result),
+  // Read/write failure (no data).
+  MockReadWrite(IoMode io_mode, int result) : mode(io_mode), result(result),
       data(NULL), data_len(0), sequence_number(0),
       time_stamp(base::Time::Now()) { }
 
-  // Read failure (no data), with sequence information.
-  MockRead(IoMode io_mode, int result, int seq) : mode(io_mode),
+  // Read/write failure (no data), with sequence information.
+  MockReadWrite(IoMode io_mode, int result, int seq) : mode(io_mode),
       result(result), data(NULL), data_len(0), sequence_number(seq),
       time_stamp(base::Time::Now()) { }
 
-  // Asynchronous read success (inferred data length).
-  explicit MockRead(const char* data) : mode(ASYNC),  result(0), data(data),
-      data_len(strlen(data)), sequence_number(0),
-      time_stamp(base::Time::Now()) { }
-
-  // Read success (inferred data length).
-  MockRead(IoMode io_mode, const char* data) : mode(io_mode), result(0),
+  // Asynchronous read/write success (inferred data length).
+  explicit MockReadWrite(const char* data) : mode(ASYNC),  result(0),
       data(data), data_len(strlen(data)), sequence_number(0),
       time_stamp(base::Time::Now()) { }
 
-  // Read success.
-  MockRead(IoMode io_mode, const char* data, int data_len) : mode(io_mode),
+  // Read/write success (inferred data length).
+  MockReadWrite(IoMode io_mode, const char* data) : mode(io_mode), result(0),
+      data(data), data_len(strlen(data)), sequence_number(0),
+      time_stamp(base::Time::Now()) { }
+
+  // Read/write success.
+  MockReadWrite(IoMode io_mode, const char* data, int data_len) : mode(io_mode),
       result(0), data(data), data_len(data_len), sequence_number(0),
       time_stamp(base::Time::Now()) { }
 
-  // Read success (inferred data length) with sequence information.
-  MockRead(IoMode io_mode, int seq, const char* data) : mode(io_mode),
+  // Read/write success (inferred data length) with sequence information.
+  MockReadWrite(IoMode io_mode, int seq, const char* data) : mode(io_mode),
       result(0), data(data), data_len(strlen(data)), sequence_number(seq),
       time_stamp(base::Time::Now()) { }
 
-  // Read success with sequence information.
-  MockRead(IoMode io_mode, const char* data, int data_len, int seq) :
+  // Read/write success with sequence information.
+  MockReadWrite(IoMode io_mode, const char* data, int data_len, int seq) :
       mode(io_mode), result(0), data(data), data_len(data_len),
       sequence_number(seq), time_stamp(base::Time::Now()) { }
 
   IoMode mode;
   int result;
   const char* data;
   int data_len;
 
   // For OrderedSocketData, which only allows reads to occur in a particular
   // sequence.  If a read occurs before the given |sequence_number| is reached,
   // an ERR_IO_PENDING is returned.
   int sequence_number;      // The sequence number at which a read is allowed
                             // to occur.
   base::Time time_stamp;    // The time stamp at which the operation occurred.
 };
 
-// MockWrite uses the same member fields as MockRead, but with different
-// meanings. The expected input to MockTCPClientSocket::Write() is given
-// by {data, data_len}, and the return value of Write() is controlled by
-// {async, result}.
-typedef MockRead MockWrite;
+typedef MockReadWrite<MOCK_READ> MockRead;
+typedef MockReadWrite<MOCK_WRITE> MockWrite;
 
 struct MockWriteResult {
   MockWriteResult(IoMode io_mode, int result)
       : mode(io_mode),
         result(result) {}
 
   IoMode mode;
   int result;
 };
 
@@ skipping 306 matching lines @@
   void RunFor(int steps);
 
   // Stop at step |seq|, which must be in the future.
   virtual void SetStop(int seq);
 
   // Stop |seq| steps after the current step.
   virtual void StopAfter(int seq);
   bool stopped() const { return stopped_; }
   void SetStopped(bool val) { stopped_ = val; }
   MockRead& current_read() { return current_read_; }
-  MockRead& current_write() { return current_write_; }
+  MockWrite& current_write() { return current_write_; }
   int sequence_number() const { return sequence_number_; }
   void set_socket(base::WeakPtr<DeterministicMockTCPClientSocket> socket) {
     socket_ = socket;
   }
 
   // StaticSocketDataProvider:
 
   // When the socket calls Read(), that calls GetNextRead(), and expects either
   // ERR_IO_PENDING or data.
   virtual MockRead GetNextRead() OVERRIDE;
@@ skipping 578 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_