Remove dependency on headers stream from QuicSession.

net/quic/quic_headers_stream.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/quic/quic_headers_stream.h"
 
 #include "base/strings/stringprintf.h"
-#include "net/quic/quic_session.h"
+#include "net/quic/quic_spdy_session.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 const QuicStreamId kInvalidStreamId = 0;
 
@@ skipping 143 matching lines @@
     }
   }
 
  private:
   SpdyMajorVersion spdy_version_;
   QuicHeadersStream* stream_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 };
 
-QuicHeadersStream::QuicHeadersStream(QuicSession* session)
+QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
     : ReliableQuicStream(kHeadersStreamId, session),
+      spdy_session_(session),
       stream_id_(kInvalidStreamId),
       fin_(false),
       frame_len_(0),
       spdy_framer_(SPDY4),
       spdy_framer_visitor_(new SpdyFramerVisitor(SPDY4, this)) {
   spdy_framer_.set_visitor(spdy_framer_visitor_.get());
   spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
   // The headers stream is exempt from connection level flow control.
   DisableConnectionFlowControlForThisStream();
 }
@@ skipping 32 matching lines @@
                                     bool fin) {
   if (session()->perspective() == Perspective::IS_CLIENT) {
     CloseConnectionWithDetails(
         QUIC_INVALID_HEADERS_STREAM_DATA,
         "SPDY SYN_STREAM frame received at the client");
     return;
   }
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
-  session()->OnStreamHeadersPriority(stream_id, priority);
+  spdy_session_->OnStreamHeadersPriority(stream_id, priority);
 }
 
 void QuicHeadersStream::OnSynReply(SpdyStreamId stream_id, bool fin) {
   if (session()->perspective() == Perspective::IS_SERVER) {
     CloseConnectionWithDetails(
         QUIC_INVALID_HEADERS_STREAM_DATA,
         "SPDY SYN_REPLY frame received at the server");
     return;
   }
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
 }
 
 void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
                                                  const char* header_data,
                                                  size_t len) {
   DCHECK_EQ(stream_id_, stream_id);
   if (len == 0) {
     DCHECK_NE(0u, stream_id_);
     DCHECK_NE(0u, frame_len_);
-    session()->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
+    spdy_session_->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
     // Reset state for the next frame.
     stream_id_ = kInvalidStreamId;
     fin_ = false;
     frame_len_ = 0;
   } else {
-    session()->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
+    spdy_session_->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
   }
 }
 
 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
   frame_len_ += frame_len;
 }
 
 bool QuicHeadersStream::IsConnected() {
   return session()->connection()->connected();
 }
 
 }  // namespace net