Connection level flow control (CLFC) accounting on receipt of FIN/RST

net/quic/reliable_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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 103 matching lines @@
       id_(id),
       session_(session),
       stream_bytes_read_(0),
       stream_bytes_written_(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_received_(false),
       rst_sent_(false),
+      rst_received_(false),
       is_server_(session_->is_server()),
       flow_controller_(
           session_->connection(),
           id_,
           is_server_,
           session_->config()->HasReceivedInitialFlowControlWindowBytes() ?
               session_->config()->ReceivedInitialFlowControlWindowBytes() :
               kDefaultFlowControlSendWindow,
           session_->max_flow_control_receive_window_bytes(),
           session_->max_flow_control_receive_window_bytes()),
       connection_flow_controller_(session_->flow_controller()) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
 bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (read_side_closed_) {
     DVLOG(1) << ENDPOINT << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
     return true;
   }
 
   if (frame.stream_id != id_) {
     LOG(ERROR) << "Error!";
     return false;
   }
 
+  if (frame.fin) {
+    fin_received_ = true;
+  }
+
   // This count include duplicate data received.
   size_t frame_payload_size = frame.data.TotalBufferSize();
   stream_bytes_read_ += frame_payload_size;
 
   // Flow control is interested in tracking highest received offset.
   if (MaybeIncreaseHighestReceivedOffset(frame.offset + frame_payload_size)) {
     // As the highest received offset has changed, we should check to see if
     // this is a violation of flow control.
     if (flow_controller_.FlowControlViolation() ||
         connection_flow_controller_->FlowControlViolation()) {
       session_->connection()->SendConnectionClose(
           QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
       return false;
     }
   }
 
   return sequencer_.OnStreamFrame(frame);
 }
 
 int ReliableQuicStream::num_frames_received() const {
   return sequencer_.num_frames_received();
 }
 
 int ReliableQuicStream::num_duplicate_frames_received() const {
   return sequencer_.num_duplicate_frames_received();
 }
 
 void ReliableQuicStream::OnStreamReset(const QuicRstStreamFrame& frame) {
+  rst_received_ = true;
   MaybeIncreaseHighestReceivedOffset(frame.byte_offset);
 
   stream_error_ = frame.error_code;
   CloseWriteSide();
   CloseReadSide();
 }
 
 void ReliableQuicStream::OnConnectionClosed(QuicErrorCode error,
                                             bool from_peer) {
   if (read_side_closed_ && write_side_closed_) {
@@ skipping 288 matching lines @@
     connection_flow_controller_->AddBytesConsumed(bytes);
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   return flow_controller_.IsBlocked() ||
          connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net