QUIC flow control now based on highest received byte offset rather than

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 133 matching lines @@
     // We don't want to be reading: blackhole the data.
     return true;
   }
 
   if (frame.stream_id != id_) {
     LOG(ERROR) << "Error!";
     return false;
   }
 
   // This count include duplicate data received.
-  stream_bytes_read_ += frame.data.TotalBufferSize();
+  size_t frame_payload_size = frame.data.TotalBufferSize();
+  stream_bytes_read_ += frame_payload_size;
+
+  // Flow control is interested in tracking highest received offset.
+  MaybeIncreaseHighestReceivedOffset(frame.offset + frame_payload_size);
 
   bool accepted = sequencer_.OnStreamFrame(frame);
 
   if (flow_controller_.FlowControlViolation() ||
       connection_flow_controller_->FlowControlViolation()) {
     session_->connection()->SendConnectionClose(QUIC_FLOW_CONTROL_ERROR);
     return false;
   }
 
   return accepted;
 }
 
 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) {
+  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_) {
     return;
   }
@@ skipping 237 matching lines @@
   if (flow_controller_.UpdateSendWindowOffset(frame.byte_offset)) {
     // We can write again!
     // TODO(rjshade): This does not respect priorities (e.g. multiple
     //                outstanding POSTs are unblocked on arrival of
     //                SHLO with initial window).
     // As long as the connection is not flow control blocked, we can write!
     OnCanWrite();
   }
 }
 
-void ReliableQuicStream::AddBytesBuffered(uint64 bytes) {
+void ReliableQuicStream::MaybeIncreaseHighestReceivedOffset(uint64 new_offset) {
   if (flow_controller_.IsEnabled()) {
-    flow_controller_.AddBytesBuffered(bytes);
-    connection_flow_controller_->AddBytesBuffered(bytes);
+    uint64 increment =
+        new_offset - flow_controller_.highest_received_byte_offset();
+    if (flow_controller_.UpdateHighestReceivedOffset(new_offset)) {
+      // If |new_offset| increased the stream flow controller's highest received
+      // offset, then we need to increase the connection flow controller's value
+      // by the incremental difference.
+      connection_flow_controller_->UpdateHighestReceivedOffset(
+          connection_flow_controller_->highest_received_byte_offset() +
+          increment);
+    }
   }
 }
 
-void ReliableQuicStream::RemoveBytesBuffered(uint64 bytes) {
-  if (flow_controller_.IsEnabled()) {
-    flow_controller_.RemoveBytesBuffered(bytes);
-    connection_flow_controller_->RemoveBytesBuffered(bytes);
-  }
-}
-
 void ReliableQuicStream::AddBytesSent(uint64 bytes) {
   if (flow_controller_.IsEnabled()) {
     flow_controller_.AddBytesSent(bytes);
     connection_flow_controller_->AddBytesSent(bytes);
   }
 }
 
 void ReliableQuicStream::AddBytesConsumed(uint64 bytes) {
   if (flow_controller_.IsEnabled()) {
     flow_controller_.AddBytesConsumed(bytes);
     flow_controller_.MaybeSendWindowUpdate(session()->connection());
 
     connection_flow_controller_->AddBytesConsumed(bytes);
     connection_flow_controller_->MaybeSendWindowUpdate(session()->connection());
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   return flow_controller_.IsBlocked() ||
          connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net