Add AllReadDataConsumed and AllWriteDataConsumed methods to SocketDataProvider

net/spdy/spdy_http_stream_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 "net/spdy/spdy_http_stream.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 171 matching lines @@
   deterministic_data()->RunFor(3);
 
   callback.WaitForResult();
 
   // Can get timing information once the stream connects.
   TestLoadTimingNotReused(*http_stream);
 
   // 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);
   // Test that there's no crash when trying to get the load timing after the
   // stream has been closed.
   TestLoadTimingNotReused(*http_stream);
 }
 
 TEST_P(SpdyHttpStreamTest, LoadTimingTwoRequests) {
   scoped_ptr<SpdyFrame> req1(
@@ skipping 140 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, http_stream.SendRequest(
       headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key));
 
   deterministic_data()->RunFor(seq);
   callback.WaitForResult();
 
   // 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
 // chunk becomes available while a write is pending.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPost) {
   const char kUploadData1[] = "12345678";
   const int kUploadData1Size = arraysize(kUploadData1)-1;
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(
@@ skipping 81 matching lines @@
   scoped_refptr<IOBuffer> buf3(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf3.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf3->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
   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
 // frame when uploading a chunked data stream.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithEmptyFinalDataFrame) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(
       spdy_util_.ConstructSpdyBodyFrame(1, "", 0, true));
   MockWrite writes[] = {
@@ skipping 64 matching lines @@
   // Read and check |chunk2| response.
   deterministic_data()->RunFor(1);
   ASSERT_EQ(0,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
 
   // Finish reading the |EOF|.
   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
 // payload. Unclear if this is a case worth supporting.
 TEST_P(SpdyHttpStreamTest, ChunkedPostWithEmptyPayload) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk(
       spdy_util_.ConstructSpdyBodyFrame(1, "", 0, true));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 0),
@@ skipping 48 matching lines @@
   deterministic_data()->RunFor(1);
   scoped_refptr<IOBuffer> buf(new IOBuffer(1));
   ASSERT_EQ(0,
             http_stream->ReadResponseBody(
                 buf.get(), 1, callback.callback()));
 
   // Finish reading the |EOF|.
   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
 TEST_P(SpdyHttpStreamTest, SpdyURLTest) {
   const char* const full_url = "http://www.example.org/foo?query=what#anchor";
   const char* const base_url = "http://www.example.org/foo?query=what";
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(base_url, false, 1, LOWEST));
   MockWrite writes[] = {
       CreateMockWrite(*req.get(), 0),
@@ skipping 24 matching lines @@
                                                      callback.callback()));
 
   EXPECT_EQ(base_url, http_stream->stream()->GetUrlFromHeaders().spec());
 
   deterministic_data()->RunFor(3);
   callback.WaitForResult();
 
   // 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.
 
 // Test the receipt of a WINDOW_UPDATE frame while waiting for a chunk to be
 // made available is handled correctly.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithWindowUpdate) {
   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
@@ skipping 69 matching lines @@
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Finish reading the |EOF|.
   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
 // methods.
 
 }  // namespace net