Give MockRead and MockWrite distinct types.

Currently, MockRead and MockWrite are defined as the same type by using
typedef. However, these types are different types and should not be used
interchangably.

This change gives MockRead and MockWrite distinct types by using templates
so the compiler can cause an error when these types are used interchangably.
Some misuses of MockRead and MockWrite were found, so these are fixed in this
change, too.

BUG=none
R=mmenke@chromium.org,akalin@chromium.org


Review URL: https://chromiumcodereview.appspot.com/10796085

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@148782 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 46 insertions, 31 deletions

diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 34af370..9a8a638 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -109,7 +109,8 @@ void DumpData(const char* data, int data_len) {
   }
 }
 
-void DumpMockRead(const MockRead& r) {
+template <MockReadWriteType type>
+void DumpMockReadWrite(const MockReadWrite<type>& r) {
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
   DVLOG(1) << "Async:   " << (r.mode == ASYNC)
@@ -390,14 +391,14 @@ MockRead OrderedSocketData::GetNextRead() {
       sequence_number_++) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                               << ": Read " << read_index();
-    DumpMockRead(next_read);
+    DumpMockReadWrite(next_read);
     blocked_ = (next_read.result == ERR_IO_PENDING);
     return StaticSocketDataProvider::GetNextRead();
   }
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                             << ": I/O Pending";
   MockRead result = MockRead(ASYNC, ERR_IO_PENDING);
-  DumpMockRead(result);
+  DumpMockReadWrite(result);
   blocked_ = true;
   return result;
 }
@@ -405,7 +406,7 @@ MockRead OrderedSocketData::GetNextRead() {
 MockWriteResult OrderedSocketData::OnWrite(const std::string& data) {
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Write " << write_index();
-  DumpMockRead(PeekWrite());
+  DumpMockReadWrite(PeekWrite());
   ++sequence_number_;
   if (blocked_) {
     // TODO(willchan): This 100ms delay seems to work around some weirdness.  We
@@ -518,14 +519,14 @@ MockRead DeterministicSocketData::GetNextRead() {
       result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
     }
     if (print_debug_)
-      DumpMockRead(result);
+      DumpMockReadWrite(result);
     return result;
   }
 
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Read " << read_index();
   if (print_debug_)
-    DumpMockRead(current_read_);
+    DumpMockReadWrite(current_read_);
 
   // Increment the sequence number if IO is complete
   if (current_read_.mode == SYNCHRONOUS)
@@ -562,7 +563,7 @@ MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) {
   }
 
   if (print_debug_)
-    DumpMockRead(next_write);
+    DumpMockReadWrite(next_write);
 
   // Move to the next step if I/O is synchronous, since the operation will
   // complete when this method returns.
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index 171e3c3..7087640 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -72,48 +72,65 @@ struct MockConnect {
   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),
+  // 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 (inferred data length).
-  MockRead(IoMode io_mode, const char* data) : mode(io_mode), result(0),
+  // 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 success.
-  MockRead(IoMode io_mode, const char* data, int data_len) : mode(io_mode),
+  // 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()) { }
 
@@ -130,11 +147,8 @@ struct MockRead {
   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)
@@ -461,7 +475,7 @@ class DeterministicSocketData
   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;
diff --git a/net/socket/socks_client_socket_pool_unittest.cc b/net/socket/socks_client_socket_pool_unittest.cc
index 70c769b..9912854 100644
--- a/net/socket/socks_client_socket_pool_unittest.cc
+++ b/net/socket/socks_client_socket_pool_unittest.cc
@@ -49,7 +49,7 @@ class SOCKSClientSocketPoolTest : public testing::Test {
    private:
     scoped_ptr<StaticSocketDataProvider> data_;
     scoped_array<MockWrite> writes_;
-    scoped_array<MockWrite> reads_;
+    scoped_array<MockRead> reads_;
   };
 
   SOCKSClientSocketPoolTest()