Remove redundant at_read_eof and at_write_eof methods.

net/quic/quic_network_transaction_unittest.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 <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 805 matching lines @@
   // The HTTP transaction will complete.
   DeterministicSocketData http_data2(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   socket_factory.AddSocketDataProvider(&http_data2);
 
   CreateSessionWithFactory(&socket_factory, true);
 
   // 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) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddRead(
       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
                                      GetResponseHeaders("200 OK")));
@@ skipping 249 matching lines @@
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSessionWithNextProtos();
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
   SendRequestAndExpectHttpResponse("hello from http");
 
   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) {
   // Alternate-protocol job
   MockRead quic_reads[] = {
     MockRead(ASYNC, ERR_IO_PENDING),
   };
   StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
@@ skipping 139 matching lines @@
 
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 }  // namespace test
 }  // namespace net