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

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 35 matching lines @@
   ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ = -10000,
 };
 
 class AsyncSocket;
 class MockClientSocket;
 class OriginBoundCertService;
 class SSLClientSocket;
 class SSLHostInfo;
 class StreamSocket;
 
-enum ConnectMode {
+enum IoMode {
   ASYNC,
   SYNCHRONOUS
 };
 
 struct MockConnect {
   // Asynchronous connection success.
-  MockConnect() : async(true), result(OK) { }
-  MockConnect(ConnectMode m, int r) : async(m == ASYNC), result(r) { }
+  MockConnect() : mode(ASYNC), result(OK) { }
+  MockConnect(IoMode io_mode, int r) : mode(io_mode), result(r) { }
 
-  bool async;
+  IoMode mode;
   int result;
 };
 
 struct MockRead {
   // Flag to indicate that the message loop should be terminated.
   enum {
     STOPLOOP = 1 << 31
   };
 
   // Default
-  MockRead() : async(false), result(0), data(NULL), data_len(0),
+  MockRead() : mode(SYNCHRONOUS), result(0), data(NULL), data_len(0),
       sequence_number(0), time_stamp(base::Time::Now()) {}
 
   // Read failure (no data).
-  MockRead(bool async, int result) : async(async) , result(result), data(NULL),
-      data_len(0), sequence_number(0), time_stamp(base::Time::Now()) { }
+  MockRead(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(bool async, int result, int seq) : async(async) , result(result),
-      data(NULL), data_len(0), sequence_number(seq),
+  MockRead(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) : async(true),  result(0), data(data),
+  explicit MockRead(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(bool async, const char* data) : async(async), result(0), data(data),
-      data_len(strlen(data)), sequence_number(0),
+  MockRead(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(bool async, const char* data, int data_len) : async(async),
+  MockRead(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(bool async, int seq, const char* data) : async(async),
+  MockRead(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(bool async, const char* data, int data_len, int seq) : async(async),
-      result(0), data(data), data_len(data_len), sequence_number(seq),
-      time_stamp(base::Time::Now()) { }
+  MockRead(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()) { }
 
-  bool async;
+  IoMode mode;
   int result;
   const char* data;
   int data_len;
 
   // For OrderedSocketData, which only allows reads to occur in a particular
   // sequence.  If a read occurs before the given |sequence_number| is reached,
   // an ERR_IO_PENDING is returned.
   int sequence_number;      // The sequence number at which a read is allowed
                             // to occur.
   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;
 
 struct MockWriteResult {
-  MockWriteResult(bool async, int result) : async(async), result(result) {}
+  MockWriteResult(IoMode io_mode, int result)
+      : mode(io_mode),
+        result(result) {}
 
-  bool async;
+  IoMode mode;
   int result;
 };
 
 // The SocketDataProvider is an interface used by the MockClientSocket
 // for getting data about individual reads and writes on the socket.
 class SocketDataProvider {
  public:
   SocketDataProvider() : socket_(NULL) {}
 
   virtual ~SocketDataProvider() {}
@@ skipping 109 matching lines @@
   // If true, we'll not require the client to consume all data before we
   // mock the next read.
   bool allow_unconsumed_reads_;
 
   DISALLOW_COPY_AND_ASSIGN(DynamicSocketDataProvider);
 };
 
 // SSLSocketDataProviders only need to keep track of the return code from calls
 // to Connect().
 struct SSLSocketDataProvider {
-  SSLSocketDataProvider(bool async, int result);
+  SSLSocketDataProvider(IoMode mode, int result);
   ~SSLSocketDataProvider();
 
   void SetNextProto(SSLClientSocket::NextProto proto);
 
   MockConnect connect;
   SSLClientSocket::NextProtoStatus next_proto_status;
   std::string next_proto;
   std::string server_protos;
   bool was_npn_negotiated;
   SSLClientSocket::NextProto protocol_negotiated;
@@ skipping 762 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_