This QUIC change includes:

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 36 matching lines @@
 
 QuicStream::PendingData::~PendingData() {}
 
 QuicStream::QuicStream(QuicStreamId id, QuicSession* session)
     : queued_data_bytes_(0),
       sequencer_(this, session->connection()->clock()),
       id_(id),
       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_,
                        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) {
+      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() {}
 
 void QuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK_EQ(frame.stream_id, id_);
 
   DCHECK(!(read_side_closed_ && write_side_closed_));
 
   if (frame.fin) {
     fin_received_ = true;
@@ skipping 44 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);
+  }
 }
 
 void QuicStream::CloseConnectionWithDetails(QuicErrorCode error,
                                             const string& details) {
   session()->connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 void QuicStream::WriteOrBufferData(
     QuicStringPiece data,
@@ skipping 158 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);
+  }
+}
+
+void QuicStream::OnStreamFrameRetransmitted(const QuicStreamFrame& frame) {
+  if (ack_listener_ != nullptr) {
+    ack_listener_->OnPacketRetransmitted(frame.data_length);
+  }
+}
+
 }  // namespace net