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

net/socket/socks_client_socket_unittest.cc

 // Copyright (c) 2011 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 "net/socket/socks_client_socket.h"
 
 #include "net/base/address_list.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
@@ skipping 109 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel);
 };
 
 // Tests a complete handshake and the disconnection.
 TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
   const std::string payload_write = "random data";
   const std::string payload_read = "moar random data";
 
   MockWrite data_writes[] = {
-      MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)),
-      MockWrite(true, payload_write.data(), payload_write.size()) };
+      MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)),
+      MockWrite(ASYNC, payload_write.data(), payload_write.size()) };
   MockRead data_reads[] = {
-      MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply)),
-      MockRead(true, payload_read.data(), payload_read.size()) };
+      MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)),
+      MockRead(ASYNC, payload_read.data(), payload_read.size()) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
   // At this state the TCP connection is completed but not the SOCKS handshake.
   EXPECT_TRUE(tcp_sock_->IsConnected());
@@ skipping 50 matching lines @@
     {
       { 0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0 },
       ERR_SOCKS_CONNECTION_FAILED,
     },
   };
 
   //---------------------------------------
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     MockWrite data_writes[] = {
-        MockWrite(false, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
+        MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
     MockRead data_reads[] = {
-        MockRead(false, tests[i].fail_reply, arraysize(tests[i].fail_reply)) };
+        MockRead(SYNCHRONOUS, tests[i].fail_reply,
+                 arraysize(tests[i].fail_reply)) };
     CapturingNetLog log(CapturingNetLog::kUnbounded);
 
     user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                      data_writes, arraysize(data_writes),
                                      host_resolver_.get(),
                                      "localhost", 80,
                                      &log));
 
     int rv = user_sock_->Connect(callback_.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 13 matching lines @@
   }
 }
 
 // Tests scenario when the server sends the handshake response in
 // more than one packet.
 TEST_F(SOCKSClientSocketTest, PartialServerReads) {
   const char kSOCKSPartialReply1[] = { 0x00 };
   const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
 
   MockWrite data_writes[] = {
-      MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
+      MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
   MockRead data_reads[] = {
-      MockRead(true, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),
-      MockRead(true, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };
+      MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),
+      MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
   int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 10 matching lines @@
       entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests scenario when the client sends the handshake request in
 // more than one packet.
 TEST_F(SOCKSClientSocketTest, PartialClientWrites) {
   const char kSOCKSPartialRequest1[] = { 0x04, 0x01 };
   const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 };
 
   MockWrite data_writes[] = {
-      MockWrite(true, arraysize(kSOCKSPartialRequest1)),
+      MockWrite(ASYNC, arraysize(kSOCKSPartialRequest1)),
       // simulate some empty writes
-      MockWrite(true, 0),
-      MockWrite(true, 0),
-      MockWrite(true, kSOCKSPartialRequest2,
+      MockWrite(ASYNC, 0),
+      MockWrite(ASYNC, 0),
+      MockWrite(ASYNC, kSOCKSPartialRequest2,
                 arraysize(kSOCKSPartialRequest2)) };
   MockRead data_reads[] = {
-      MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };
+      MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
   int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
       entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests the case when the server sends a smaller sized handshake data
 // and closes the connection.
 TEST_F(SOCKSClientSocketTest, FailedSocketRead) {
   MockWrite data_writes[] = {
-      MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
+      MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
   MockRead data_reads[] = {
-      MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2),
+      MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2),
       // close connection unexpectedly
-      MockRead(false, 0) };
+      MockRead(SYNCHRONOUS, 0) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
   int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 40 matching lines @@
       entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Calls Disconnect() while a host resolve is in progress. The outstanding host
 // resolve should be cancelled.
 TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) {
   scoped_ptr<HangingHostResolverWithCancel> hanging_resolver(
     new HangingHostResolverWithCancel());
 
   // Doesn't matter what the socket data is, we will never use it -- garbage.
-  MockWrite data_writes[] = { MockWrite(false, "", 0) };
-  MockRead data_reads[] = { MockRead(false, "", 0) };
+  MockWrite data_writes[] = { MockWrite(SYNCHRONOUS, "", 0) };
+  MockRead data_reads[] = { MockRead(SYNCHRONOUS, "", 0) };
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    hanging_resolver.get(),
                                    "foo", 80,
                                    NULL));
 
   // Start connecting (will get stuck waiting for the host to resolve).
   int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_FALSE(user_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnectedAndIdle());
 
   // The host resolver should have received the resolve request.
   EXPECT_TRUE(hanging_resolver->HasOutstandingRequest());
 
   // Disconnect the SOCKS socket -- this should cancel the outstanding resolve.
   user_sock_->Disconnect();
 
   EXPECT_FALSE(hanging_resolver->HasOutstandingRequest());
 
   EXPECT_FALSE(user_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnectedAndIdle());
 }
 
 }  // namespace net