Change MockRead and MockWrite (et. al.) to take an IoMode enum, instead

of a bool async.

Review URL: http://codereview.chromium.org/9425016

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

2 files changed, 51 insertions, 51 deletions

diff --git a/jingle/notifier/base/chrome_async_socket_unittest.cc b/jingle/notifier/base/chrome_async_socket_unittest.cc
index 1f16e3a..9b1d07a 100644
--- a/jingle/notifier/base/chrome_async_socket_unittest.cc
+++ b/jingle/notifier/base/chrome_async_socket_unittest.cc
@@ -43,7 +43,7 @@ class AsyncSocketDataProvider : public net::SocketDataProvider {
     if (reads_.empty()) {
       DCHECK(!has_pending_read_);
       has_pending_read_ = true;
-      const net::MockRead pending_read(false, net::ERR_IO_PENDING);
+      const net::MockRead pending_read(net::SYNCHRONOUS, net::ERR_IO_PENDING);
       return pending_read;
     }
     net::MockRead mock_read = reads_.front();
@@ -58,14 +58,14 @@ class AsyncSocketDataProvider : public net::SocketDataProvider {
     net::MockWrite mock_write = writes_.front();
     writes_.pop_front();
     if (mock_write.result != net::OK) {
-      return net::MockWriteResult(mock_write.async, mock_write.result);
+      return net::MockWriteResult(mock_write.mode, mock_write.result);
     }
     std::string expected_data(mock_write.data, mock_write.data_len);
     EXPECT_EQ(expected_data, data);
     if (expected_data != data) {
-      return net::MockWriteResult(false, net::ERR_UNEXPECTED);
+      return net::MockWriteResult(net::SYNCHRONOUS, net::ERR_UNEXPECTED);
     }
-    return net::MockWriteResult(mock_write.async, data.size());
+    return net::MockWriteResult(mock_write.mode, data.size());
   }
 
   // We ignore resets so we can pre-load the socket data provider with
@@ -151,7 +151,7 @@ class ChromeAsyncSocketTest
       public sigslot::has_slots<> {
  protected:
   ChromeAsyncSocketTest()
-      : ssl_socket_data_provider_(true, net::OK),
+      : ssl_socket_data_provider_(net::ASYNC, net::OK),
         addr_(0xaabbccdd, 35) {}
 
   virtual ~ChromeAsyncSocketTest() {}
@@ -660,7 +660,7 @@ TEST_F(ChromeAsyncSocketTest, ReadError) {
   message_loop_.RunAllPending();
 
   async_socket_data_provider_.AddRead(
-      net::MockRead(false, net::ERR_TIMED_OUT));
+      net::MockRead(net::SYNCHRONOUS, net::ERR_TIMED_OUT));
 
   ExpectSignalSocketState(
       SignalSocketState(
@@ -714,7 +714,7 @@ TEST_F(ChromeAsyncSocketTest, PendingReadError) {
   ExpectNoSignal();
 
   async_socket_data_provider_.AddRead(
-      net::MockRead(true, net::ERR_TIMED_OUT));
+      net::MockRead(net::ASYNC, net::ERR_TIMED_OUT));
 
   ExpectSignalSocketState(
       SignalSocketState(
@@ -738,11 +738,12 @@ const char kWriteData[] = "mydatatowrite";
 
 TEST_F(ChromeAsyncSocketTest, SyncWrite) {
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData, 3));
+      net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData + 3, 5));
+      net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData + 8, arraysize(kWriteData) - 8));
+      net::MockWrite(net::SYNCHRONOUS,
+                     kWriteData + 8, arraysize(kWriteData) - 8));
   DoOpenClosed();
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
@@ -762,11 +763,11 @@ TEST_F(ChromeAsyncSocketTest, AsyncWrite) {
   DoOpenClosed();
 
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData, 3));
+      net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData + 3, 5));
+      net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData + 8, arraysize(kWriteData) - 8));
+      net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
   message_loop_.RunAllPending();
@@ -785,11 +786,11 @@ TEST_F(ChromeAsyncSocketTest, AsyncWriteError) {
   DoOpenClosed();
 
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData, 3));
+      net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData + 3, 5));
+      net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, net::ERR_TIMED_OUT));
+      net::MockWrite(net::ASYNC, net::ERR_TIMED_OUT));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
   message_loop_.RunAllPending();
@@ -955,7 +956,7 @@ TEST_F(ChromeAsyncSocketTest, WriteDuringSSLConnecting) {
   ExpectNonErrorState(ChromeAsyncSocket::STATE_TLS_CONNECTING);
 
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData, 3));
+      net::MockWrite(net::ASYNC, kWriteData, 3));
 
   // Shouldn't do anything.
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
@@ -991,7 +992,7 @@ TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPostedWrite) {
     DoOpenClosed();
 
     async_socket_data_provider_.AddWrite(
-        net::MockWrite(true, kWriteData, 3));
+        net::MockWrite(net::ASYNC, kWriteData, 3));
     EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
 
     EXPECT_FALSE(chrome_async_socket_->StartTls("fakedomain.com"));
@@ -1025,11 +1026,12 @@ TEST_F(ChromeAsyncSocketTest, SSLRead) {
 
 TEST_F(ChromeAsyncSocketTest, SSLSyncWrite) {
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData, 3));
+      net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData + 3, 5));
+      net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(false, kWriteData + 8, arraysize(kWriteData) - 8));
+      net::MockWrite(net::SYNCHRONOUS,
+                     kWriteData + 8, arraysize(kWriteData) - 8));
   DoSSLOpenClosed();
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
@@ -1049,11 +1051,11 @@ TEST_F(ChromeAsyncSocketTest, SSLAsyncWrite) {
   DoSSLOpenClosed();
 
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData, 3));
+      net::MockWrite(net::ASYNC, kWriteData, 3));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData + 3, 5));
+      net::MockWrite(net::ASYNC, kWriteData + 3, 5));
   async_socket_data_provider_.AddWrite(
-      net::MockWrite(true, kWriteData + 8, arraysize(kWriteData) - 8));
+      net::MockWrite(net::ASYNC, kWriteData + 8, arraysize(kWriteData) - 8));
 
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData, 3));
   message_loop_.RunAllPending();
diff --git a/jingle/notifier/base/fake_ssl_client_socket_unittest.cc b/jingle/notifier/base/fake_ssl_client_socket_unittest.cc
index f54ed10..0e8a733 100644
--- a/jingle/notifier/base/fake_ssl_client_socket_unittest.cc
+++ b/jingle/notifier/base/fake_ssl_client_socket_unittest.cc
@@ -70,7 +70,7 @@ class MockClientSocket : public net::StreamSocket {
 
 // Break up |data| into a bunch of chunked MockReads/Writes and push
 // them onto |ops|.
-void AddChunkedOps(base::StringPiece data, size_t chunk_size, bool async,
+void AddChunkedOps(base::StringPiece data, size_t chunk_size, net::IoMode mode,
                    std::vector<net::MockRead>* ops) {
   DCHECK_GT(chunk_size, 0U);
   size_t offset = 0;
@@ -78,7 +78,7 @@ void AddChunkedOps(base::StringPiece data, size_t chunk_size, bool async,
     size_t bounded_chunk_size = std::min(data.size() - offset, chunk_size);
     // We take advantage of the fact that MockWrite is typedefed to
     // MockRead.
-    ops->push_back(net::MockRead(async, data.data() + offset,
+    ops->push_back(net::MockRead(mode, data.data() + offset,
                                  bounded_chunk_size));
     offset += bounded_chunk_size;
   }
@@ -109,9 +109,9 @@ class FakeSSLClientSocketTest : public testing::Test {
   }
 
   void ExpectStatus(
-      bool async, int expected_status, int immediate_status,
+      net::IoMode mode, int expected_status, int immediate_status,
       net::TestCompletionCallback* test_completion_callback) {
-    if (async) {
+    if (mode == net::ASYNC) {
       EXPECT_EQ(net::ERR_IO_PENDING, immediate_status);
       int status = test_completion_callback->WaitForResult();
       EXPECT_EQ(expected_status, status);
@@ -124,27 +124,26 @@ class FakeSSLClientSocketTest : public testing::Test {
   // (sliced up according to the parameters) and makes sure the
   // FakeSSLClientSocket behaves as expected.
   void RunSuccessfulHandshakeTest(
-      bool async, size_t read_chunk_size, size_t write_chunk_size,
+      net::IoMode mode, size_t read_chunk_size, size_t write_chunk_size,
       int num_resets) {
     base::StringPiece ssl_client_hello =
         FakeSSLClientSocket::GetSslClientHello();
     base::StringPiece ssl_server_hello =
         FakeSSLClientSocket::GetSslServerHello();
 
-    net::MockConnect mock_connect(async ? net::ASYNC : net::SYNCHRONOUS,
-                                  net::OK);
+    net::MockConnect mock_connect(mode, net::OK);
     std::vector<net::MockRead> reads;
     std::vector<net::MockWrite> writes;
     static const char kReadTestData[] = "read test data";
     static const char kWriteTestData[] = "write test data";
     for (int i = 0; i < num_resets + 1; ++i) {
       SCOPED_TRACE(i);
-      AddChunkedOps(ssl_server_hello, read_chunk_size, async, &reads);
-      AddChunkedOps(ssl_client_hello, write_chunk_size, async, &writes);
+      AddChunkedOps(ssl_server_hello, read_chunk_size, mode, &reads);
+      AddChunkedOps(ssl_client_hello, write_chunk_size, mode, &writes);
       reads.push_back(
-          net::MockRead(async, kReadTestData, arraysize(kReadTestData)));
+          net::MockRead(mode, kReadTestData, arraysize(kReadTestData)));
       writes.push_back(
-          net::MockWrite(async, kWriteTestData, arraysize(kWriteTestData)));
+          net::MockWrite(mode, kWriteTestData, arraysize(kWriteTestData)));
     }
     SetData(mock_connect, &reads, &writes);
 
@@ -155,10 +154,10 @@ class FakeSSLClientSocketTest : public testing::Test {
       net::TestCompletionCallback test_completion_callback;
       int status = fake_ssl_client_socket.Connect(
           test_completion_callback.callback());
-      if (async) {
+      if (mode == net::ASYNC) {
         EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
       }
-      ExpectStatus(async, net::OK, status, &test_completion_callback);
+      ExpectStatus(mode, net::OK, status, &test_completion_callback);
       if (fake_ssl_client_socket.IsConnected()) {
         int read_len = arraysize(kReadTestData);
         int read_buf_len = 2 * read_len;
@@ -166,14 +165,14 @@ class FakeSSLClientSocketTest : public testing::Test {
             new net::IOBuffer(read_buf_len));
         int read_status = fake_ssl_client_socket.Read(
             read_buf, read_buf_len, test_completion_callback.callback());
-        ExpectStatus(async, read_len, read_status, &test_completion_callback);
+        ExpectStatus(mode, read_len, read_status, &test_completion_callback);
 
         scoped_refptr<net::IOBuffer> write_buf(
             new net::StringIOBuffer(kWriteTestData));
         int write_status = fake_ssl_client_socket.Write(
             write_buf, arraysize(kWriteTestData),
             test_completion_callback.callback());
-        ExpectStatus(async, arraysize(kWriteTestData), write_status,
+        ExpectStatus(mode, arraysize(kWriteTestData), write_status,
                      &test_completion_callback);
       } else {
         ADD_FAILURE();
@@ -186,20 +185,19 @@ class FakeSSLClientSocketTest : public testing::Test {
   // Sets up the mock socket to generate an unsuccessful handshake
   // FakeSSLClientSocket fails as expected.
   void RunUnsuccessfulHandshakeTestHelper(
-      bool async, int error, HandshakeErrorLocation location) {
+      net::IoMode mode, int error, HandshakeErrorLocation location) {
     DCHECK_NE(error, net::OK);
     base::StringPiece ssl_client_hello =
         FakeSSLClientSocket::GetSslClientHello();
     base::StringPiece ssl_server_hello =
         FakeSSLClientSocket::GetSslServerHello();
 
-    net::MockConnect mock_connect(async ? net::ASYNC : net::SYNCHRONOUS,
-                                  net::OK);
+    net::MockConnect mock_connect(mode, net::OK);
     std::vector<net::MockRead> reads;
     std::vector<net::MockWrite> writes;
     const size_t kChunkSize = 1;
-    AddChunkedOps(ssl_server_hello, kChunkSize, async, &reads);
-    AddChunkedOps(ssl_client_hello, kChunkSize, async, &writes);
+    AddChunkedOps(ssl_server_hello, kChunkSize, mode, &reads);
+    AddChunkedOps(ssl_client_hello, kChunkSize, mode, &writes);
     switch (location) {
       case CONNECT_ERROR:
         mock_connect.result = error;
@@ -232,7 +230,7 @@ class FakeSSLClientSocketTest : public testing::Test {
         if (error ==
             net::ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
           static const char kDummyData[] = "DUMMY";
-          reads.push_back(net::MockRead(async, kDummyData));
+          reads.push_back(net::MockRead(mode, kDummyData));
         }
         break;
       }
@@ -252,14 +250,14 @@ class FakeSSLClientSocketTest : public testing::Test {
     int status = fake_ssl_client_socket.Connect(
         test_completion_callback.callback());
     EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
-    ExpectStatus(async, expected_status, status, &test_completion_callback);
+    ExpectStatus(mode, expected_status, status, &test_completion_callback);
     EXPECT_FALSE(fake_ssl_client_socket.IsConnected());
   }
 
   void RunUnsuccessfulHandshakeTest(
       int error, HandshakeErrorLocation location) {
-    RunUnsuccessfulHandshakeTestHelper(false, error, location);
-    RunUnsuccessfulHandshakeTestHelper(true, error, location);
+    RunUnsuccessfulHandshakeTestHelper(net::SYNCHRONOUS, error, location);
+    RunUnsuccessfulHandshakeTestHelper(net::ASYNC, error, location);
   }
 
   // MockTCPClientSocket needs a message loop.
@@ -301,7 +299,7 @@ TEST_F(FakeSSLClientSocketTest, SuccessfulHandshakeSync) {
     SCOPED_TRACE(i);
     for (size_t j = 1; j < 100; j += 5) {
       SCOPED_TRACE(j);
-      RunSuccessfulHandshakeTest(false, i, j, 0);
+      RunSuccessfulHandshakeTest(net::SYNCHRONOUS, i, j, 0);
     }
   }
 }
@@ -311,13 +309,13 @@ TEST_F(FakeSSLClientSocketTest, SuccessfulHandshakeAsync) {
     SCOPED_TRACE(i);
     for (size_t j = 1; j < 100; j += 9) {
       SCOPED_TRACE(j);
-      RunSuccessfulHandshakeTest(true, i, j, 0);
+      RunSuccessfulHandshakeTest(net::ASYNC, i, j, 0);
     }
   }
 }
 
 TEST_F(FakeSSLClientSocketTest, ResetSocket) {
-  RunSuccessfulHandshakeTest(true, 1, 2, 3);
+  RunSuccessfulHandshakeTest(net::ASYNC, 1, 2, 3);
 }
 
 TEST_F(FakeSSLClientSocketTest, UnsuccessfulHandshakeConnectError) {