If the stream is being closed locally (for example in the case of a

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/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::vector;
 
 namespace net {
 
 const size_t kMaxPrematurelyClosedStreamsTracked = 20;
+const size_t kMaxZombieStreams = 20;
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 // We want to make sure we delete any closed streams in a safe manner.
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
 // processing.
 //
 // We could just override the base methods, but this makes it easier to make
 // sure we don't miss any.
@@ skipping 95 matching lines @@
 
     ReliableQuicStream* stream = GetStream(frames[i].stream_id);
     if (stream == NULL) return false;
     if (!stream->WillAcceptStreamFrame(frames[i])) return false;
 
     // TODO(alyssar) check against existing connection address: if changed, make
     // sure we update the connection.
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
-    ReliableQuicStream* stream = GetStream(frames[i].stream_id);
-    if (stream) {
-      stream->OnStreamFrame(frames[i]);
+    QuicStreamId stream_id = frames[i].stream_id;
+    ReliableQuicStream* stream = GetStream(stream_id);
+    if (!stream) {
+      continue;
+    }
+    stream->OnStreamFrame(frames[i]);
+
+    // If the stream had been prematurely closed, and the
+    // headers are now decompressed, then we are finally finished
+    // with this stream.
+    if (ContainsKey(zombie_streams_, stream_id) &&
+        stream->headers_decompressed()) {
+      CloseZombieStream(stream_id);
     }
   }
 
   while (!decompression_blocked_streams_.empty()) {
     QuicHeaderId header_id = decompression_blocked_streams_.begin()->first;
     if (header_id != decompressor_.current_header_id()) {
       break;
     }
     QuicStreamId stream_id = decompression_blocked_streams_.begin()->second;
     decompression_blocked_streams_.erase(header_id);
     ReliableQuicStream* stream = GetStream(stream_id);
     if (!stream) {
       connection()->SendConnectionClose(
           QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
       return false;
     }
     stream->OnDecompressorAvailable();
   }
   return true;
 }
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   ReliableQuicStream* stream = GetStream(frame.stream_id);
   if (!stream) {
     return;  // Errors are handled by GetStream.
   }
+  if (ContainsKey(zombie_streams_, stream->id())) {
+    // If this was a zombie stream then we close it out now.
+    CloseZombieStream(stream->id());
+    // However, since the headers still have not been decompressed, we want to
+    // mark it a prematurely closed so that if we ever receive frames
+    // for this stream we can close the connection.
+    DCHECK(!stream->headers_decompressed());
+    AddPrematurelyClosedStream(frame.stream_id);
+    return;
+  }
   stream->OnStreamReset(frame.error_code);
 }
 
 void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
   DCHECK(frame.last_good_stream_id < next_stream_id_);
   goaway_received_ = true;
 }
 
 void QuicSession::ConnectionClose(QuicErrorCode error, bool from_peer) {
+  DCHECK(!connection_->connected());
   if (error_ == QUIC_NO_ERROR) {
     error_ = error;
   }
 
   while (stream_map_.size() != 0) {
     ReliableStreamMap::iterator it = stream_map_.begin();
     QuicStreamId id = it->first;
     it->second->ConnectionClose(error, from_peer);
     // The stream should call CloseStream as part of ConnectionClose.
     if (stream_map_.find(id) != stream_map_.end()) {
@@ skipping 30 matching lines @@
 QuicConsumedData QuicSession::WriteData(QuicStreamId id,
                                         StringPiece data,
                                         QuicStreamOffset offset,
                                         bool fin) {
   return connection_->SendStreamData(id, data, offset, fin);
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error) {
   connection_->SendRstStream(id, error);
-  CloseStream(id);
+  CloseStreamInner(id, true);
 }
 
 void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
   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) {
   DLOG(INFO) << ENDPOINT << "Closing stream " << stream_id;
 
   ReliableStreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
     DLOG(INFO) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   ReliableQuicStream* stream = it->second;
-  if (!stream->headers_decompressed()) {
-    if (prematurely_closed_streams_.size() ==
-        kMaxPrematurelyClosedStreamsTracked) {
-      prematurely_closed_streams_.erase(prematurely_closed_streams_.begin());
+  if (connection_->connected() && !stream->headers_decompressed()) {
+    // If the stream is being closed locally (for example a client cancelling
+    // a request before receiving the response) then we need to make sure that
+    // we keep the stream alive long enough to process any response or
+    // RST_STREAM frames.
+    if (locally_reset && !is_server_) {
+      AddZombieStream(stream_id);
+      return;
     }
-    prematurely_closed_streams_.insert(make_pair(stream->id(), true));
+
+    // This stream has been closed before the headers were decompressed.
+    // This might cause problems with head of line blocking of headers.
+    // If the peer sent headers which were lost but we now close the stream
+    // we will never be able to decompress headers for other streams.
+    // To deal with this, we keep track of streams which have been closed
+    // prematurely.  If we ever receive data frames for this steam, then we
+    // know there actually has been a problem and we close the connection.
+    AddPrematurelyClosedStream(stream->id());
   }
   closed_streams_.push_back(it->second);
   stream_map_.erase(it);
   stream->OnClose();
 }
 
+void QuicSession::AddZombieStream(QuicStreamId stream_id) {
+  if (zombie_streams_.size() == kMaxZombieStreams) {
+    QuicStreamId oldest_zombie_stream_id = zombie_streams_.begin()->first;
+    CloseZombieStream(oldest_zombie_stream_id);
+    // However, since the headers still have not been decompressed, we want to
+    // mark it a prematurely closed so that if we ever receive frames
+    // for this stream we can close the connection.
+    AddPrematurelyClosedStream(oldest_zombie_stream_id);
+  }
+  zombie_streams_.insert(make_pair(stream_id, true));
+}
+
+void QuicSession::CloseZombieStream(QuicStreamId stream_id) {
+  DCHECK(ContainsKey(zombie_streams_, stream_id));
+  zombie_streams_.erase(stream_id);
+  ReliableQuicStream* stream = GetStream(stream_id);
+  if (!stream) {
+    return;
+  }
+  stream_map_.erase(stream_id);
+  stream->OnClose();
+  closed_streams_.push_back(stream);
+}
+
+void QuicSession::AddPrematurelyClosedStream(QuicStreamId stream_id) {
+  if (prematurely_closed_streams_.size() ==
+      kMaxPrematurelyClosedStreamsTracked) {
+    prematurely_closed_streams_.erase(prematurely_closed_streams_.begin());
+  }
+  prematurely_closed_streams_.insert(make_pair(stream_id, true));
+}
+
 bool QuicSession::IsEncryptionEstablished() {
   return GetCryptoStream()->encryption_established();
 }
 
 bool QuicSession::IsCryptoHandshakeConfirmed() {
   return GetCryptoStream()->handshake_confirmed();
 }
 
 void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   switch (event) {
@@ skipping 106 matching lines @@
   }
   ActivateStream(stream);
   return stream;
 }
 
 bool QuicSession::IsClosedStream(QuicStreamId id) {
   DCHECK_NE(0u, id);
   if (id == kCryptoStreamId) {
     return false;
   }
-  if (stream_map_.count(id) != 0) {
+  if (ContainsKey(zombie_streams_, id)) {
+    return true;
+  }
+  if (ContainsKey(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_ &&
       implicitly_created_streams_.count(id) == 0;
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
-  return stream_map_.size() + implicitly_created_streams_.size();
+  return stream_map_.size() + implicitly_created_streams_.size() -
+      zombie_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id) {
   write_blocked_streams_.PushBack(id, 0);
 }
 
 void QuicSession::MarkDecompressionBlocked(QuicHeaderId header_id,
                                            QuicStreamId stream_id) {
   decompression_blocked_streams_[header_id] = stream_id;
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net