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

net/socket/socket_test_util.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 "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 89 matching lines @@
                  << Asciify(data[i + 0])
                  << "   '";
         break;
     }
   }
 }
 
 void DumpMockRead(const MockRead& r) {
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
-  DVLOG(1) << "Async:   " << r.async
+  DVLOG(1) << "Async:   " << (r.mode == ASYNC)
            << "\nResult:  " << r.result;
   DumpData(r.data, r.data_len);
   const char* stop = (r.sequence_number & MockRead::STOPLOOP) ? " (STOP)" : "";
   DVLOG(1) << "Stage:   " << (r.sequence_number & ~MockRead::STOPLOOP) << stop
            << "\nTime:    " << r.time_stamp.ToInternalValue();
 }
 
 }  // namespace
 
 StaticSocketDataProvider::StaticSocketDataProvider()
@@ skipping 41 matching lines @@
 
 MockRead StaticSocketDataProvider::GetNextRead() {
   DCHECK(!at_read_eof());
   reads_[read_index_].time_stamp = base::Time::Now();
   return reads_[read_index_++];
 }
 
 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
-    return MockWriteResult(false, data.length());
+    return MockWriteResult(SYNCHRONOUS, data.length());
   }
-
+  LOG(INFO) << "about to write: " << data;
   DCHECK(!at_write_eof());
 
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
   MockWrite* w = &writes_[write_index_++];
   w->time_stamp = base::Time::Now();
   int result = w->result;
   if (w->data) {
     // Note - we can simulate a partial write here.  If the expected data
     // is a match, but shorter than the write actually written, that is legal.
     // Example:
     //   Application writes "foobarbaz" (9 bytes)
     //   Expected write was "foo" (3 bytes)
     //   This is a success, and we return 3 to the application.
     std::string expected_data(w->data, w->data_len);
     EXPECT_GE(data.length(), expected_data.length());
     std::string actual_data(data.substr(0, w->data_len));
     EXPECT_EQ(expected_data, actual_data);
     if (expected_data != actual_data)
-      return MockWriteResult(false, ERR_UNEXPECTED);
+      return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
     if (result == OK)
       result = w->data_len;
   }
-  return MockWriteResult(w->async, result);
+  return MockWriteResult(w->mode, result);
 }
 
 void StaticSocketDataProvider::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
 DynamicSocketDataProvider::DynamicSocketDataProvider()
     : short_read_limit_(0),
       allow_unconsumed_reads_(false) {
 }
 
 DynamicSocketDataProvider::~DynamicSocketDataProvider() {}
 
 MockRead DynamicSocketDataProvider::GetNextRead() {
   if (reads_.empty())
-    return MockRead(false, ERR_UNEXPECTED);
+    return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   MockRead result = reads_.front();
   if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
     reads_.pop_front();
   } else {
     result.data_len = short_read_limit_;
     reads_.front().data += result.data_len;
     reads_.front().data_len -= result.data_len;
   }
   return result;
 }
 
 void DynamicSocketDataProvider::Reset() {
   reads_.clear();
 }
 
 void DynamicSocketDataProvider::SimulateRead(const char* data,
                                              const size_t length) {
   if (!allow_unconsumed_reads_) {
     EXPECT_TRUE(reads_.empty()) << "Unconsumed read: " << reads_.front().data;
   }
-  reads_.push_back(MockRead(true, data, length));
+  reads_.push_back(MockRead(ASYNC, data, length));
 }
 
-SSLSocketDataProvider::SSLSocketDataProvider(bool async, int result)
-    : connect(async ? ASYNC : SYNCHRONOUS, result),
+SSLSocketDataProvider::SSLSocketDataProvider(IoMode mode, int result)
+    : connect(mode, result),
       next_proto_status(SSLClientSocket::kNextProtoUnsupported),
       was_npn_negotiated(false),
       protocol_negotiated(SSLClientSocket::kProtoUnknown),
       client_cert_sent(false),
       cert_request_info(NULL),
       origin_bound_cert_type(CLIENT_CERT_INVALID_TYPE) {
 }
 
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
@@ skipping 22 matching lines @@
 DelayedSocketData::~DelayedSocketData() {
 }
 
 void DelayedSocketData::ForceNextRead() {
   DCHECK(read_in_progress_);
   write_delay_ = 0;
   CompleteRead();
 }
 
 MockRead DelayedSocketData::GetNextRead() {
-  MockRead out = MockRead(true, ERR_IO_PENDING);
+  MockRead out = MockRead(ASYNC, ERR_IO_PENDING);
   if (write_delay_ <= 0)
     out = StaticSocketDataProvider::GetNextRead();
   read_in_progress_ = (out.result == ERR_IO_PENDING);
   return out;
 }
 
 MockWriteResult DelayedSocketData::OnWrite(const std::string& data) {
   MockWriteResult rv = StaticSocketDataProvider::OnWrite(data);
   // Now that our write has completed, we can allow reads to continue.
   if (!--write_delay_ && read_in_progress_)
@@ skipping 64 matching lines @@
   if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
       sequence_number_++) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                               << ": Read " << read_index();
     DumpMockRead(next_read);
     blocked_ = (next_read.result == ERR_IO_PENDING);
     return StaticSocketDataProvider::GetNextRead();
   }
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                             << ": I/O Pending";
-  MockRead result = MockRead(true, ERR_IO_PENDING);
+  MockRead result = MockRead(ASYNC, ERR_IO_PENDING);
   DumpMockRead(result);
   blocked_ = true;
   return result;
 }
 
 MockWriteResult OrderedSocketData::OnWrite(const std::string& data) {
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Write " << write_index();
   DumpMockRead(PeekWrite());
   ++sequence_number_;
@@ skipping 82 matching lines @@
 
 void DeterministicSocketData::StopAfter(int seq) {
   SetStop(sequence_number_ + seq);
 }
 
 MockRead DeterministicSocketData::GetNextRead() {
   current_read_ = StaticSocketDataProvider::PeekRead();
   EXPECT_LE(sequence_number_, current_read_.sequence_number);
 
   // Synchronous read while stopped is an error
-  if (stopped() && !current_read_.async) {
+  if (stopped() && current_read_.mode == SYNCHRONOUS) {
     LOG(ERROR) << "Unable to perform synchronous IO while stopped";
-    return MockRead(false, ERR_UNEXPECTED);
+    return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async read which will be called back in a future step.
   if (sequence_number_ < current_read_.sequence_number) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                               << ": I/O Pending";
-    MockRead result = MockRead(false, ERR_IO_PENDING);
-    if (!current_read_.async) {
+    MockRead result = MockRead(SYNCHRONOUS, ERR_IO_PENDING);
+    if (current_read_.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous read: "
           << current_read_.sequence_number
           << " at stage: " << sequence_number_;
-      result = MockRead(false, ERR_UNEXPECTED);
+      result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
     }
     if (print_debug_)
       DumpMockRead(result);
     return result;
   }
 
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Read " << read_index();
   if (print_debug_)
     DumpMockRead(current_read_);
 
   // Increment the sequence number if IO is complete
-  if (!current_read_.async)
+  if (current_read_.mode == SYNCHRONOUS)
     NextStep();
 
   DCHECK_NE(ERR_IO_PENDING, current_read_.result);
   StaticSocketDataProvider::GetNextRead();
 
   return current_read_;
 }
 
 MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) {
   const MockWrite& next_write = StaticSocketDataProvider::PeekWrite();
   current_write_ = next_write;
 
   // Synchronous write while stopped is an error
-  if (stopped() && !next_write.async) {
+  if (stopped() && next_write.mode == SYNCHRONOUS) {
     LOG(ERROR) << "Unable to perform synchronous IO while stopped";
-    return MockWriteResult(false, ERR_UNEXPECTED);
+    return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async write which will be called back in a future step.
   if (sequence_number_ < next_write.sequence_number) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                               << ": I/O Pending";
-    if (!next_write.async) {
+    if (next_write.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous write: "
           << next_write.sequence_number << " at stage: " << sequence_number_;
-      return MockWriteResult(false, ERR_UNEXPECTED);
+      return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
     }
   } else {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                               << ": Write " << write_index();
   }
 
   if (print_debug_)
     DumpMockRead(next_write);
 
   // Move to the next step if I/O is synchronous, since the operation will
   // complete when this method returns.
-  if (!next_write.async)
+  if (next_write.mode == SYNCHRONOUS)
     NextStep();
 
   // This is either a sync write for this step, or an async write.
   return StaticSocketDataProvider::OnWrite(data);
 }
 
 void DeterministicSocketData::Reset() {
   NET_TRACE(INFO, "  *** ") << "Stage "
                             << sequence_number_ << ": Reset()";
   sequence_number_ = 0;
@@ skipping 170 matching lines @@
 }
 
 MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses,
                                          net::NetLog* net_log,
                                          SocketDataProvider* data)
     : MockClientSocket(net_log),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       num_bytes_read_(0),
-      read_data_(false, ERR_UNEXPECTED),
+      read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_buf_(NULL),
       pending_buf_len_(0),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockTCPClientSocket::~MockTCPClientSocket() {}
@@ skipping 38 matching lines @@
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   was_used_to_convey_data_ = true;
 
-  if (write_result.async) {
+  if (write_result.mode == ASYNC) {
     RunCallbackAsync(callback, write_result.result);
     return ERR_IO_PENDING;
   }
 
   return write_result.result;
 }
 
 int MockTCPClientSocket::Connect(const CompletionCallback& callback) {
   if (connected_)
     return OK;
   connected_ = true;
   peer_closed_connection_ = false;
-  if (data_->connect_data().async) {
+  if (data_->connect_data().mode == ASYNC) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
 
 void MockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   pending_callback_.Reset();
 }
@@ skipping 37 matching lines @@
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
-  read_data_.async = false;
+  read_data_.mode = SYNCHRONOUS;
 
   CompletionCallback callback = pending_callback_;
   int rv = CompleteRead();
   RunCallback(callback, rv);
 }
 
 int MockTCPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
@@ skipping 18 matching lines @@
       num_bytes_read_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
-  if (read_data_.async) {
+  if (read_data_.mode == ASYNC) {
     DCHECK(!callback.is_null());
     RunCallbackAsync(callback, result);
     return ERR_IO_PENDING;
   }
   return result;
 }
 
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
     net::NetLog* net_log, DeterministicSocketData* data)
     : MockClientSocket(net_log),
@@ skipping 17 matching lines @@
 int DeterministicMockTCPClientSocket::CompleteRead() {
   DCHECK_GT(read_buf_len_, 0);
   DCHECK_LE(read_data_.data_len, read_buf_len_);
   DCHECK(read_buf_);
 
   was_used_to_convey_data_ = true;
 
   if (read_data_.result == ERR_IO_PENDING)
     read_data_ = data_->GetNextRead();
   DCHECK_NE(ERR_IO_PENDING, read_data_.result);
-  // If read_data_.async is true, we do not need to wait, since this is already
+  // If read_data_.mode is ASYNC, we do not need to wait, since this is already
   // the callback. Therefore we don't even bother to check it.
   int result = read_data_.result;
 
   if (read_data_.data_len > 0) {
     DCHECK(read_data_.data);
     result = std::min(read_buf_len_, read_data_.data_len);
     memcpy(read_buf_->data(), read_data_.data, result);
   }
 
   if (read_pending_) {
     read_pending_ = false;
     read_callback_.Run(result);
   }
 
   return result;
 }
 
 int DeterministicMockTCPClientSocket::Write(
     IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
-  if (write_result.async) {
+  if (write_result.mode == ASYNC) {
     write_callback_ = callback;
     write_result_ = write_result.result;
     DCHECK(!write_callback_.is_null());
     write_pending_ = true;
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   return write_result.result;
 }
 
 int DeterministicMockTCPClientSocket::Read(
     IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   read_data_ = data_->GetNextRead();
   // The buffer should always be big enough to contain all the MockRead data. To
   // use small buffers, split the data into multiple MockReads.
   DCHECK_LE(read_data_.data_len, buf_len);
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
 
-  if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
+  if (read_data_.mode == ASYNC || (read_data_.result == ERR_IO_PENDING)) {
     read_pending_ = true;
     DCHECK(!read_callback_.is_null());
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   return CompleteRead();
 }
 
 // TODO(erikchen): Support connect sequencing.
 int DeterministicMockTCPClientSocket::Connect(
     const CompletionCallback& callback) {
   if (connected_)
     return OK;
   connected_ = true;
-  if (data_->connect_data().async) {
+  if (data_->connect_data().mode == ASYNC) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
 
 void DeterministicMockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
 }
 
@@ skipping 63 matching lines @@
                                const CompletionCallback& callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
   int rv = transport_->socket()->Connect(
       base::Bind(&ConnectCallback, base::Unretained(this), callback));
   if (rv == OK) {
     if (data_->connect.result == OK)
       connected_ = true;
-    if (data_->connect.async) {
+    if (data_->connect.mode == ASYNC) {
       RunCallbackAsync(callback, data_->connect.result);
       return ERR_IO_PENDING;
     }
     return data_->connect.result;
   }
   return rv;
 }
 
 void MockSSLClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
@@ skipping 88 matching lines @@
 
 void MockSSLClientSocket::OnReadComplete(const MockRead& data) {
   NOTIMPLEMENTED();
 }
 
 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
-      read_data_(false, ERR_UNEXPECTED),
+      read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       pending_buf_(NULL),
       pending_buf_len_(0),
       net_log_(net::NetLog::Source(), net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {}
@@ skipping 30 matching lines @@
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
-  if (write_result.async) {
+  if (write_result.mode == ASYNC) {
     RunCallbackAsync(callback, write_result.result);
     return ERR_IO_PENDING;
   }
   return write_result.result;
 }
 
 bool MockUDPClientSocket::SetReceiveBufferSize(int32 size) {
   return true;
 }
 
@@ skipping 30 matching lines @@
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
-  read_data_.async = false;
+  read_data_.mode = SYNCHRONOUS;
 
   net::CompletionCallback callback = pending_callback_;
   int rv = CompleteRead();
   RunCallback(callback, rv);
 }
 
 int MockUDPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
@@ skipping 15 matching lines @@
       read_offset_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
-  if (read_data_.async) {
+  if (read_data_.mode == ASYNC) {
     DCHECK(!callback.is_null());
     RunCallbackAsync(callback, result);
     return ERR_IO_PENDING;
   }
   return result;
 }
 
 void MockUDPClientSocket::RunCallbackAsync(const CompletionCallback& callback,
                                            int result) {
   MessageLoop::current()->PostTask(
@@ skipping 264 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net