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

jingle/notifier/base/chrome_async_socket_unittest.cc

 // 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.
 
 #include "jingle/notifier/base/chrome_async_socket.h"
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 25 matching lines @@
     EXPECT_TRUE(writes_.empty());
     EXPECT_TRUE(reads_.empty());
   }
 
   // If there's no read, sets the "has pending read" flag.  Otherwise,
   // pops the next read.
   virtual net::MockRead GetNextRead() {
     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();
     reads_.pop_front();
     return mock_read;
   }
 
   // Simply pops the next write and, if applicable, compares it to
   // |data|.
   virtual net::MockWriteResult OnWrite(const std::string& data) {
     DCHECK(!writes_.empty());
     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
   // read/write events.
   virtual void Reset() {}
 
   // If there is a pending read, completes it with the given read.
   // Otherwise, queues up the given read.
   void AddRead(const net::MockRead& mock_read) {
     DCHECK_NE(mock_read.result, net::ERR_IO_PENDING);
@@ skipping 65 matching lines @@
   net::AddressList address_list_;
   net::SSLConfig ssl_config_;
   net::CertVerifier cert_verifier_;
 };
 
 class ChromeAsyncSocketTest
     : public testing::Test,
       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() {}
 
   virtual void SetUp() {
     scoped_ptr<net::MockClientSocketFactory> mock_client_socket_factory(
         new net::MockClientSocketFactory());
     mock_client_socket_factory->AddSocketDataProvider(
         &async_socket_data_provider_);
     mock_client_socket_factory->AddSSLSocketDataProvider(
@@ skipping 488 matching lines @@
   DoOpenClosed();
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
   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(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 }
 
 TEST_F(ChromeAsyncSocketTest, ReadEmpty) {
   async_socket_data_provider_.AddRead(net::MockRead(""));
   DoOpenClosed();
@@ skipping 33 matching lines @@
       SignalSocketState::NoError(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 }
 
 TEST_F(ChromeAsyncSocketTest, PendingReadError) {
   DoOpenClosed();
 
   ExpectNoSignal();
 
   async_socket_data_provider_.AddRead(
-      net::MockRead(true, net::ERR_TIMED_OUT));
+      net::MockRead(net::ASYNC, net::ERR_TIMED_OUT));
 
   ExpectSignalSocketState(
       SignalSocketState(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
           ChromeAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
 }
 
 // After this we can assume non-SSL Read() works as expected.
 
 TEST_F(ChromeAsyncSocketTest, WrongWrite) {
   EXPECT_DEBUG_DEATH({
     std::string data("foo");
     EXPECT_FALSE(chrome_async_socket_->Write(data.data(), data.size()));
     ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
                      ChromeAsyncSocket::ERROR_WRONGSTATE);
     EXPECT_TRUE(chrome_async_socket_->Close());
   }, "non-open");
 }
 
 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));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoCloseOpenedNoError();
 }
 
 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();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoCloseOpenedNoError();
 }
 
 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();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
   message_loop_.RunAllPending();
 
   ExpectSignalSocketState(
@@ skipping 145 matching lines @@
 TEST_F(ChromeAsyncSocketTest, WriteDuringSSLConnecting) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
   ExpectReadSignal();
 
   EXPECT_TRUE(chrome_async_socket_->StartTls("fakedomain.com"));
   ExpectNoSignal();
   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));
 
   // TODO(akalin): Figure out how to test that the write happens
   // *after* the SSL connect.
 
   message_loop_.RunAllPending();
   ExpectSSLConnectSignal();
   ExpectNoSignal();
@@ skipping 15 matching lines @@
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
                           net::OK));
   }, "wrong state");
 }
 
 TEST_F(ChromeAsyncSocketTest, SSLConnectDuringPostedWrite) {
   EXPECT_DEBUG_DEATH({
     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"));
 
     message_loop_.RunAllPending();
 
     DoCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
                           ChromeAsyncSocket::STATE_CLOSED,
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
@@ skipping 13 matching lines @@
 
   EXPECT_EQ(kReadData, DrainRead(1));
 
   message_loop_.RunAllPending();
 
   DoSSLCloseOpenedNoError();
 }
 
 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));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 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();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 3, 5));
   message_loop_.RunAllPending();
   EXPECT_TRUE(chrome_async_socket_->Write(kWriteData + 8,
                                           arraysize(kWriteData) - 8));
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace notifier