Remove dependency on headers stream from QuicSession.

net/tools/quic/quic_server_session.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/tools/quic/quic_server_session.h"
 
 #include "base/logging.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
+#include "net/quic/quic_spdy_session.h"
 #include "net/quic/reliable_quic_stream.h"
 #include "net/tools/quic/quic_spdy_server_stream.h"
 
 namespace net {
 namespace tools {
 
 QuicServerSession::QuicServerSession(
     const QuicConfig& config,
     QuicConnection* connection,
     QuicServerSessionVisitor* visitor,
     const QuicCryptoServerConfig* crypto_config)
-    : QuicSession(connection, config),
+    : QuicSpdySession(connection, config),
       crypto_config_(crypto_config),
       visitor_(visitor),
       bandwidth_resumption_enabled_(false),
       bandwidth_estimate_sent_to_client_(QuicBandwidth::Zero()),
       last_scup_time_(QuicTime::Zero()),
       last_scup_sequence_number_(0) {
 }
 
 QuicServerSession::~QuicServerSession() {}
 
 void QuicServerSession::Initialize() {
   crypto_stream_.reset(CreateQuicCryptoServerStream(crypto_config_));
-  QuicSession::Initialize();
+  QuicSpdySession::Initialize();
 }
 
 QuicCryptoServerStream* QuicServerSession::CreateQuicCryptoServerStream(
     const QuicCryptoServerConfig* crypto_config) {
   return new QuicCryptoServerStream(crypto_config, this);
 }
 
 void QuicServerSession::OnConfigNegotiated() {
   QuicSession::OnConfigNegotiated();
 
@@ skipping 15 matching lines @@
   if (cached_network_params != nullptr && bandwidth_resumption_enabled_ &&
       cached_network_params->serving_region() == serving_region_) {
     connection()->ResumeConnectionState(*cached_network_params,
                                         max_bandwidth_resumption);
   }
 
   if (FLAGS_enable_quic_fec &&
       ContainsQuicTag(config()->ReceivedConnectionOptions(), kFHDR)) {
     // kFHDR config maps to FEC protection always for headers stream.
     // TODO(jri): Add crypto stream in addition to headers for kHDR.
-    headers_stream_->set_fec_policy(FEC_PROTECT_ALWAYS);
+    headers_stream()->set_fec_policy(FEC_PROTECT_ALWAYS);
   }
 }
 
 void QuicServerSession::OnConnectionClosed(QuicErrorCode error,
                                            bool from_peer) {
   QuicSession::OnConnectionClosed(error, from_peer);
   // In the unlikely event we get a connection close while doing an asynchronous
   // crypto event, make sure we cancel the callback.
   if (crypto_stream_.get() != nullptr) {
     crypto_stream_->CancelOutstandingCallbacks();
@@ skipping 87 matching lines @@
 
   crypto_stream_->SendServerConfigUpdate(&cached_network_params);
 
   connection()->OnSendConnectionState(cached_network_params);
 
   last_scup_time_ = now;
   last_scup_sequence_number_ =
       connection()->sequence_number_of_last_sent_packet();
 }
 
-bool QuicServerSession::ShouldCreateIncomingDataStream(QuicStreamId id) {
+bool QuicServerSession::ShouldCreateIncomingDynamicStream(QuicStreamId id) {
   if (!connection()->connected()) {
-    LOG(DFATAL) << "ShouldCreateIncomingDataStream called when disconnected";
+    LOG(DFATAL) << "ShouldCreateIncomingDynamicStream called when disconnected";
     return false;
   }
 
   if (id % 2 == 0) {
     DVLOG(1) << "Invalid incoming even stream_id:" << id;
     connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
     return false;
   }
   if (GetNumOpenStreams() >= get_max_open_streams()) {
     DVLOG(1) << "Failed to create a new incoming stream with id:" << id
              << " Already " << GetNumOpenStreams() << " streams open (max "
              << get_max_open_streams() << ").";
     connection()->SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS);
     return false;
   }
   return true;
 }
 
-QuicDataStream* QuicServerSession::CreateIncomingDataStream(
+QuicDataStream* QuicServerSession::CreateIncomingDynamicStream(
     QuicStreamId id) {
-  if (!ShouldCreateIncomingDataStream(id)) {
+  if (!ShouldCreateIncomingDynamicStream(id)) {
     return nullptr;
   }
 
   return new QuicSpdyServerStream(id, this);
 }
 
-QuicDataStream* QuicServerSession::CreateOutgoingDataStream() {
+QuicDataStream* QuicServerSession::CreateOutgoingDynamicStream() {
   DLOG(ERROR) << "Server push not yet supported";
   return nullptr;
 }
 
 QuicCryptoServerStream* QuicServerSession::GetCryptoStream() {
   return crypto_stream_.get();
 }
 
 }  // namespace tools
 }  // namespace net