Remove is_deletable_ from QuicStream. Add QuicStream::IsWaitingForAcks

net/quic/core/quic_stream.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_stream.h"
 
 #include "net/quic/core/quic_flow_controller.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
@@ skipping 47 matching lines @@
       stream_error_(QUIC_STREAM_NO_ERROR),
       connection_error_(QUIC_NO_ERROR),
       read_side_closed_(false),
       write_side_closed_(false),
       fin_buffered_(false),
       fin_sent_(false),
       fin_acked_(false),
       fin_received_(false),
       rst_sent_(false),
       rst_received_(false),
-      is_deletable_(true),
       perspective_(session_->perspective()),
       flow_controller_(session_->connection(),
                        id_,
                        perspective_,
                        GetReceivedFlowControlWindow(session),
                        GetInitialStreamFlowControlWindowToSend(session),
                        session_->flow_controller()->auto_tune_receive_window(),
                        session_->flow_controller()),
       connection_flow_controller_(session_->flow_controller()),
       stream_contributes_to_connection_flow_control_(true),
       busy_counter_(0),
       add_random_padding_after_fin_(false),
       ack_listener_(nullptr) {
   SetFromConfig();
 }
 
 QuicStream::~QuicStream() {
-  QUIC_LOG_IF(WARNING, !is_deletable_)
-      << "Stream destroyed while not deletable.";
+  QUIC_LOG_IF(WARNING, !IsWaitingForAcks())
+      << "Stream destroyed while waiting for acks.";
 }
 
 void QuicStream::SetFromConfig() {}
 
 void QuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK_EQ(frame.stream_id, id_);
 
   DCHECK(!(read_side_closed_ && write_side_closed_));
 
   if (frame.fin) {
@@ skipping 45 matching lines @@
   rst_received_ = true;
   MaybeIncreaseHighestReceivedOffset(frame.byte_offset);
 
   stream_error_ = frame.error_code;
   CloseWriteSide();
   CloseReadSide();
 }
 
 void QuicStream::OnConnectionClosed(QuicErrorCode error,
                                     ConnectionCloseSource /*source*/) {
-  if (session()->use_stream_notifier()) {
-    // Connection is closed, consider this stream as deletable.
-    SetIsDeletable(true);
-  }
   if (read_side_closed_ && write_side_closed_) {
     return;
   }
   if (error != QUIC_NO_ERROR) {
     stream_error_ = QUIC_STREAM_CONNECTION_ERROR;
     connection_error_ = error;
   }
 
   CloseWriteSide();
   CloseReadSide();
 }
 
 void QuicStream::OnFinRead() {
   DCHECK(sequencer_.IsClosed());
   // OnFinRead can be called due to a FIN flag in a headers block, so there may
   // have been no OnStreamFrame call with a FIN in the frame.
   fin_received_ = true;
   // If fin_sent_ is true, then CloseWriteSide has already been called, and the
   // stream will be destroyed by CloseReadSide, so don't need to call
   // StreamDraining.
   CloseReadSide();
 }
 
 void QuicStream::Reset(QuicRstStreamErrorCode error) {
   stream_error_ = error;
   // Sending a RstStream results in calling CloseStream.
   session()->SendRstStream(id(), error, stream_bytes_written_);
   rst_sent_ = true;
-  if (session()->use_stream_notifier() && error != QUIC_STREAM_NO_ERROR) {
-    // This stream is deletable as data is not going to be retransmitted.
-    SetIsDeletable(true);
+  if (session()->use_stream_notifier() && !IsWaitingForAcks()) {
+    session_->OnStreamDoneWaitingForAcks(id_);
   }
 }
 
 void QuicStream::CloseConnectionWithDetails(QuicErrorCode error,
                                             const string& details) {
   session()->connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 void QuicStream::WriteOrBufferData(
@@ skipping 159 matching lines @@
       CloseWriteSide();
     } else if (fin && !consumed_data.fin_consumed) {
       session_->MarkConnectionLevelWriteBlocked(id());
     }
   } else {
     session_->MarkConnectionLevelWriteBlocked(id());
   }
   if (consumed_data.bytes_consumed > 0 || consumed_data.fin_consumed) {
     busy_counter_ = 0;
   }
-  if (session()->use_stream_notifier() &&
-      (stream_bytes_written_ > stream_bytes_acked_ ||
-       (fin && consumed_data.fin_consumed))) {
-    // This stream is considered not deletable when it has unacked data
-    // (including FIN).
-    SetIsDeletable(false);
-  }
   return consumed_data;
 }
 
 QuicConsumedData QuicStream::WritevDataInner(
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   StreamSendingState state = fin ? FIN : NO_FIN;
   if (fin && add_random_padding_after_fin_) {
@@ skipping 123 matching lines @@
 void QuicStream::UpdateSendWindowOffset(QuicStreamOffset new_window) {
   if (flow_controller_.UpdateSendWindowOffset(new_window)) {
     OnCanWrite();
   }
 }
 
 void QuicStream::AddRandomPaddingAfterFin() {
   add_random_padding_after_fin_ = true;
 }
 
-void QuicStream::SetIsDeletable(bool is_deletable) {
-  is_deletable_ = is_deletable;
-  if (is_deletable) {
-    session_->MarkStreamDeletable(id_);
-  }
-}
-
 void QuicStream::OnStreamFrameAcked(const QuicStreamFrame& frame,
                                     QuicTime::Delta ack_delay_time) {
   DCHECK_EQ(frame.stream_id, id());
   stream_bytes_acked_ += frame.data_length;
   if (stream_bytes_acked_ > stream_bytes_written_) {
     CloseConnectionWithDetails(QUIC_INTERNAL_ERROR,
                                "Unsent stream data is acked");
     return;
   }
   if (frame.fin) {
     fin_acked_ = true;
   }
   if (ack_listener_ != nullptr) {
     ack_listener_->OnPacketAcked(frame.data_length, ack_delay_time);
   }
-  if (stream_bytes_acked_ == stream_bytes_written_ &&
-      ((fin_sent_ && fin_acked_) || !fin_sent_)) {
-    // This stream is considered deletable when all sent bytes are acked
-    // (including FIN).
-    SetIsDeletable(true);
+  if (!IsWaitingForAcks()) {
+    session_->OnStreamDoneWaitingForAcks(id_);
   }
 }
 
 void QuicStream::OnStreamFrameRetransmitted(const QuicStreamFrame& frame) {
   if (ack_listener_ != nullptr) {
     ack_listener_->OnPacketRetransmitted(frame.data_length);
   }
 }
 
+bool QuicStream::IsWaitingForAcks() const {
+  if (rst_sent_ && stream_error_ != QUIC_STREAM_NO_ERROR) {
+    // RST_STREAM sent because of error.
+    return false;
+  }
+  if (connection_error_ != QUIC_NO_ERROR) {
+    // Connection encounters error and is going to close.
+    return false;
+  }
+  if (stream_bytes_acked_ == stream_bytes_written_ &&
+      ((fin_sent_ && fin_acked_) || !fin_sent_)) {
+    // All sent data has been acked.
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace net