Add AllReadDataConsumed and AllWriteDataConsumed methods to SocketDataProvider

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 138 matching lines @@
       read_count_(reads_count),
       writes_(writes),
       write_index_(0),
       write_count_(writes_count) {
 }
 
 StaticSocketDataHelper::~StaticSocketDataHelper() {
 }
 
 const MockRead& StaticSocketDataHelper::PeekRead() const {
-  CHECK(!at_read_eof());
+  CHECK(!AllReadDataConsumed());
   return reads_[read_index_];
 }
 
 const MockWrite& StaticSocketDataHelper::PeekWrite() const {
-  CHECK(!at_write_eof());
+  CHECK(!AllWriteDataConsumed());
   return writes_[write_index_];
 }
 
 const MockRead& StaticSocketDataHelper::AdvanceRead() {
-  CHECK(!at_read_eof());
+  CHECK(!AllReadDataConsumed());
   return reads_[read_index_++];
 }
 
 const MockWrite& StaticSocketDataHelper::AdvanceWrite() {
-  CHECK(!at_write_eof());
+  CHECK(!AllWriteDataConsumed());
   return writes_[write_index_++];
 }
 
 bool StaticSocketDataHelper::VerifyWriteData(const std::string& data) {
-  CHECK(!at_write_eof());
+  CHECK(!AllWriteDataConsumed());
   // Check that what the actual data matches the expectations.
   const MockWrite& next_write = PeekWrite();
   if (!next_write.data)
     return true;
 
   // Note: Partial writes are supported 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 the function returns true.
   std::string expected_data(next_write.data, next_write.data_len);
   std::string actual_data(data.substr(0, next_write.data_len));
   EXPECT_GE(data.length(), expected_data.length());
   EXPECT_EQ(expected_data, actual_data);
   return expected_data == actual_data;
 }
 
+bool StaticSocketDataHelper::AllReadDataConsumed() const {
+  return read_index_ >= read_count_;
+}
+
+bool StaticSocketDataHelper::AllWriteDataConsumed() const {
+  return write_index_ >= write_count_;
+}
+
 void StaticSocketDataHelper::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider()
     : StaticSocketDataProvider(nullptr, 0, nullptr, 0) {
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
                                                    size_t reads_count,
                                                    MockWrite* writes,
                                                    size_t writes_count)
     : helper_(reads, reads_count, writes, writes_count) {
 }
 
 StaticSocketDataProvider::~StaticSocketDataProvider() {
 }
 
 MockRead StaticSocketDataProvider::OnRead() {
-  CHECK(!helper_.at_read_eof());
+  CHECK(!helper_.AllReadDataConsumed());
   return helper_.AdvanceRead();
 }
 
 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (helper_.write_count() == 0) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(SYNCHRONOUS, data.length());
   }
-  EXPECT_FALSE(helper_.at_write_eof());
-  if (helper_.at_write_eof()) {
+  EXPECT_FALSE(helper_.AllWriteDataConsumed());
+  if (helper_.AllWriteDataConsumed()) {
     // Show what the extra write actually consists of.
     EXPECT_EQ("<unexpected write>", data);
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
   if (!helper_.VerifyWriteData(data))
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
 
   const MockWrite& next_write = helper_.AdvanceWrite();
   // In the case that the write was successful, return the number of bytes
   // written. Otherwise return the error code.
   int result =
       next_write.result == OK ? next_write.data_len : next_write.result;
   return MockWriteResult(next_write.mode, result);
 }
 
 void StaticSocketDataProvider::Reset() {
   helper_.Reset();
 }
 
+bool StaticSocketDataProvider::AllReadDataConsumed() const {
+  return helper_.AllReadDataConsumed();
+}
+
+bool StaticSocketDataProvider::AllWriteDataConsumed() const {
+  return helper_.AllWriteDataConsumed();
+}
+
 DynamicSocketDataProvider::DynamicSocketDataProvider()
     : short_read_limit_(0),
       allow_unconsumed_reads_(false) {
 }
 
 DynamicSocketDataProvider::~DynamicSocketDataProvider() {}
 
 MockRead DynamicSocketDataProvider::OnRead() {
   if (reads_.empty())
     return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
@@ skipping 240 matching lines @@
                                          MockRead* reads,
                                          size_t reads_count,
                                          MockWrite* writes,
                                          size_t writes_count)
     : SequencedSocketData(reads, reads_count, writes, writes_count) {
   set_connect_data(connect);
 }
 
 MockRead SequencedSocketData::OnRead() {
   CHECK_EQ(IDLE, read_state_);
-  CHECK(!helper_.at_read_eof());
+  CHECK(!helper_.AllReadDataConsumed());
 
   NET_TRACE(1, " *** ") << "sequence_number: " << sequence_number_;
   const MockRead& next_read = helper_.PeekRead();
   NET_TRACE(1, " *** ") << "next_read: " << next_read.sequence_number;
   CHECK_GE(next_read.sequence_number, sequence_number_);
 
   // Special case handling for hanging reads.
   if (next_read.mode == ASYNC && next_read.result == ERR_IO_PENDING) {
     NET_TRACE(1, " *** ") << "Hanging read";
     helper_.AdvanceRead();
     ++sequence_number_;
-    CHECK(helper_.at_read_eof());
+    CHECK(helper_.AllReadDataConsumed());
     return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
   }
 
   if (next_read.sequence_number <= sequence_number_) {
     if (next_read.mode == SYNCHRONOUS) {
       NET_TRACE(1, " *** ") << "Returning synchronously";
       DumpMockReadWrite(next_read);
       helper_.AdvanceRead();
       ++sequence_number_;
       MaybePostWriteCompleteTask();
@@ skipping 11 matching lines @@
   } else {
     NET_TRACE(1, " *** ") << "Waiting for write to trigger read";
     read_state_ = PENDING;
   }
 
   return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
 }
 
 MockWriteResult SequencedSocketData::OnWrite(const std::string& data) {
   CHECK_EQ(IDLE, write_state_);
-  CHECK(!helper_.at_write_eof());
+  CHECK(!helper_.AllWriteDataConsumed());
 
   NET_TRACE(1, " *** ") << "sequence_number: " << sequence_number_;
   const MockWrite& next_write = helper_.PeekWrite();
   NET_TRACE(1, " *** ") << "next_write: " << next_write.sequence_number;
   CHECK_GE(next_write.sequence_number, sequence_number_);
 
   if (!helper_.VerifyWriteData(data))
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
 
   if (next_write.sequence_number <= sequence_number_) {
@@ skipping 27 matching lines @@
 }
 
 void SequencedSocketData::Reset() {
   helper_.Reset();
   sequence_number_ = 0;
   read_state_ = IDLE;
   write_state_ = IDLE;
   weak_factory_.InvalidateWeakPtrs();
 }
 
-bool SequencedSocketData::at_read_eof() const {
-  return helper_.at_read_eof();
+bool SequencedSocketData::AllReadDataConsumed() const {
+  return helper_.AllReadDataConsumed();
 }
 
-bool SequencedSocketData::at_write_eof() const {
-  return helper_.at_read_eof();
+bool SequencedSocketData::AllWriteDataConsumed() const {
+  return helper_.AllWriteDataConsumed();
 }
 
 void SequencedSocketData::MaybePostReadCompleteTask() {
   NET_TRACE(1, " ****** ") << " current: " << sequence_number_;
   // Only trigger the next read to complete if there is already a read pending
   // which should complete at the current sequence number.
   if (read_state_ != PENDING ||
       helper_.PeekRead().sequence_number != sequence_number_) {
     return;
   }
@@ skipping 99 matching lines @@
   DCHECK(!is_running_);
   is_running_ = true;
 
   SetStopped(false);
   int counter = 0;
   // Continue to consume data until all data has run out, or the stopped_ flag
   // has been set. Consuming data requires two separate operations -- running
   // the tasks in the message loop, and explicitly invoking the read/write
   // callbacks (simulating network I/O). We check our conditions between each,
   // since they can change in either.
-  while ((!at_write_eof() || !at_read_eof()) && !stopped()) {
+  while ((!AllWriteDataConsumed() || !AllReadDataConsumed()) && !stopped()) {
     if (counter % 2 == 0)
       base::RunLoop().RunUntilIdle();
     if (counter % 2 == 1) {
       InvokeCallbacks();
     }
     counter++;
   }
   // We're done consuming new data, but it is possible there are still some
   // pending callbacks which we expect to complete before returning.
   while (delegate_.get() &&
@@ skipping 1440 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