This QUIC change includes:

net/quic/core/quic_stream.cc

Index: net/quic/core/quic_stream.cc
diff --git a/net/quic/core/quic_stream.cc b/net/quic/core/quic_stream.cc
index 733a805084ff331da83b6c6c8944af3c9ab68381..6e9b2bd2acf947a950923a3bc9d8ab663b825530 100644
--- a/net/quic/core/quic_stream.cc
+++ b/net/quic/core/quic_stream.cc
@@ -54,15 +54,18 @@ QuicStream::QuicStream(QuicStreamId id, QuicSession* session)
       session_(session),
       stream_bytes_read_(0),
       stream_bytes_written_(0),
+      stream_bytes_acked_(0),
       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_,
@@ -74,11 +77,15 @@ QuicStream::QuicStream(QuicStreamId id, QuicSession* session)
       connection_flow_controller_(session_->flow_controller()),
       stream_contributes_to_connection_flow_control_(true),
       busy_counter_(0),
-      add_random_padding_after_fin_(false) {
+      add_random_padding_after_fin_(false),
+      ack_listener_(nullptr) {
   SetFromConfig();
 }
 
-QuicStream::~QuicStream() {}
+QuicStream::~QuicStream() {
+  QUIC_LOG_IF(WARNING, !is_deletable_)
+      << "Stream destroyed while not deletable.";
+}
 
 void QuicStream::SetFromConfig() {}
 
@@ -143,6 +150,10 @@ void QuicStream::OnStreamReset(const QuicRstStreamFrame& frame) {
 
 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;
   }
@@ -171,6 +182,10 @@ void QuicStream::Reset(QuicRstStreamErrorCode 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);
+  }
 }
 
 void QuicStream::CloseConnectionWithDetails(QuicErrorCode error,
@@ -349,6 +364,13 @@ QuicConsumedData QuicStream::WritevData(
   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;
 }
 
@@ -492,4 +514,40 @@ 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);
+  }
+}
+
+void QuicStream::OnStreamFrameRetransmitted(const QuicStreamFrame& frame) {
+  if (ack_listener_ != nullptr) {
+    ack_listener_->OnPacketRetransmitted(frame.data_length);
+  }
+}
+
 }  // namespace net