Break out the basic reliable QUIC stream functionality from the

net/quic/quic_data_stream_test.cc

Index: net/quic/quic_data_stream_test.cc
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/quic_data_stream_test.cc
similarity index 75%
copy from net/quic/reliable_quic_stream_test.cc
copy to net/quic/quic_data_stream_test.cc
index a8bd5c917d50641645f3de2ba748ae47986575ee..3e46aceca9a323a29406b9fa87f470969190596d 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/quic_data_stream_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/quic/reliable_quic_stream.h"
+#include "net/quic/quic_data_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
@@ -27,20 +27,17 @@ namespace net {
 namespace test {
 namespace {
 
-const char kData1[] = "FooAndBar";
-const char kData2[] = "EepAndBaz";
-const size_t kDataLen = 9;
 const QuicGuid kGuid = 42;
 const QuicGuid kStreamId = 3;
 const bool kIsServer = true;
 const bool kShouldProcessData = true;
 
-class TestStream : public ReliableQuicStream {
+class TestStream : public QuicDataStream {
  public:
   TestStream(QuicStreamId id,
              QuicSession* session,
              bool should_process_data)
-      : ReliableQuicStream(id, session),
+      : QuicDataStream(id, session),
         should_process_data_(should_process_data) {}
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
@@ -61,9 +58,9 @@ class TestStream : public ReliableQuicStream {
   string data_;
 };
 
-class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
+class QuicDataStreamTest : public ::testing::TestWithParam<bool> {
  public:
-  ReliableQuicStreamTest() {
+  QuicDataStreamTest() {
     headers_[":host"] = "www.google.com";
     headers_[":path"] = "/index.hml";
     headers_[":scheme"] = "https";
@@ -119,114 +116,7 @@ class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
   WriteBlockedList<QuicStreamId>* write_blocked_list_;
 };
 
-TEST_F(ReliableQuicStreamTest, WriteAllData) {
-  Initialize(kShouldProcessData);
-
-  connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-      Return(QuicConsumedData(kDataLen, true)));
-  stream_->WriteOrBufferData(kData1, false);
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
-}
-
-// TODO(rtenneti): Death tests crash on OS_ANDROID.
-#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
-TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
-  Initialize(kShouldProcessData);
-
-  // Write no data and no fin.  If we consume nothing we should not be write
-  // blocked.
-  EXPECT_DEBUG_DEATH({
-    EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-        Return(QuicConsumedData(0, false)));
-    stream_->WriteOrBufferData(StringPiece(), false);
-    EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
-  }, "");
-}
-#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
-
-TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
-  Initialize(kShouldProcessData);
-
-  // Write some data and no fin.  If we consume some but not all of the data,
-  // we should be write blocked a not all the data was consumed.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-      Return(QuicConsumedData(1, false)));
-  stream_->WriteOrBufferData(StringPiece(kData1, 2), false);
-  ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
-}
-
-
-TEST_F(ReliableQuicStreamTest, BlockIfFinNotConsumedWithData) {
-  Initialize(kShouldProcessData);
-
-  // Write some data and no fin.  If we consume all the data but not the fin,
-  // we should be write blocked because the fin was not consumed.
-  // (This should never actually happen as the fin should be sent out with the
-  // last data)
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-      Return(QuicConsumedData(2, false)));
-  stream_->WriteOrBufferData(StringPiece(kData1, 2), true);
-  ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
-}
-
-TEST_F(ReliableQuicStreamTest, BlockIfSoloFinNotConsumed) {
-  Initialize(kShouldProcessData);
-
-  // Write no data and a fin.  If we consume nothing we should be write blocked,
-  // as the fin was not consumed.
-  EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-      Return(QuicConsumedData(0, false)));
-  stream_->WriteOrBufferData(StringPiece(), true);
-  ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
-}
-
-TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
-  Initialize(kShouldProcessData);
-
-  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
-  connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).WillOnce(
-      Return(QuicConsumedData(kDataLen - 1, false)));
-  stream_->WriteOrBufferData(kData1, false);
-  EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
-
-  // Queue a bytes_consumed write.
-  stream_->WriteOrBufferData(kData2, false);
-
-  // Make sure we get the tail of the first write followed by the bytes_consumed
-  InSequence s;
-  EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).
-      WillOnce(Return(QuicConsumedData(1, false)));
-  EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).
-      WillOnce(Return(QuicConsumedData(kDataLen - 2, false)));
-  stream_->OnCanWrite();
-
-  // And finally the end of the bytes_consumed.
-  EXPECT_CALL(*session_, WritevData(_, _, 1, _, _, _)).
-      WillOnce(Return(QuicConsumedData(2, true)));
-  stream_->OnCanWrite();
-}
-
-TEST_F(ReliableQuicStreamTest, ConnectionCloseAfterStreamClose) {
-  Initialize(kShouldProcessData);
-
-  stream_->CloseReadSide();
-  stream_->CloseWriteSide();
-  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
-  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
-  stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR, false);
-  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
-  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeaders) {
+TEST_F(QuicDataStreamTest, ProcessHeaders) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -239,7 +129,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeaders) {
             stream_->EffectivePriority());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidHeaderId) {
+TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidHeaderId) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -251,7 +141,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidHeaderId) {
   stream_->OnStreamFrame(frame);
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidPriority) {
+TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidPriority) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -263,7 +153,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidPriority) {
   stream_->OnStreamFrame(frame);
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBody) {
+TEST_F(QuicDataStreamTest, ProcessHeadersAndBody) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -277,7 +167,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBody) {
             stream_->data());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyFragments) {
+TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -318,7 +208,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyFragments) {
             stream_->EffectivePriority());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyReadv) {
+TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyReadv) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -348,7 +238,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyReadv) {
   EXPECT_EQ(body, string(buffer, bytes_read));
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
+TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -374,7 +264,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   }
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
+TEST_F(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
@@ -404,7 +294,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   }
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessCorruptHeadersEarly) {
+TEST_F(QuicDataStreamTest, ProcessCorruptHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
@@ -446,7 +336,7 @@ TEST_F(ReliableQuicStreamTest, ProcessCorruptHeadersEarly) {
   EXPECT_EQ("", stream2_->data());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessPartialHeadersEarly) {
+TEST_F(QuicDataStreamTest, ProcessPartialHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
@@ -499,7 +389,7 @@ TEST_F(ReliableQuicStreamTest, ProcessPartialHeadersEarly) {
   EXPECT_EQ(decompressed_headers2, stream2_->data());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersEarly) {
+TEST_F(QuicDataStreamTest, ProcessHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
@@ -537,7 +427,7 @@ TEST_F(ReliableQuicStreamTest, ProcessHeadersEarly) {
   EXPECT_EQ(decompressed_headers2, stream2_->data());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeadersDelay) {
+TEST_F(QuicDataStreamTest, ProcessHeadersDelay) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(