Add AllReadDataConsumed and AllWriteDataConsumed methods to SocketDataProvider

so that all provider subclasses can have their state verified.

Committed: https://crrev.com/bce10d97d6fc5233071427cf622aaad7abde9e19
Cr-Commit-Position: refs/heads/master@{#328154}

Review URL: https://codereview.chromium.org/1114383003

Cr-Commit-Position: refs/heads/master@{#328351}

14 files changed, 265 insertions, 234 deletions

diff --git a/jingle/glue/chrome_async_socket_unittest.cc b/jingle/glue/chrome_async_socket_unittest.cc
index 78b07a6..a785553 100644
--- a/jingle/glue/chrome_async_socket_unittest.cc
+++ b/jingle/glue/chrome_async_socket_unittest.cc
@@ -93,6 +93,14 @@ class AsyncSocketDataProvider : public net::SocketDataProvider {
     writes_.push_back(mock_write);
   }
 
+  bool AllReadDataConsumed() const override {
+    return reads_.empty();
+  }
+
+  bool AllWriteDataConsumed() const override {
+    return writes_.empty();
+  }
+
  private:
   std::deque<net::MockRead> reads_;
   bool has_pending_read_;
diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc
index 79e1687..c242658 100644
--- a/net/ftp/ftp_network_transaction_unittest.cc
+++ b/net/ftp/ftp_network_transaction_unittest.cc
@@ -128,6 +128,10 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider {
     Init();
   }
 
+  bool AllReadDataConsumed() const override { return state_ == QUIT; }
+
+  bool AllWriteDataConsumed() const override { return state_ == QUIT; }
+
   void set_multiline_welcome(bool multiline) { multiline_welcome_ = multiline; }
 
   bool use_epsv() const { return use_epsv_; }
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 74979b3..c3bcf25 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -162,7 +162,8 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
   }
 
   bool AtEof() {
-    return socket_data_->at_read_eof() && socket_data_->at_write_eof();
+    return socket_data_->AllReadDataConsumed() &&
+           socket_data_->AllWriteDataConsumed();
   }
 
   void ProcessPacket(scoped_ptr<QuicEncryptedPacket> packet) {
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 4472d40..7d23928 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -797,18 +797,18 @@ TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
   // Run the first request.
   http_data.StopAfter(arraysize(http_reads) + arraysize(http_writes));
   SendRequestAndExpectHttpResponse("hello world");
-  ASSERT_TRUE(http_data.at_read_eof());
-  ASSERT_TRUE(http_data.at_write_eof());
+  ASSERT_TRUE(http_data.AllReadDataConsumed());
+  ASSERT_TRUE(http_data.AllWriteDataConsumed());
 
   // Now run the second request in which the QUIC socket hangs,
   // and verify the the transaction continues over HTTP.
   http_data2.StopAfter(arraysize(http_reads) + arraysize(http_writes));
   SendRequestAndExpectHttpResponse("hello world");
 
-  ASSERT_TRUE(http_data2.at_read_eof());
-  ASSERT_TRUE(http_data2.at_write_eof());
-  ASSERT_TRUE(!quic_data.at_read_eof());
-  ASSERT_TRUE(!quic_data.at_write_eof());
+  ASSERT_TRUE(http_data2.AllReadDataConsumed());
+  ASSERT_TRUE(http_data2.AllWriteDataConsumed());
+  ASSERT_TRUE(!quic_data.AllReadDataConsumed());
+  ASSERT_TRUE(!quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
@@ -1078,8 +1078,8 @@ TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) {
 
   ExpectBrokenAlternateProtocolMapping();
 
-  EXPECT_TRUE(quic_data.at_read_eof());
-  EXPECT_TRUE(quic_data.at_write_eof());
+  EXPECT_TRUE(quic_data.AllReadDataConsumed());
+  EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) {
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index dd7865b..1c80bc4 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -296,8 +296,8 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
 
     factory_.OnSessionClosed(session);
     EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
-    EXPECT_TRUE(socket_data.at_read_eof());
-    EXPECT_TRUE(socket_data.at_write_eof());
+    EXPECT_TRUE(socket_data.AllReadDataConsumed());
+    EXPECT_TRUE(socket_data.AllWriteDataConsumed());
     return port;
   }
 
@@ -373,8 +373,8 @@ TEST_P(QuicStreamFactoryTest, Create) {
   stream = request2.ReleaseStream();  // Will reset stream 5.
   stream.reset();  // Will reset stream 7.
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
@@ -402,8 +402,8 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
@@ -437,8 +437,8 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
@@ -483,10 +483,10 @@ TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, host_port_pair_, !is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, Pooling) {
@@ -532,8 +532,8 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
           &factory_, host_port_pair_, is_https_),
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
@@ -585,10 +585,10 @@ TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
           &factory_, host_port_pair_, is_https_),
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
@@ -654,10 +654,10 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
@@ -717,8 +717,8 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
@@ -784,10 +784,10 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
@@ -851,10 +851,10 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
@@ -920,8 +920,8 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
@@ -993,10 +993,10 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
@@ -1066,10 +1066,10 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
             QuicStreamFactoryPeer::GetActiveSession(
                 &factory_, server2, is_https_));
 
-  EXPECT_TRUE(socket_data1.at_read_eof());
-  EXPECT_TRUE(socket_data1.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, Goaway) {
@@ -1131,10 +1131,10 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   stream2.reset();
   stream.reset();
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
@@ -1197,8 +1197,8 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
 
   EXPECT_EQ(OK, callback_.WaitForResult());
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   STLDeleteElements(&streams);
 }
 
@@ -1219,8 +1219,8 @@ TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
@@ -1241,8 +1241,8 @@ TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
 
   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CancelCreate) {
@@ -1271,8 +1271,8 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
   EXPECT_TRUE(stream.get());
   stream.reset();
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
@@ -1356,10 +1356,10 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
@@ -1420,10 +1420,10 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
@@ -1484,10 +1484,10 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
@@ -1548,10 +1548,10 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
@@ -1660,8 +1660,8 @@ TEST_P(QuicStreamFactoryTest, RacingConnections) {
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_EQ(0u,
             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
 }
@@ -1694,8 +1694,8 @@ TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
@@ -1828,12 +1828,12 @@ TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
   EXPECT_TRUE(stream2.get());
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
-  EXPECT_TRUE(socket_data.at_read_eof());
-  EXPECT_TRUE(socket_data.at_write_eof());
-  EXPECT_TRUE(socket_data2.at_read_eof());
-  EXPECT_TRUE(socket_data2.at_write_eof());
-  EXPECT_TRUE(socket_data3.at_read_eof());
-  EXPECT_TRUE(socket_data3.at_write_eof());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data3.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
 }
 
 }  // namespace test
diff --git a/net/socket/sequenced_socket_data_unittest.cc b/net/socket/sequenced_socket_data_unittest.cc
index e0ed320..3e1dbd3 100644
--- a/net/socket/sequenced_socket_data_unittest.cc
+++ b/net/socket/sequenced_socket_data_unittest.cc
@@ -242,8 +242,8 @@ SequencedSocketDataTest::~SequencedSocketDataTest() {
   // Make sure no unexpected pending tasks will cause a failure.
   base::RunLoop().RunUntilIdle();
   if (expect_eof_) {
-    EXPECT_EQ(expect_eof_, data_->at_read_eof());
-    EXPECT_EQ(expect_eof_, data_->at_write_eof());
+    EXPECT_EQ(expect_eof_, data_->AllReadDataConsumed());
+    EXPECT_EQ(expect_eof_, data_->AllWriteDataConsumed());
   }
 }
 
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index cf033c2..4df69d2 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -156,27 +156,27 @@ 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)
@@ -195,6 +195,14 @@ bool StaticSocketDataHelper::VerifyWriteData(const std::string& 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;
@@ -215,7 +223,7 @@ StaticSocketDataProvider::~StaticSocketDataProvider() {
 }
 
 MockRead StaticSocketDataProvider::OnRead() {
-  CHECK(!helper_.at_read_eof());
+  CHECK(!helper_.AllReadDataConsumed());
   return helper_.AdvanceRead();
 }
 
@@ -224,8 +232,8 @@ MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
     // 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);
@@ -248,6 +256,14 @@ 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) {
@@ -508,7 +524,7 @@ SequencedSocketData::SequencedSocketData(const MockConnect& 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();
@@ -520,7 +536,7 @@ MockRead SequencedSocketData::OnRead() {
     NET_TRACE(1, " *** ") << "Hanging read";
     helper_.AdvanceRead();
     ++sequence_number_;
-    CHECK(helper_.at_read_eof());
+    CHECK(helper_.AllReadDataConsumed());
     return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
   }
 
@@ -552,7 +568,7 @@ MockRead SequencedSocketData::OnRead() {
 
 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();
@@ -600,12 +616,12 @@ void SequencedSocketData::Reset() {
   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() {
@@ -725,7 +741,7 @@ void DeterministicSocketData::Run() {
   // 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) {
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index 3bd88d2..b4584ad 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -198,6 +198,8 @@ class SocketDataProvider {
   virtual MockRead OnRead() = 0;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset() = 0;
+  virtual bool AllReadDataConsumed() const = 0;
+  virtual bool AllWriteDataConsumed() const = 0;
 
   // Accessor for the socket which is using the SocketDataProvider.
   AsyncSocket* socket() { return socket_; }
@@ -258,14 +260,17 @@ class StaticSocketDataHelper {
   // in which case this method will still return true.
   bool VerifyWriteData(const std::string& data);
 
+  // Return true if all read data has been consumed.
+  bool AllReadDataConsumed() const;
+
+  // Return true if all write data has been consumed.
+  bool AllWriteDataConsumed() const;
+
   size_t read_index() const { return read_index_; }
   size_t write_index() const { return write_index_; }
   size_t read_count() const { return read_count_; }
   size_t write_count() const { return write_count_; }
 
-  bool at_read_eof() const { return read_index_ >= read_count_; }
-  bool at_write_eof() const { return write_index_ >= write_count_; }
-
  private:
   MockRead* reads_;
   size_t read_index_;
@@ -294,15 +299,14 @@ class StaticSocketDataProvider : public SocketDataProvider {
   MockRead OnRead() override;
   MockWriteResult OnWrite(const std::string& data) override;
   void Reset() override;
+  bool AllReadDataConsumed() const override;
+  bool AllWriteDataConsumed() const override;
 
   size_t read_index() const { return helper_.read_index(); }
   size_t write_index() const { return helper_.write_index(); }
   size_t read_count() const { return helper_.read_count(); }
   size_t write_count() const { return helper_.write_count(); }
 
-  bool at_read_eof() const { return helper_.at_read_eof(); }
-  bool at_write_eof() const { return helper_.at_write_eof(); }
-
  protected:
   StaticSocketDataHelper* helper() { return &helper_; }
 
@@ -499,12 +503,8 @@ class SequencedSocketData : public SocketDataProvider {
   MockRead OnRead() override;
   MockWriteResult OnWrite(const std::string& data) override;
   void Reset() override;
-
-  // Returns true if all data has been read.
-  bool at_read_eof() const;
-
-  // Returns true if all data has been written.
-  bool at_write_eof() const;
+  bool AllReadDataConsumed() const override;
+  bool AllWriteDataConsumed() const override;
 
  private:
   // Defines the state for the read or write path.
diff --git a/net/spdy/spdy_http_stream_unittest.cc b/net/spdy/spdy_http_stream_unittest.cc
index 6fecf45..9121cec 100644
--- a/net/spdy/spdy_http_stream_unittest.cc
+++ b/net/spdy/spdy_http_stream_unittest.cc
@@ -189,8 +189,8 @@ TEST_P(SpdyHttpStreamTest, SendRequest) {
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key));
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 
   TestLoadTimingNotReused(*http_stream);
   http_stream->Close(true);
@@ -351,8 +351,8 @@ TEST_P(SpdyHttpStreamTest, SendChunkedPost) {
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key));
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 }
 
 // Test to ensure the SpdyStream state machine does not get confused when a
@@ -454,8 +454,8 @@ TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPost) {
   deterministic_data()->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 }
 
 // Test that the SpdyStream state machine can handle sending a final empty data
@@ -540,8 +540,8 @@ TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithEmptyFinalDataFrame) {
   deterministic_data()->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 }
 
 // Test that the SpdyStream state machine handles a chunked upload with no
@@ -610,8 +610,8 @@ TEST_P(SpdyHttpStreamTest, ChunkedPostWithEmptyPayload) {
   deterministic_data()->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 }
 
 // Test case for bug: http://code.google.com/p/chromium/issues/detail?id=50058
@@ -656,8 +656,8 @@ TEST_P(SpdyHttpStreamTest, SpdyURLTest) {
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key));
-  EXPECT_TRUE(deterministic_data()->at_read_eof());
-  EXPECT_TRUE(deterministic_data()->at_write_eof());
+  EXPECT_TRUE(deterministic_data()->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data()->AllWriteDataConsumed());
 }
 
 // The tests below are only for SPDY/3 and above.
@@ -747,8 +747,8 @@ TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithWindowUpdate) {
   deterministic_data_->RunFor(1);
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
-  EXPECT_TRUE(deterministic_data_->at_read_eof());
-  EXPECT_TRUE(deterministic_data_->at_write_eof());
+  EXPECT_TRUE(deterministic_data_->AllReadDataConsumed());
+  EXPECT_TRUE(deterministic_data_->AllWriteDataConsumed());
 }
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index 0e5a701..c88108f 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -270,14 +270,12 @@ class SpdyNetworkTransactionTest
     void VerifyDataConsumed() {
       for (DataVector::iterator it = data_vector_.begin();
           it != data_vector_.end(); ++it) {
-        EXPECT_TRUE((*it)->at_read_eof()) << "Read count: "
-                                          << (*it)->read_count()
-                                          << " Read index: "
-                                          << (*it)->read_index();
-        EXPECT_TRUE((*it)->at_write_eof()) << "Write count: "
-                                           << (*it)->write_count()
-                                           << " Write index: "
-                                           << (*it)->write_index();
+        EXPECT_TRUE((*it)->AllReadDataConsumed())
+            << "Read count: " << (*it)->read_count()
+            << " Read index: " << (*it)->read_index();
+        EXPECT_TRUE((*it)->AllWriteDataConsumed())
+            << "Write count: " << (*it)->write_count()
+            << " Write index: " << (*it)->write_index();
       }
     }
 
@@ -287,14 +285,12 @@ class SpdyNetworkTransactionTest
     void VerifyDataNotConsumed() {
       for (DataVector::iterator it = data_vector_.begin();
           it != data_vector_.end(); ++it) {
-        EXPECT_TRUE(!(*it)->at_read_eof()) << "Read count: "
-                                           << (*it)->read_count()
-                                           << " Read index: "
-                                           << (*it)->read_index();
-        EXPECT_TRUE(!(*it)->at_write_eof()) << "Write count: "
-                                            << (*it)->write_count()
-                                            << " Write index: "
-                                            << (*it)->write_index();
+        EXPECT_TRUE(!(*it)->AllReadDataConsumed())
+            << "Read count: " << (*it)->read_count()
+            << " Read index: " << (*it)->read_index();
+        EXPECT_TRUE(!(*it)->AllWriteDataConsumed())
+            << "Write count: " << (*it)->write_count()
+            << " Write index: " << (*it)->write_index();
       }
     }
 
@@ -647,8 +643,8 @@ class SpdyNetworkTransactionTest
     ReadResult(trans, data, &result);
 
     // Verify that we consumed all test data.
-    EXPECT_TRUE(data->at_read_eof());
-    EXPECT_TRUE(data->at_write_eof());
+    EXPECT_TRUE(data->AllReadDataConsumed());
+    EXPECT_TRUE(data->AllWriteDataConsumed());
 
     // Verify that the received push data is same as the expected push data.
     EXPECT_EQ(result2.compare(expected), 0) << "Received data: "
@@ -2488,10 +2484,10 @@ TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectGetRequest) {
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data2.at_read_eof());
-  EXPECT_TRUE(data2.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data2.AllReadDataConsumed());
+  EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 // Send a spdy request to www.example.org. Get a pushed stream that redirects to
@@ -2583,10 +2579,10 @@ TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectServerPush) {
   }
   data.CompleteRead();
   data2.CompleteRead();
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data2.at_read_eof());
-  EXPECT_TRUE(data2.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data2.AllReadDataConsumed());
+  EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
@@ -2761,14 +2757,12 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) {
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed())
+      << "Read count: " << data.read_count()
+      << " Read index: " << data.read_index();
+  EXPECT_TRUE(data.AllWriteDataConsumed())
+      << "Write count: " << data.write_count()
+      << " Write index: " << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
@@ -2986,14 +2980,12 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed())
+      << "Read count: " << data.read_count()
+      << " Read index: " << data.read_index();
+  EXPECT_TRUE(data.AllWriteDataConsumed())
+      << "Write count: " << data.write_count()
+      << " Write index: " << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
@@ -3043,14 +3035,12 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) {
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed())
+      << "Read count: " << data.read_count()
+      << " Read index: " << data.read_index();
+  EXPECT_TRUE(data.AllWriteDataConsumed())
+      << "Write count: " << data.write_count()
+      << " Write index: " << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
@@ -3103,14 +3093,12 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) {
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed())
+      << "Read count: " << data.read_count()
+      << " Read index: " << data.read_index();
+  EXPECT_TRUE(data.AllWriteDataConsumed())
+      << "Write count: " << data.write_count()
+      << " Write index: " << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
@@ -3579,8 +3567,8 @@ TEST_P(SpdyNetworkTransactionTest, WriteError) {
   EXPECT_TRUE(helper.StartDefaultTest());
   data.RunFor(2);
   helper.FinishDefaultTest();
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(!data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(!data.AllReadDataConsumed());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_FAILED, out.rv);
 }
@@ -5278,8 +5266,8 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) {
   data.RunFor(1);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // TODO(baranovich): HTTP 2 does not allow multiple HEADERS frames
@@ -5418,8 +5406,8 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushWithTwoHeaderFrames) {
   data.RunFor(1);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) {
@@ -5525,8 +5513,8 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) {
   data.RunFor(1);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) {
@@ -5714,8 +5702,8 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
     ReadResult(trans, &data, &result);
 
     // Verify that we consumed all test data.
-    EXPECT_TRUE(data.at_read_eof());
-    EXPECT_TRUE(data.at_write_eof());
+    EXPECT_TRUE(data.AllReadDataConsumed());
+    EXPECT_TRUE(data.AllWriteDataConsumed());
 
     // Verify the SYN_REPLY.
     // Copy the response info, because trans goes away.
@@ -5770,14 +5758,12 @@ TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) {
   EXPECT_EQ(OK, rv);
 
   // Verify that we consumed all test data.
-  EXPECT_TRUE(data.at_read_eof()) << "Read count: "
-                                   << data.read_count()
-                                   << " Read index: "
-                                   << data.read_index();
-  EXPECT_TRUE(data.at_write_eof()) << "Write count: "
-                                    << data.write_count()
-                                    << " Write index: "
-                                    << data.write_index();
+  EXPECT_TRUE(data.AllReadDataConsumed())
+      << "Read count: " << data.read_count()
+      << " Read index: " << data.read_index();
+  EXPECT_TRUE(data.AllWriteDataConsumed())
+      << "Write count: " << data.write_count()
+      << " Write index: " << data.write_index();
 
   // Verify the SYN_REPLY.
   HttpResponseInfo response = *trans->GetResponseInfo();
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index 241b25b..a8196e4 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -1590,7 +1590,7 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
       CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
 
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdySessionTest, ClearSettingsStorageOnIPAddressChanged) {
@@ -2767,8 +2767,8 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
   // Verify task observer's executed_count is zero, which indicates DoRead read
   // all the available data.
   EXPECT_EQ(0u, observer.executed_count());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 }
 
 // Test that SpdySession::DoReadLoop yields while reading the
@@ -2859,8 +2859,8 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
   // posted only one task and thus yielded though there is data available for it
   // to read.
   EXPECT_EQ(1u, observer.executed_count());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 }
 
 // Test that SpdySession::DoReadLoop() tests interactions of yielding
@@ -2970,8 +2970,8 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
   // posted only one task and thus yielded though there is data available for
   // it to read.
   EXPECT_EQ(1u, observer.executed_count());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 }
 
 // Send a GoAway frame when SpdySession is in DoReadLoop. Make sure
@@ -3030,8 +3030,8 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
   // Run until GoAway.
   data.RunFor(3);
   EXPECT_EQ(NULL, spdy_stream1.get());
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(session == NULL);
 }
 
@@ -3938,8 +3938,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
 
   data.RunFor(4);
 
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 
   EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
@@ -4018,8 +4018,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
 
   data.RunFor(1);
 
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 
   EXPECT_EQ(initial_window_size - msg_data_size,
             session->session_send_window_size_);
@@ -4140,8 +4140,8 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
             session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
-  EXPECT_TRUE(data.at_write_eof());
-  EXPECT_TRUE(data.at_read_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+  EXPECT_TRUE(data.AllReadDataConsumed());
 
   EXPECT_EQ(msg_data, delegate.TakeReceivedData());
 
@@ -4239,7 +4239,7 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Run the resume-after-unstall test with all possible stall and
@@ -4440,7 +4440,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Delegate that closes a given stream after sending its body.
@@ -4626,7 +4626,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
   EXPECT_TRUE(delegate3.send_headers_completed());
   EXPECT_EQ(std::string(), delegate3.TakeReceivedData());
 
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Cause a stall by reducing the flow control send window to
@@ -4740,7 +4740,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdySessionTest, GoAwayOnSessionFlowControlError) {
diff --git a/net/spdy/spdy_stream_unittest.cc b/net/spdy/spdy_stream_unittest.cc
index cb42286..f538e0f 100644
--- a/net/spdy/spdy_stream_unittest.cc
+++ b/net/spdy/spdy_stream_unittest.cc
@@ -172,7 +172,7 @@ TEST_P(SpdyStreamTest, SendDataAfterOpen) {
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
             delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyStreamTest, PushedStream) {
@@ -292,7 +292,7 @@ TEST_P(SpdyStreamTest, StreamError) {
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
             delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 
   // Check that the NetLog was filled reasonably.
   TestNetLogEntry::List entries;
@@ -372,7 +372,7 @@ TEST_P(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) {
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Make sure that large blocks of data are properly split up into
@@ -435,7 +435,7 @@ TEST_P(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) {
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Receiving a header with uppercase ASCII should result in a protocol
@@ -875,7 +875,7 @@ void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseRequestResponse) {
@@ -964,7 +964,7 @@ void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
             delegate.TakeReceivedData());
-  EXPECT_TRUE(data.at_write_eof());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseBidirectional) {
diff --git a/remoting/base/buffered_socket_writer_unittest.cc b/remoting/base/buffered_socket_writer_unittest.cc
index 0c74044..07bb2ec 100644
--- a/remoting/base/buffered_socket_writer_unittest.cc
+++ b/remoting/base/buffered_socket_writer_unittest.cc
@@ -45,6 +45,14 @@ class SocketDataProvider: public net::SocketDataProvider {
                                 size);
   }
 
+  bool AllReadDataConsumed() const override {
+    return true;
+  }
+
+  bool AllWriteDataConsumed() const override {
+    return true;
+  }
+
   void Reset() override {}
 
   std::string written_data() { return written_data_; }
diff --git a/remoting/signaling/xmpp_signal_strategy_unittest.cc b/remoting/signaling/xmpp_signal_strategy_unittest.cc
index b4c4a53..2193982 100644
--- a/remoting/signaling/xmpp_signal_strategy_unittest.cc
+++ b/remoting/signaling/xmpp_signal_strategy_unittest.cc
@@ -29,6 +29,14 @@ class XmppSocketDataProvider: public net::SocketDataProvider {
 
   void Reset() override {}
 
+  bool AllReadDataConsumed() const override {
+    return true;
+  }
+
+  bool AllWriteDataConsumed() const override {
+    return true;
+  }
+
   void ReceiveData(const std::string& text) {
     socket()->OnReadComplete(
         net::MockRead(net::ASYNC, text.data(), text.size()));