Landing Recent QUIC changes until 03:18 AM, May 28, UTC

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),
       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, !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) {
     fin_received_ = true;
@@ skipping 72 matching lines @@
   // 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() && !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(
     QuicStringPiece data,
@@ skipping 301 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::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 (!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