Break out the basic reliable QUIC stream functionality from the

net/tools/quic/quic_server_session_test.cc

 // Copyright 2013 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/tools/quic/quic_server_session.h"
 
-
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.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/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_spdy_server_stream.h"
 #include "net/tools/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using __gnu_cxx::vector;
 using net::test::MockConnection;
 using net::test::QuicConnectionPeer;
-using net::test::ReliableQuicStreamPeer;
+using net::test::QuicDataStreamPeer;
 using testing::_;
 using testing::StrictMock;
 
 namespace net {
 namespace tools {
 namespace test {
 
 class QuicServerSessionPeer {
  public:
-  static ReliableQuicStream* GetIncomingReliableStream(
+  static QuicDataStream* GetIncomingReliableStream(
       QuicServerSession* s, QuicStreamId id) {
     return s->GetIncomingReliableStream(id);
   }
-  static ReliableQuicStream* GetStream(QuicServerSession* s, QuicStreamId id) {
-    return s->GetStream(id);
+  static QuicDataStream* GetDataStream(QuicServerSession* s, QuicStreamId id) {
+    return s->GetDataStream(id);
   }
 };
 
-class CloseOnDataStream : public ReliableQuicStream {
+class CloseOnDataStream : public QuicDataStream {
  public:
   CloseOnDataStream(QuicStreamId id, QuicSession* session)
-      : ReliableQuicStream(id, session) {
+      : QuicDataStream(id, session) {
   }
 
   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     session()->MarkDecompressionBlocked(1, id());
     session()->CloseStream(id());
     return true;
   }
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
     return 0;
   }
 };
 
 class TestQuicQuicServerSession : public QuicServerSession {
  public:
   TestQuicQuicServerSession(const QuicConfig& config,
                             QuicConnection* connection,
                             QuicSessionOwner* owner)
       : QuicServerSession(config, connection, owner),
         close_stream_on_data_(false) {
   }
 
-  virtual ReliableQuicStream* CreateIncomingReliableStream(
+  virtual QuicDataStream* CreateIncomingDataStream(
       QuicStreamId id) OVERRIDE {
-    if (!ShouldCreateIncomingReliableStream(id)) {
+    if (!ShouldCreateIncomingDataStream(id)) {
       return NULL;
     }
     if (close_stream_on_data_) {
       return new CloseOnDataStream(id, this);
     } else {
       return new QuicSpdyServerStream(id, this);
     }
   }
 
   void CloseStreamOnData() {
@@ skipping 16 matching lines @@
     config_.set_max_streams_per_connection(3, 3);
 
     connection_ = new MockConnection(guid_, IPEndPoint(), 0, &eps_, true);
     session_.reset(new TestQuicQuicServerSession(
         config_, connection_, &owner_));
     session_->InitializeSession(crypto_config_);
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
   }
 
   void MarkHeadersReadForStream(QuicStreamId id) {
-    ReliableQuicStream* stream = QuicServerSessionPeer::GetStream(
+    QuicDataStream* stream = QuicServerSessionPeer::GetDataStream(
         session_.get(), id);
     ASSERT_TRUE(stream != NULL);
-    ReliableQuicStreamPeer::SetHeadersDecompressed(stream, true);
+    QuicDataStreamPeer::SetHeadersDecompressed(stream, true);
   }
 
   QuicGuid guid_;
   EpollServer eps_;
   StrictMock<MockQuicSessionOwner> owner_;
   MockConnection* connection_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   scoped_ptr<TestQuicQuicServerSession> session_;
   QuicConnectionVisitorInterface* visitor_;
@@ skipping 111 matching lines @@
   // Incoming streams on the server session must be odd.
   EXPECT_EQ(NULL,
             QuicServerSessionPeer::GetIncomingReliableStream(
                 session_.get(), 2));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net