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

11 files changed, 72 insertions, 57 deletions

diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index 7c10eb0..e6cc4f6 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -5774,8 +5774,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_SSL_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, reinterpret_cast<char*>(read_buffer),
-              arraysize(read_buffer)),
+    MockRead(ASYNC, 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"),
@@ -5842,8 +5842,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS5_HTTP_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockRead(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockRead(ASYNC, 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"),
@@ -5909,8 +5909,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS5_SSL_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockRead(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockRead(ASYNC, 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"),
@@ -7893,7 +7893,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GenerateAuthToken) {
     }
     TestRound(const MockWrite& write_arg, const MockRead& read_arg,
               int expected_rv_arg, const MockWrite* extra_write_arg,
-              const MockWrite* extra_read_arg)
+              const MockRead* extra_read_arg)
         : write(write_arg),
           read(read_arg),
           expected_rv(expected_rv_arg),
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index 7ccddeb..d63434d 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -5774,8 +5774,8 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SOCKS4_SSL_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, reinterpret_cast<char*>(read_buffer),
-              arraysize(read_buffer)),
+    MockRead(ASYNC, 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"),
@@ -5842,8 +5842,8 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SOCKS5_HTTP_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockRead(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockRead(ASYNC, 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"),
@@ -5909,8 +5909,8 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SOCKS5_SSL_GET) {
   };
 
   MockRead data_reads[] = {
-    MockWrite(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
-    MockWrite(ASYNC, kSOCKS5OkResponse, arraysize(kSOCKS5OkResponse)),
+    MockRead(ASYNC, kSOCKS5GreetResponse, arraysize(kSOCKS5GreetResponse)),
+    MockRead(ASYNC, 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"),
@@ -7892,7 +7892,7 @@ TEST_F(HttpNetworkTransactionSpdy3Test, GenerateAuthToken) {
     }
     TestRound(const MockWrite& write_arg, const MockRead& read_arg,
               int expected_rv_arg, const MockWrite* extra_write_arg,
-              const MockWrite* extra_read_arg)
+              const MockRead* extra_read_arg)
         : write(write_arg),
           read(read_arg),
           expected_rv(expected_rv_arg),
diff --git a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
index 50835cd..fee1626 100644
--- a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc
@@ -280,7 +280,7 @@ TEST_P(HttpProxyClientSocketPoolSpdy2Test, NeedAuth) {
                                 kAuthChallenge,
                                 arraysize(kAuthChallenge)));
   MockRead spdy_reads[] = {
-    CreateMockWrite(*resp, 1, ASYNC),
+    CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3)
   };
 
diff --git a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
index 86ad31d..b9c5f74 100644
--- a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc
@@ -280,7 +280,7 @@ TEST_P(HttpProxyClientSocketPoolSpdy3Test, NeedAuth) {
                                 kAuthChallenge,
                                 arraysize(kAuthChallenge)));
   MockRead spdy_reads[] = {
-    CreateMockWrite(*resp, 1, ASYNC),
+    CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3)
   };
 
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()
diff --git a/net/spdy/spdy_network_transaction_spdy2_unittest.cc b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
index 2cff815..06e64ba 100644
--- a/net/spdy/spdy_network_transaction_spdy2_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
@@ -1715,7 +1715,7 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, PostWithEarlySynReply) {
 
   scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
-  MockRead writes[] = {
+  MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 2),
   };
diff --git a/net/spdy/spdy_network_transaction_spdy3_unittest.cc b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
index e93733b..9fd4c04 100644
--- a/net/spdy/spdy_network_transaction_spdy3_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
@@ -1721,7 +1721,7 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, PostWithEarlySynReply) {
 
   scoped_ptr<SpdyFrame> req(ConstructSpdyPost(kUploadDataSize, NULL, 0));
   scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
-  MockRead writes[] = {
+  MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 2),
   };
diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc
index 9597289..a592810 100644
--- a/net/spdy/spdy_session_spdy2_unittest.cc
+++ b/net/spdy/spdy_session_spdy2_unittest.cc
@@ -183,8 +183,8 @@ TEST_F(SpdySessionSpdy2Test, Ping) {
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(ConstructSpdyPing());
-  MockRead writes[] = {
-    CreateMockRead(*write_ping),
+  MockWrite writes[] = {
+    CreateMockWrite(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
@@ -332,8 +332,8 @@ TEST_F(SpdySessionSpdy2Test, FailedPing) {
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(ConstructSpdyPing());
-  MockRead writes[] = {
-    CreateMockRead(*write_ping),
+  MockWrite writes[] = {
+    CreateMockWrite(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc
index 59b7382..5b88415 100644
--- a/net/spdy/spdy_session_spdy3_unittest.cc
+++ b/net/spdy/spdy_session_spdy3_unittest.cc
@@ -183,8 +183,8 @@ TEST_F(SpdySessionSpdy3Test, Ping) {
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(ConstructSpdyPing());
-  MockRead writes[] = {
-    CreateMockRead(*write_ping),
+  MockWrite writes[] = {
+    CreateMockWrite(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
@@ -336,8 +336,8 @@ TEST_F(SpdySessionSpdy3Test, FailedPing) {
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(ConstructSpdyPing());
-  MockRead writes[] = {
-    CreateMockRead(*write_ping),
+  MockWrite writes[] = {
+    CreateMockWrite(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));