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 m, int r) : mode(m), 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 m, int result) : mode(m), result(result),

[jar (doing other things), 2012/02/22 17:38:25]

Style guide would probably argue against using "m" as an abbreviation for
mode.... but in this case, the code would probably look worse if you used
"mode".   

Either leave it as is.... or use the parameter name io_mode to initialize the
struct member |mode|.

[Ryan Hamilton, 2012/02/22 17:50:10]

Done.

+      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 m, int result, int seq) : mode(m),
+      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 m, const char* data) : mode(m), 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 m, const char* data, int data_len) : mode(m),
       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 m, int seq, const char* data) : mode(m),
       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 m, const char* data, int data_len, int seq) :
+      mode(m), 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 m, int result) : mode(m), 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();
 
   MockConnect connect;
   SSLClientSocket::NextProtoStatus next_proto_status;
   std::string next_proto;
   std::string server_protos;
   bool was_npn_negotiated;
   SSLClientSocket::NextProto protocol_negotiated;
   bool client_cert_sent;
   SSLCertRequestInfo* cert_request_info;
@@ skipping 760 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_