Remove dependency on headers stream from QuicSession.

net/tools/quic/quic_server_session_test.cc

Index: net/tools/quic/quic_server_session_test.cc
diff --git a/net/tools/quic/quic_server_session_test.cc b/net/tools/quic/quic_server_session_test.cc
index 1df0dc672976ba811f2dd6ccf1d2b44fbf3a5250..a7ec9feaf00367966f7831dbdaedc34a511aa889 100644
--- a/net/tools/quic/quic_server_session_test.cc
+++ b/net/tools/quic/quic_server_session_test.cc
@@ -16,6 +16,7 @@
 #include "net/quic/test_tools/quic_data_stream_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
+#include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
@@ -31,6 +32,7 @@ using net::test::QuicConnectionPeer;
 using net::test::QuicDataStreamPeer;
 using net::test::QuicSentPacketManagerPeer;
 using net::test::QuicSessionPeer;
+using net::test::QuicSpdySessionPeer;
 using net::test::QuicSustainedBandwidthRecorderPeer;
 using net::test::SupportedVersions;
 using net::test::ValueRestore;
@@ -47,13 +49,14 @@ namespace test {
 
 class QuicServerSessionPeer {
  public:
-  static QuicDataStream* GetIncomingDataStream(
-      QuicServerSession* s, QuicStreamId id) {
-    return s->GetIncomingDataStream(id);
+  static ReliableQuicStream* GetIncomingDynamicStream(QuicServerSession* s,
+                                                      QuicStreamId id) {
+    return s->GetIncomingDynamicStream(id);
   }
   static void SetCryptoStream(QuicServerSession* s,
                               QuicCryptoServerStream* crypto_stream) {
     s->crypto_stream_.reset(crypto_stream);
+    s->static_streams()[kCryptoStreamId] = crypto_stream;
   }
   static bool IsBandwidthResumptionEnabled(QuicServerSession* s) {
     return s->bandwidth_resumption_enabled_;
@@ -207,23 +210,23 @@ TEST_P(QuicServerSessionTest, MaxOpenStreams) {
   QuicStreamId stream_id = kClientDataStreamId1;
   // Open the max configured number of streams, should be no problem.
   for (size_t i = 0; i < kMaxStreamsForTest; ++i) {
-    EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
-                                                             stream_id));
+    EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDynamicStream(session_.get(),
+                                                                stream_id));
     stream_id += 2;
   }
 
   // Open more streams: server should accept slightly more than the limit.
   for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) {
-    EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
-                                                             stream_id));
+    EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDynamicStream(session_.get(),
+                                                                stream_id));
     stream_id += 2;
   }
 
   // Now violate the server's internal stream limit.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
   stream_id += 2;
-  EXPECT_FALSE(
-      QuicServerSessionPeer::GetIncomingDataStream(session_.get(), stream_id));
+  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDynamicStream(session_.get(),
+                                                               stream_id));
 }
 
 TEST_P(QuicServerSessionTest, MaxOpenStreamsImplicit) {
@@ -241,19 +244,19 @@ TEST_P(QuicServerSessionTest, MaxOpenStreamsImplicit) {
             session_->get_max_open_streams());
 
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDynamicStream(
       session_.get(), kClientDataStreamId1));
   // Implicitly open streams up to the server's limit.
   const int kActualMaxStreams =
       kMaxStreamsForTest + kMaxStreamsMinimumIncrement;
   const int kMaxValidStreamId =
       kClientDataStreamId1 + (kActualMaxStreams - 1) * 2;
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDynamicStream(
       session_.get(), kMaxValidStreamId));
 
   // Opening a further stream will result in connection close.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
-  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream(
+  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDynamicStream(
       session_.get(), kMaxValidStreamId + 2));
 }
 
@@ -261,14 +264,15 @@ TEST_P(QuicServerSessionTest, GetEvenIncomingError) {
   // Incoming streams on the server session must be odd.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   EXPECT_EQ(nullptr,
-            QuicServerSessionPeer::GetIncomingDataStream(session_.get(), 4));
+            QuicServerSessionPeer::GetIncomingDynamicStream(session_.get(), 4));
 }
 
 TEST_P(QuicServerSessionTest, GetStreamDisconnected) {
   // Don't create new streams if the connection is disconnected.
   QuicConnectionPeer::CloseConnection(connection_);
-  EXPECT_DFATAL(QuicServerSessionPeer::GetIncomingDataStream(session_.get(), 5),
-                "ShouldCreateIncomingDataStream called when disconnected");
+  EXPECT_DFATAL(
+      QuicServerSessionPeer::GetIncomingDynamicStream(session_.get(), 5),
+      "ShouldCreateIncomingDynamicStream called when disconnected");
 }
 
 TEST_P(QuicServerSessionTest, SetFecProtectionFromConfig) {
@@ -282,9 +286,9 @@ TEST_P(QuicServerSessionTest, SetFecProtectionFromConfig) {
 
   // Verify that headers stream is always protected and data streams are
   // optionally protected.
-  EXPECT_EQ(FEC_PROTECT_ALWAYS,
-            QuicSessionPeer::GetHeadersStream(session_.get())->fec_policy());
-  QuicDataStream* stream = QuicServerSessionPeer::GetIncomingDataStream(
+  EXPECT_EQ(FEC_PROTECT_ALWAYS, QuicSpdySessionPeer::GetHeadersStream(
+                                    session_.get())->fec_policy());
+  ReliableQuicStream* stream = QuicServerSessionPeer::GetIncomingDynamicStream(
       session_.get(), kClientDataStreamId1);
   ASSERT_TRUE(stream);
   EXPECT_EQ(FEC_PROTECT_OPTIONAL, stream->fec_policy());