Part of QUIC v39 change: 1) do not ack acks. 2) Send a WINDOW_UPDATE frame every 20 packets which d…

net/quic/core/quic_flow_controller.cc

 // Copyright 2014 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_flow_controller.h"
 
 #include <cstdint>
 
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_packets.h"
@@ skipping 184 matching lines @@
   }
 
   if (available_window >= threshold) {
     QUIC_DVLOG(1) << ENDPOINT << "Not sending WindowUpdate for stream " << id_
                   << ", available window: " << available_window
                   << " >= threshold: " << threshold;
     return;
   }
 
   MaybeIncreaseMaxWindowSize();
-  SendWindowUpdate(available_window);
+  UpdateReceiveWindowOffsetAndSendWindowUpdate(available_window);
 }
 
-void QuicFlowController::SendWindowUpdate(QuicStreamOffset available_window) {
+void QuicFlowController::UpdateReceiveWindowOffsetAndSendWindowUpdate(
+    QuicStreamOffset available_window) {
   // Update our receive window.
   receive_window_offset_ += (receive_window_size_ - available_window);
 
   QUIC_DVLOG(1) << ENDPOINT << "Sending WindowUpdate frame for stream " << id_
                 << ", consumed bytes: " << bytes_consumed_
                 << ", available window: " << available_window
                 << ", and threshold: " << WindowUpdateThreshold()
                 << ", and receive window size: " << receive_window_size_
                 << ". New receive window offset is: " << receive_window_offset_;
 
-  // Inform the peer of our new receive window.
-  connection_->SendWindowUpdate(id_, receive_window_offset_);
+  SendWindowUpdate();
 }
 
 void QuicFlowController::MaybeSendBlocked() {
   if (SendWindowSize() == 0 &&
       last_blocked_send_window_offset_ < send_window_offset_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id_
                     << " is flow control blocked. "
                     << "Send window: " << SendWindowSize()
                     << ", bytes sent: " << bytes_sent_
                     << ", send limit: " << send_window_offset_;
@@ skipping 27 matching lines @@
   return was_previously_blocked;
 }
 
 void QuicFlowController::EnsureWindowAtLeast(QuicByteCount window_size) {
   if (receive_window_size_limit_ >= window_size) {
     return;
   }
 
   QuicStreamOffset available_window = receive_window_offset_ - bytes_consumed_;
   IncreaseWindowSize();
-  SendWindowUpdate(available_window);
+  UpdateReceiveWindowOffsetAndSendWindowUpdate(available_window);
 }
 
 bool QuicFlowController::IsBlocked() const {
   return SendWindowSize() == 0;
 }
 
 uint64_t QuicFlowController::SendWindowSize() const {
   if (bytes_sent_ > send_window_offset_) {
     return 0;
   }
   return send_window_offset_ - bytes_sent_;
 }
 
 void QuicFlowController::UpdateReceiveWindowSize(QuicStreamOffset size) {
   DCHECK_LE(size, receive_window_size_limit_);
   QUIC_DVLOG(1) << ENDPOINT << "UpdateReceiveWindowSize for stream " << id_
                 << ": " << size;
   if (receive_window_size_ != receive_window_offset_) {
     QUIC_BUG << "receive_window_size_:" << receive_window_size_
              << " != receive_window_offset:" << receive_window_offset_;
     return;
   }
   receive_window_size_ = size;
   receive_window_offset_ = size;
 }
 
+void QuicFlowController::SendWindowUpdate() {
+  connection_->SendWindowUpdate(id_, receive_window_offset_);
+}
+
 }  // namespace net