Break out the basic reliable QUIC stream functionality from the

net/quic/quic_session_test.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/quic/quic_session.h"
 
 #include <set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
+#include "net/quic/test_tools/quic_data_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::hash_map;
 using std::set;
 using std::vector;
 using testing::_;
@@ skipping 23 matching lines @@
     const QuicErrorCode error = session()->config()->ProcessClientHello(
         msg, &error_details);
     EXPECT_EQ(QUIC_NO_ERROR, error);
     session()->OnConfigNegotiated();
     session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
-class TestStream : public ReliableQuicStream {
+class TestStream : public QuicDataStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session)
-      : ReliableQuicStream(id, session) {
+      : QuicDataStream(id, session) {
   }
 
   using ReliableQuicStream::CloseWriteSide;
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) {
     return data_len;
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
@@ skipping 19 matching lines @@
  public:
   TestSession(QuicConnection* connection, bool is_server)
       : QuicSession(connection, DefaultQuicConfig(), is_server),
         crypto_stream_(this) {
   }
 
   virtual TestCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
-  virtual TestStream* CreateOutgoingReliableStream() OVERRIDE {
+  virtual TestStream* CreateOutgoingDataStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
-  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) OVERRIDE {
+  virtual TestStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE {
     return new TestStream(id, this);
   }
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
-  ReliableQuicStream* GetIncomingReliableStream(QuicStreamId stream_id) {
+  QuicDataStream* GetIncomingReliableStream(QuicStreamId stream_id) {
     return QuicSession::GetIncomingReliableStream(stream_id);
   }
 
   TestCryptoStream crypto_stream_;
 };
 
 class QuicSessionTest : public ::testing::Test {
  protected:
   QuicSessionTest()
       : guid_(1),
@@ skipping 71 matching lines @@
 TEST_F(QuicSessionTest, ImplicitlyCreatedStreams) {
   ASSERT_TRUE(session_.GetIncomingReliableStream(7) != NULL);
   // Both 3 and 5 should be implicitly created.
   EXPECT_FALSE(session_.IsClosedStream(3));
   EXPECT_FALSE(session_.IsClosedStream(5));
   ASSERT_TRUE(session_.GetIncomingReliableStream(5) != NULL);
   ASSERT_TRUE(session_.GetIncomingReliableStream(3) != NULL);
 }
 
 TEST_F(QuicSessionTest, IsClosedStreamLocallyCreated) {
-  TestStream* stream2 = session_.CreateOutgoingReliableStream();
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
   EXPECT_EQ(2u, stream2->id());
-  ReliableQuicStreamPeer::SetHeadersDecompressed(stream2, true);
-  TestStream* stream4 = session_.CreateOutgoingReliableStream();
+  QuicDataStreamPeer::SetHeadersDecompressed(stream2, true);
+  TestStream* stream4 = session_.CreateOutgoingDataStream();
   EXPECT_EQ(4u, stream4->id());
-  ReliableQuicStreamPeer::SetHeadersDecompressed(stream4, true);
+  QuicDataStreamPeer::SetHeadersDecompressed(stream4, true);
 
   CheckClosedStreams();
   CloseStream(4);
   CheckClosedStreams();
   CloseStream(2);
   CheckClosedStreams();
 }
 
 TEST_F(QuicSessionTest, IsClosedStreamPeerCreated) {
-  ReliableQuicStream* stream3 = session_.GetIncomingReliableStream(3);
-  ReliableQuicStreamPeer::SetHeadersDecompressed(stream3, true);
-  ReliableQuicStream* stream5 = session_.GetIncomingReliableStream(5);
-  ReliableQuicStreamPeer::SetHeadersDecompressed(stream5, true);
+  QuicDataStream* stream3 = session_.GetIncomingReliableStream(3);
+  QuicDataStreamPeer::SetHeadersDecompressed(stream3, true);
+  QuicDataStream* stream5 = session_.GetIncomingReliableStream(5);
+  QuicDataStreamPeer::SetHeadersDecompressed(stream5, true);
 
   CheckClosedStreams();
   CloseStream(3);
   CheckClosedStreams();
   CloseStream(5);
   // Create stream id 9, and implicitly 7
-  ReliableQuicStream* stream9 = session_.GetIncomingReliableStream(9);
-  ReliableQuicStreamPeer::SetHeadersDecompressed(stream9, true);
+  QuicDataStream* stream9 = session_.GetIncomingReliableStream(9);
+  QuicDataStreamPeer::SetHeadersDecompressed(stream9, true);
   CheckClosedStreams();
   // Close 9, but make sure 7 is still not closed
   CloseStream(9);
   CheckClosedStreams();
 }
 
 TEST_F(QuicSessionTest, StreamIdTooLarge) {
   session_.GetIncomingReliableStream(3);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   session_.GetIncomingReliableStream(105);
 }
 
 TEST_F(QuicSessionTest, DecompressionError) {
   ReliableQuicStream* stream = session_.GetIncomingReliableStream(3);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
   const char data[] =
       "\1\0\0\0"   // headers id
       "\0\0\0\4"   // length
       "abcd";      // invalid compressed data
   stream->ProcessRawData(data, arraysize(data));
 }
 
 TEST_F(QuicSessionTest, OnCanWrite) {
-  TestStream* stream2 = session_.CreateOutgoingReliableStream();
-  TestStream* stream4 = session_.CreateOutgoingReliableStream();
-  TestStream* stream6 = session_.CreateOutgoingReliableStream();
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
+  TestStream* stream4 = session_.CreateOutgoingDataStream();
+  TestStream* stream6 = session_.CreateOutgoingDataStream();
 
   session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
 
   InSequence s;
   StreamBlocker stream2_blocker(&session_, stream2->id());
   EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(
       // Reregister, to test the loop limit.
       InvokeWithoutArgs(&stream2_blocker, &StreamBlocker::MarkWriteBlocked));
   EXPECT_CALL(*stream6, OnCanWrite());
   EXPECT_CALL(*stream4, OnCanWrite());
 
   EXPECT_FALSE(session_.OnCanWrite());
 }
 
 TEST_F(QuicSessionTest, BufferedHandshake) {
   EXPECT_FALSE(session_.HasPendingHandshake());  // Default value.
 
   // Test that blocking other streams does not change our status.
-  TestStream* stream2 = session_.CreateOutgoingReliableStream();
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
   StreamBlocker stream2_blocker(&session_, stream2->id());
   stream2_blocker.MarkWriteBlocked();
   EXPECT_FALSE(session_.HasPendingHandshake());
 
-  TestStream* stream3 = session_.CreateOutgoingReliableStream();
+  TestStream* stream3 = session_.CreateOutgoingDataStream();
   StreamBlocker stream3_blocker(&session_, stream3->id());
   stream3_blocker.MarkWriteBlocked();
   EXPECT_FALSE(session_.HasPendingHandshake());
 
   // Blocking (due to buffering of) the Crypto stream is detected.
   session_.MarkWriteBlocked(kCryptoStreamId, kSomeMiddlePriority);
   EXPECT_TRUE(session_.HasPendingHandshake());
 
-  TestStream* stream4 = session_.CreateOutgoingReliableStream();
+  TestStream* stream4 = session_.CreateOutgoingDataStream();
   StreamBlocker stream4_blocker(&session_, stream4->id());
   stream4_blocker.MarkWriteBlocked();
   EXPECT_TRUE(session_.HasPendingHandshake());
 
   InSequence s;
   // Force most streams to re-register, which is common scenario when we block
   // the Crypto stream, and only the crypto stream can "really" write.
 
   // Due to prioritization, we *should* be asked to write the crypto stream
   // first.
   // Don't re-register the crypto stream (which signals complete writing).
   TestCryptoStream* crypto_stream = session_.GetCryptoStream();
   EXPECT_CALL(*crypto_stream, OnCanWrite());
 
   // Re-register all other streams, to show they weren't able to proceed.
   EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(
       InvokeWithoutArgs(&stream2_blocker, &StreamBlocker::MarkWriteBlocked));
 
   EXPECT_CALL(*stream3, OnCanWrite()).WillOnce(
       InvokeWithoutArgs(&stream3_blocker, &StreamBlocker::MarkWriteBlocked));
 
   EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(
       InvokeWithoutArgs(&stream4_blocker, &StreamBlocker::MarkWriteBlocked));
 
   EXPECT_FALSE(session_.OnCanWrite());
   EXPECT_FALSE(session_.HasPendingHandshake());  // Crypto stream wrote.
 }
 
 TEST_F(QuicSessionTest, OnCanWriteWithClosedStream) {
-  TestStream* stream2 = session_.CreateOutgoingReliableStream();
-  TestStream* stream4 = session_.CreateOutgoingReliableStream();
-  TestStream* stream6 = session_.CreateOutgoingReliableStream();
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
+  TestStream* stream4 = session_.CreateOutgoingDataStream();
+  TestStream* stream6 = session_.CreateOutgoingDataStream();
 
   session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
   CloseStream(stream6->id());
 
   InSequence s;
   EXPECT_CALL(*stream2, OnCanWrite());
   EXPECT_CALL(*stream4, OnCanWrite());
   EXPECT_TRUE(session_.OnCanWrite());
 }
 
 // Regression test for http://crbug.com/248737
 TEST_F(QuicSessionTest, OutOfOrderHeaders) {
   QuicSpdyCompressor compressor;
   vector<QuicStreamFrame> frames;
   QuicPacketHeader header;
   header.public_header.guid = session_.guid();
 
-  TestStream* stream2 = session_.CreateOutgoingReliableStream();
-  TestStream* stream4 = session_.CreateOutgoingReliableStream();
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
+  TestStream* stream4 = session_.CreateOutgoingDataStream();
   stream2->CloseWriteSide();
   stream4->CloseWriteSide();
 
   // Create frame with headers for stream2.
   string compressed_headers1 = compressor.CompressHeaders(headers_);
   QuicStreamFrame frame1(
       stream2->id(), false, 0, MakeIOVector(compressed_headers1));
 
   // Create frame with headers for stream4.
   string compressed_headers2 = compressor.CompressHeaders(headers_);
@@ skipping 32 matching lines @@
   session_.crypto_stream_.OnHandshakeMessage(msg);
   EXPECT_EQ(kDefaultTimeoutSecs,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
 }
 
 TEST_F(QuicSessionTest, ZombieStream) {
   StrictMock<MockConnection>* connection =
       new StrictMock<MockConnection>(guid_, IPEndPoint(), false);
   TestSession session(connection, /*is_server=*/ false);
 
-  TestStream* stream3 = session.CreateOutgoingReliableStream();
+  TestStream* stream3 = session.CreateOutgoingDataStream();
   EXPECT_EQ(3u, stream3->id());
-  TestStream* stream5 = session.CreateOutgoingReliableStream();
+  TestStream* stream5 = session.CreateOutgoingDataStream();
   EXPECT_EQ(5u, stream5->id());
   EXPECT_EQ(2u, session.GetNumOpenStreams());
 
   // Reset the stream, but since the headers have not been decompressed
   // it will become a zombie and will continue to process data
   // until the headers are decompressed.
   EXPECT_CALL(*connection, SendRstStream(3, QUIC_STREAM_CANCELLED));
   session.SendRstStream(3, QUIC_STREAM_CANCELLED);
 
   EXPECT_EQ(1u, session.GetNumOpenStreams());
@@ skipping 17 matching lines @@
   EXPECT_EQ(1u, session.GetNumOpenStreams());
 
   EXPECT_TRUE(connection->connected());
 }
 
 TEST_F(QuicSessionTest, ZombieStreamConnectionClose) {
   StrictMock<MockConnection>* connection =
       new StrictMock<MockConnection>(guid_, IPEndPoint(), false);
   TestSession session(connection, /*is_server=*/ false);
 
-  TestStream* stream3 = session.CreateOutgoingReliableStream();
+  TestStream* stream3 = session.CreateOutgoingDataStream();
   EXPECT_EQ(3u, stream3->id());
-  TestStream* stream5 = session.CreateOutgoingReliableStream();
+  TestStream* stream5 = session.CreateOutgoingDataStream();
   EXPECT_EQ(5u, stream5->id());
   EXPECT_EQ(2u, session.GetNumOpenStreams());
 
   stream3->CloseWriteSide();
   // Reset the stream, but since the headers have not been decompressed
   // it will become a zombie and will continue to process data
   // until the headers are decompressed.
   EXPECT_CALL(*connection, SendRstStream(3, QUIC_STREAM_CANCELLED));
   session.SendRstStream(3, QUIC_STREAM_CANCELLED);
 
@@ skipping 18 matching lines @@
       QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED));
 
   QuicRstStreamFrame rst1(3, QUIC_STREAM_NO_ERROR);
   session_.OnRstStream(rst1);
   EXPECT_EQ(0u, session_.GetNumOpenStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net