Remove dependency on headers stream from QuicSession.

net/quic/quic_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/quic/quic_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flow_controller.h"
-#include "net/quic/quic_headers_stream.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::map;
 using std::max;
 using std::string;
 using std::vector;
@@ skipping 60 matching lines @@
   void OnWriteBlocked() override { session_->OnWriteBlocked(); }
 
   bool WillingAndAbleToWrite() const override {
     return session_->WillingAndAbleToWrite();
   }
 
   bool HasPendingHandshake() const override {
     return session_->HasPendingHandshake();
   }
 
-  bool HasOpenDataStreams() const override {
-    return session_->HasOpenDataStreams();
+  bool HasOpenDynamicStreams() const override {
+    return session_->HasOpenDynamicStreams();
   }
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.MaxStreamsPerConnection()),
-      next_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 5),
-      largest_peer_created_stream_id_(0),
+      next_stream_id_(perspective() == Perspective::IS_SERVER ? 2 : 3),
+      largest_peer_created_stream_id_(
+          perspective() == Perspective::IS_SERVER ? 1 : 0),
       error_(QUIC_NO_ERROR),
       flow_controller_(connection_.get(),
                        0,
                        perspective(),
                        kMinimumFlowControlSendWindow,
                        config_.GetInitialSessionFlowControlWindowToSend(),
                        false),
       goaway_received_(false),
       goaway_sent_(false),
       has_pending_handshake_(false) {
 }
 
 void QuicSession::Initialize() {
-  // Crypto stream must exist when Initialize is called.
-  DCHECK(GetCryptoStream());
-
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetFromConfig(config_);
-  headers_stream_.reset(new QuicHeadersStream(this));
+
+  DCHECK_EQ(kCryptoStreamId, GetCryptoStream()->id());
+  static_stream_map_[kCryptoStreamId] = GetCryptoStream();
 }
 
 QuicSession::~QuicSession() {
   STLDeleteElements(&closed_streams_);
-  STLDeleteValues(&stream_map_);
+  STLDeleteValues(&dynamic_stream_map_);
 
   DLOG_IF(WARNING,
           locally_closed_streams_highest_offset_.size() > max_open_streams_)
       << "Surprisingly high number of locally closed streams still waiting for "
          "final byte offset: " << locally_closed_streams_highest_offset_.size();
 }
 
 void QuicSession::OnStreamFrames(const vector<QuicStreamFrame>& frames) {
   for (size_t i = 0; i < frames.size() && connection_->connected(); ++i) {
     // TODO(rch) deal with the error case of stream id 0.
     const QuicStreamFrame& frame = frames[i];
     QuicStreamId stream_id = frame.stream_id;
     ReliableQuicStream* stream = GetStream(stream_id);
     if (!stream) {
       // The stream no longer exists, but we may still be interested in the
       // final stream byte offset sent by the peer. A frame with a FIN can give
       // us this offset.
       if (frame.fin) {
         QuicStreamOffset final_byte_offset = frame.offset + frame.data.size();
         UpdateFlowControlOnFinalReceivedByteOffset(stream_id,
                                                    final_byte_offset);
       }
 
       continue;
     }
     stream->OnStreamFrame(frames[i]);
   }
 }
 
-void QuicSession::OnStreamHeaders(QuicStreamId stream_id,
-                                  StringPiece headers_data) {
-  QuicDataStream* stream = GetDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnStreamHeaders(headers_data);
-}
-
-void QuicSession::OnStreamHeadersPriority(QuicStreamId stream_id,
-                                          QuicPriority priority) {
-  QuicDataStream* stream = GetDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnStreamHeadersPriority(priority);
-}
-
-void QuicSession::OnStreamHeadersComplete(QuicStreamId stream_id,
-                                          bool fin,
-                                          size_t frame_len) {
-  QuicDataStream* stream = GetDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnStreamHeadersComplete(fin, frame_len);
-}
-
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
-  if (frame.stream_id == kCryptoStreamId) {
+  if (ContainsKey(static_stream_map_, frame.stream_id)) {
     connection()->SendConnectionCloseWithDetails(
-        QUIC_INVALID_STREAM_ID,
-        "Attempt to reset the crypto stream");
-    return;
-  }
-  if (frame.stream_id == kHeadersStreamId) {
-    connection()->SendConnectionCloseWithDetails(
-        QUIC_INVALID_STREAM_ID,
-        "Attempt to reset the headers stream");
+        QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream");
     return;
   }
 
-  QuicDataStream* stream = GetDataStream(frame.stream_id);
+  ReliableQuicStream* stream = GetDynamicStream(frame.stream_id);
   if (!stream) {
     // The RST frame contains the final byte offset for the stream: we can now
     // update the connection level flow controller if needed.
     UpdateFlowControlOnFinalReceivedByteOffset(frame.stream_id,
                                                frame.byte_offset);
     return;  // Errors are handled by GetStream.
   }
 
   stream->OnStreamReset(frame);
 }
 
 void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
   DCHECK(frame.last_good_stream_id < next_stream_id_);
   goaway_received_ = true;
 }
 
 void QuicSession::OnConnectionClosed(QuicErrorCode error, bool from_peer) {
   DCHECK(!connection_->connected());
   if (error_ == QUIC_NO_ERROR) {
     error_ = error;
   }
 
-  while (!stream_map_.empty()) {
-    DataStreamMap::iterator it = stream_map_.begin();
+  while (!dynamic_stream_map_.empty()) {
+    StreamMap::iterator it = dynamic_stream_map_.begin();
     QuicStreamId id = it->first;
     it->second->OnConnectionClosed(error, from_peer);
     // The stream should call CloseStream as part of OnConnectionClosed.
-    if (stream_map_.find(id) != stream_map_.end()) {
+    if (dynamic_stream_map_.find(id) != dynamic_stream_map_.end()) {
       LOG(DFATAL) << ENDPOINT
                   << "Stream failed to close under OnConnectionClosed";
       CloseStream(id);
     }
   }
 }
 
 void QuicSession::OnSuccessfulVersionNegotiation(const QuicVersion& version) {
 }
 
@@ skipping 94 matching lines @@
   // level.
   return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
          (!flow_controller_.IsBlocked() &&
           write_blocked_streams_.HasWriteBlockedDataStreams());
 }
 
 bool QuicSession::HasPendingHandshake() const {
   return has_pending_handshake_;
 }
 
-bool QuicSession::HasOpenDataStreams() const {
+bool QuicSession::HasOpenDynamicStreams() const {
   return GetNumOpenStreams() > 0;
 }
 
 QuicConsumedData QuicSession::WritevData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
     FecProtection fec_protection,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
   return connection_->SendStreamData(id, data, offset, fin, fec_protection,
                                      ack_notifier_delegate);
 }
 
-size_t QuicSession::WriteHeaders(
-    QuicStreamId id,
-    const SpdyHeaderBlock& headers,
-    bool fin,
-    QuicPriority priority,
-    QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
-  return headers_stream_->WriteHeaders(id, headers, fin, priority,
-                                       ack_notifier_delegate);
-}
-
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error,
                                 QuicStreamOffset bytes_written) {
+  if (ContainsKey(static_stream_map_, id)) {
+    LOG(DFATAL) << "Cannot send RST for a static stream with ID " << id;
+    return;
+  }
+
   if (connection()->connected()) {
     // Only send a RST_STREAM frame if still connected.
     connection_->SendRstStream(id, error, bytes_written);
   }
   CloseStreamInner(id, true);
 }
 
 void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
   if (goaway_sent_) {
     return;
   }
   goaway_sent_ = true;
   connection_->SendGoAway(error_code, largest_peer_created_stream_id_, reason);
 }
 
 void QuicSession::CloseStream(QuicStreamId stream_id) {
   CloseStreamInner(stream_id, false);
 }
 
 void QuicSession::CloseStreamInner(QuicStreamId stream_id,
                                    bool locally_reset) {
   DVLOG(1) << ENDPOINT << "Closing stream " << stream_id;
 
-  DataStreamMap::iterator it = stream_map_.find(stream_id);
-  if (it == stream_map_.end()) {
+  StreamMap::iterator it = dynamic_stream_map_.find(stream_id);
+  if (it == dynamic_stream_map_.end()) {
     DVLOG(1) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
-  QuicDataStream* stream = it->second;
+  ReliableQuicStream* stream = it->second;
 
   // Tell the stream that a RST has been sent.
   if (locally_reset) {
     stream->set_rst_sent(true);
   }
 
   closed_streams_.push_back(it->second);
 
   // If we haven't received a FIN or RST for this stream, we need to keep track
   // of the how many bytes the stream's flow controller believes it has
   // received, for accurate connection level flow control accounting.
   if (!stream->HasFinalReceivedByteOffset()) {
     locally_closed_streams_highest_offset_[stream_id] =
         stream->flow_controller()->highest_received_byte_offset();
   }
 
-  stream_map_.erase(it);
+  dynamic_stream_map_.erase(it);
   stream->OnClose();
   // Decrease the number of streams being emulated when a new one is opened.
-  connection_->SetNumOpenStreams(stream_map_.size());
+  connection_->SetNumOpenStreams(dynamic_stream_map_.size());
 }
 
 void QuicSession::UpdateFlowControlOnFinalReceivedByteOffset(
     QuicStreamId stream_id, QuicStreamOffset final_byte_offset) {
   map<QuicStreamId, QuicStreamOffset>::iterator it =
       locally_closed_streams_highest_offset_.find(stream_id);
   if (it == locally_closed_streams_highest_offset_.end()) {
     return;
   }
 
@@ skipping 51 matching lines @@
   }
   if (config_.HasReceivedInitialSessionFlowControlWindowBytes()) {
     OnNewSessionFlowControlWindow(
         config_.ReceivedInitialSessionFlowControlWindowBytes());
   }
 }
 
 void QuicSession::EnableAutoTuneReceiveWindow() {
   flow_controller_.set_auto_tune_receive_window(true);
   // Inform all existing streams about the new window.
-  GetCryptoStream()->flow_controller()->set_auto_tune_receive_window(true);
-  headers_stream_->flow_controller()->set_auto_tune_receive_window(true);
-  for (auto const& kv : stream_map_) {
+  for (auto const& kv : static_stream_map_) {
+    kv.second->flow_controller()->set_auto_tune_receive_window(true);
+  }
+  for (auto const& kv : dynamic_stream_map_) {
     kv.second->flow_controller()->set_auto_tune_receive_window(true);
   }
 }
 
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid stream flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
 
   // Inform all existing streams about the new window.
-  GetCryptoStream()->UpdateSendWindowOffset(new_window);
-  headers_stream_->UpdateSendWindowOffset(new_window);
-  for (auto const& kv : stream_map_) {
+  for (auto const& kv : static_stream_map_) {
+    kv.second->UpdateSendWindowOffset(new_window);
+  }
+  for (auto const& kv : dynamic_stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
 }
 
 void QuicSession::OnNewSessionFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid session flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
@@ skipping 36 matching lines @@
 }
 
 void QuicSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
 }
 
 QuicConfig* QuicSession::config() {
   return &config_;
 }
 
-void QuicSession::ActivateStream(QuicDataStream* stream) {
-  DVLOG(1) << ENDPOINT << "num_streams: " << stream_map_.size()
+void QuicSession::ActivateStream(ReliableQuicStream* stream) {
+  DVLOG(1) << ENDPOINT << "num_streams: " << dynamic_stream_map_.size()
            << ". activating " << stream->id();
-  DCHECK_EQ(stream_map_.count(stream->id()), 0u);
-  stream_map_[stream->id()] = stream;
+  DCHECK_EQ(dynamic_stream_map_.count(stream->id()), 0u);
+  dynamic_stream_map_[stream->id()] = stream;
   // Increase the number of streams being emulated when a new one is opened.
-  connection_->SetNumOpenStreams(stream_map_.size());
+  connection_->SetNumOpenStreams(dynamic_stream_map_.size());
 }
 
 QuicStreamId QuicSession::GetNextStreamId() {
   QuicStreamId id = next_stream_id_;
   next_stream_id_ += 2;
   return id;
 }
 
 ReliableQuicStream* QuicSession::GetStream(const QuicStreamId stream_id) {
-  if (stream_id == kCryptoStreamId) {
-    return GetCryptoStream();
+  StreamMap::iterator it = static_stream_map_.find(stream_id);
+  if (it != static_stream_map_.end()) {
+    return it->second;
   }
-  if (stream_id == kHeadersStreamId) {
-    return headers_stream_.get();
-  }
-  return GetDataStream(stream_id);
+  return GetDynamicStream(stream_id);
 }
 
-QuicDataStream* QuicSession::GetDataStream(const QuicStreamId stream_id) {
-  if (stream_id == kCryptoStreamId) {
-    DLOG(FATAL) << "Attempt to call GetDataStream with the crypto stream id";
-    return nullptr;
-  }
-  if (stream_id == kHeadersStreamId) {
-    DLOG(FATAL) << "Attempt to call GetDataStream with the headers stream id";
+ReliableQuicStream* QuicSession::GetDynamicStream(
+    const QuicStreamId stream_id) {
+  if (static_stream_map_.find(stream_id) != static_stream_map_.end()) {
+    DLOG(FATAL) << "Attempt to call GetDynamicStream for a static stream";
     return nullptr;
   }
 
-  DataStreamMap::iterator it = stream_map_.find(stream_id);
-  if (it != stream_map_.end()) {
+  StreamMap::iterator it = dynamic_stream_map_.find(stream_id);
+  if (it != dynamic_stream_map_.end()) {
     return it->second;
   }
 
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
 
   if (stream_id % 2 == next_stream_id_ % 2) {
     // We've received a frame for a locally-created stream that is not
     // currently active.  This is an error.
     if (connection()->connected()) {
       connection()->SendConnectionClose(QUIC_PACKET_FOR_NONEXISTENT_STREAM);
     }
     return nullptr;
   }
 
-  return GetIncomingDataStream(stream_id);
+  return GetIncomingDynamicStream(stream_id);
 }
 
-QuicDataStream* QuicSession::GetIncomingDataStream(QuicStreamId stream_id) {
+ReliableQuicStream* QuicSession::GetIncomingDynamicStream(
+    QuicStreamId stream_id) {
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
 
   implicitly_created_streams_.erase(stream_id);
   if (stream_id > largest_peer_created_stream_id_) {
     if (stream_id - largest_peer_created_stream_id_ > kMaxStreamIdDelta) {
       // We may already have sent a connection close due to multiple reset
       // streams in the same packet.
       if (connection()->connected()) {
         LOG(ERROR) << "Trying to get stream: " << stream_id
                    << ", largest peer created stream: "
                    << largest_peer_created_stream_id_
                    << ", max delta: " << kMaxStreamIdDelta;
         connection()->SendConnectionClose(QUIC_INVALID_STREAM_ID);
       }
       return nullptr;
     }
-    if (largest_peer_created_stream_id_ == 0 &&
-        perspective() == Perspective::IS_SERVER) {
-      largest_peer_created_stream_id_ = 3;
-    }
     for (QuicStreamId id = largest_peer_created_stream_id_ + 2;
          id < stream_id;
          id += 2) {
       implicitly_created_streams_.insert(id);
     }
     largest_peer_created_stream_id_ = stream_id;
   }
-  QuicDataStream* stream = CreateIncomingDataStream(stream_id);
+  ReliableQuicStream* stream = CreateIncomingDynamicStream(stream_id);
   if (stream == nullptr) {
     return nullptr;
   }
   ActivateStream(stream);
   return stream;
 }
 
 void QuicSession::set_max_open_streams(size_t max_open_streams) {
   DVLOG(1) << "Setting max_open_streams_ to " << max_open_streams;
   max_open_streams_ = max_open_streams;
 }
 
 bool QuicSession::IsClosedStream(QuicStreamId id) {
   DCHECK_NE(0u, id);
-  if (id == kCryptoStreamId) {
-    return false;
-  }
-  if (id == kHeadersStreamId) {
-    return false;
-  }
-  if (ContainsKey(stream_map_, id)) {
+  if (ContainsKey(static_stream_map_, id) ||
+      ContainsKey(dynamic_stream_map_, id)) {
     // Stream is active
     return false;
   }
   if (id % 2 == next_stream_id_ % 2) {
     // Locally created streams are strictly in-order.  If the id is in the
     // range of created streams and it's not active, it must have been closed.
     return id < next_stream_id_;
   }
   // For peer created streams, we also need to consider implicitly created
   // streams.
   return id <= largest_peer_created_stream_id_ &&
       !ContainsKey(implicitly_created_streams_, id);
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
-  return stream_map_.size() + implicitly_created_streams_.size();
+  return dynamic_stream_map_.size() + implicitly_created_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != nullptr) {
     LOG_IF(DFATAL, priority != stream->EffectivePriority())
         << ENDPOINT << "Stream " << id
         << "Priorities do not match.  Got: " << priority
         << " Expected: " << stream->EffectivePriority();
@@ skipping 27 matching lines @@
     // A buggy client may fail to send FIN/RSTs. Don't tolerate this.
     connection_->SendConnectionClose(QUIC_TOO_MANY_UNFINISHED_STREAMS);
   }
 }
 
 bool QuicSession::IsConnectionFlowControlBlocked() const {
   return flow_controller_.IsBlocked();
 }
 
 bool QuicSession::IsStreamFlowControlBlocked() {
-  if (headers_stream_->flow_controller()->IsBlocked() ||
-      GetCryptoStream()->flow_controller()->IsBlocked()) {
-    return true;
-  }
-  for (auto const& kv : stream_map_) {
+  for (auto const& kv : static_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
     }
+  }
+  for (auto const& kv : dynamic_stream_map_) {
+    if (kv.second->flow_controller()->IsBlocked()) {
+      return true;
+    }
   }
   return false;
 }
 
 }  // namespace net