Remove is_deletable_ from QuicStream. Add QuicStream::IsWaitingForAcks

net/quic/core/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/core/quic_session.h"
 
 #include <cstdint>
 #include <utility>
 
 #include "net/quic/core/quic_connection.h"
@@ skipping 54 matching lines @@
                            max_open_incoming_streams_)
       << "Surprisingly high number of locally closed peer initiated streams"
          "still waiting for final byte offset: "
       << num_locally_closed_incoming_streams_highest_offset();
   QUIC_LOG_IF(WARNING, GetNumLocallyClosedOutgoingStreamsHighestOffset() >
                            max_open_outgoing_streams_)
       << "Surprisingly high number of locally closed self initiated streams"
          "still waiting for final byte offset: "
       << GetNumLocallyClosedOutgoingStreamsHighestOffset();
   QUIC_LOG_IF(WARNING, !zombie_streams_.empty()) << "Still have zombie streams";
-  for (const auto& kv : dynamic_stream_map_) {
-    QUIC_LOG_IF(WARNING, !kv.second->is_deletable())
-        << "Still have non-deletable stream";
-  }
 }
 
 void QuicSession::OnStreamFrame(const QuicStreamFrame& frame) {
   // TODO(rch) deal with the error case of stream id 0.
   QuicStreamId stream_id = frame.stream_id;
   QuicStream* stream = GetOrCreateStream(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.
@@ skipping 46 matching lines @@
     // The stream should call CloseStream as part of OnConnectionClosed.
     if (dynamic_stream_map_.find(id) != dynamic_stream_map_.end()) {
       QUIC_BUG << ENDPOINT << "Stream failed to close under OnConnectionClosed";
       CloseStream(id);
     }
   }
 
   // Cleanup zombie stream map on connection close.
   while (!zombie_streams_.empty()) {
     ZombieStreamMap::iterator it = zombie_streams_.begin();
-    // Do not call OnConnectionClose as this may trigger unexpected operations
-    // in subclass of QuicStream.
-    it->second->SetIsDeletable(true);
+    closed_streams_.push_back(std::move(it->second));
+    zombie_streams_.erase(it);
   }
 
   if (visitor_) {
     visitor_->OnConnectionClosed(connection_->connection_id(), error,
                                  error_details);
   }
 }
 
 void QuicSession::OnWriteBlocked() {
   if (visitor_) {
@@ skipping 222 matching lines @@
     QUIC_DLOG(INFO) << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   QuicStream* stream = it->second.get();
 
   // Tell the stream that a RST has been sent.
   if (locally_reset) {
     stream->set_rst_sent(true);
   }
 
-  if (stream->is_deletable()) {
+  if (stream->IsWaitingForAcks()) {
+    zombie_streams_[stream->id()] = std::move(it->second);
+  } else {
     closed_streams_.push_back(std::move(it->second));
-  } else {
-    zombie_streams_[stream->id()] = std::move(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()) {
     InsertLocallyClosedStreamsHighestOffset(
         stream_id, stream->flow_controller()->highest_received_byte_offset());
   }
 
@@ skipping 555 matching lines @@
   return CreateAndActivateStream(GetNextOutgoingStreamId());
 }
 
 QuicStream* QuicSession::CreateAndActivateStream(QuicStreamId id) {
   std::unique_ptr<QuicStream> stream = CreateStream(id);
   QuicStream* stream_ptr = stream.get();
   ActivateStream(std::move(stream));
   return stream_ptr;
 }
 
-void QuicSession::MarkStreamDeletable(QuicStreamId id) {
+void QuicSession::OnStreamDoneWaitingForAcks(QuicStreamId id) {
   auto it = zombie_streams_.find(id);
   if (it == zombie_streams_.end()) {
     return;
   }
 
   closed_streams_.push_back(std::move(it->second));
   zombie_streams_.erase(it);
 }
 
 QuicStream* QuicSession::GetStream(QuicStreamId id) const {
@@ skipping 21 matching lines @@
 }
 
 void QuicSession::OnStreamFrameRetransmitted(const QuicStreamFrame& frame) {
   QuicStream* stream = GetStream(frame.stream_id);
   if (stream != nullptr) {
     stream->OnStreamFrameRetransmitted(frame);
   }
 }
 
 }  // namespace net