relnote: QUIC bugfix (and test) for setting smaller receive window size

net/quic/quic_session.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/quic_session.h"
 
 #include "base/stl_util.h"
 #ifdef TEMP_INSTRUMENTATION_473893
 #include "base/debug/alias.h"
 #endif
@@ skipping 407 matching lines @@
     // limit sent to the client. This helps avoid early connection termination
     // when FIN/RSTs for old streams are lost or arrive out of order.
     // Use a minimum number of additional streams, or a percentage increase,
     // whichever is larger.
     max_streams =
         max(max_streams + kMaxStreamsMinimumIncrement,
             static_cast<uint32>(max_streams * kMaxStreamsMultiplier));
 
     if (config_.HasReceivedConnectionOptions()) {
       if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kAFCW)) {
+        // The following variations change the initial receive flow control
+        // window sizes.
+        if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW5)) {
+          AdjustInitialFlowControlWindows(32 * 1024);
+        }
+        if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW6)) {
+          AdjustInitialFlowControlWindows(64 * 1024);
+        }
+        if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW7)) {
+          AdjustInitialFlowControlWindows(128 * 1024);
+        }
         EnableAutoTuneReceiveWindow();
       }
-      // The following variations change the initial receive flow control window
-      // size for streams.  For simplicity reasons, do not try to effect
-      // existing streams but only future ones.
-      if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW5)) {
-        config_.SetInitialStreamFlowControlWindowToSend(32 * 1024);
-      }
-      if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW6)) {
-        config_.SetInitialStreamFlowControlWindowToSend(64 * 1024);
-      }
-      if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFW7)) {
-        config_.SetInitialStreamFlowControlWindowToSend(128 * 1024);
-      }
     }
   }
   set_max_open_streams(max_streams);
 
   if (config_.HasReceivedInitialStreamFlowControlWindowBytes()) {
     // Streams which were created before the SHLO was received (0-RTT
     // requests) are now informed of the peer's initial flow control window.
     OnNewStreamFlowControlWindow(
         config_.ReceivedInitialStreamFlowControlWindowBytes());
   }
   if (config_.HasReceivedInitialSessionFlowControlWindowBytes()) {
     OnNewSessionFlowControlWindow(
         config_.ReceivedInitialSessionFlowControlWindowBytes());
   }
 }
 
 void QuicSession::EnableAutoTuneReceiveWindow() {
+  DVLOG(1) << ENDPOINT << "Enable auto tune receive windows";
   flow_controller_.set_auto_tune_receive_window(true);
   // Inform all existing streams about the new window.
   for (auto const& kv : static_stream_map_) {
     kv.second->flow_controller()->set_auto_tune_receive_window(true);
   }
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->flow_controller()->set_auto_tune_receive_window(true);
   }
 }
 
+void QuicSession::AdjustInitialFlowControlWindows(size_t stream_window) {
+  const float session_window_multiplier =
+      config_.GetInitialStreamFlowControlWindowToSend()
+          ? static_cast<float>(
+                config_.GetInitialSessionFlowControlWindowToSend()) /
+                config_.GetInitialStreamFlowControlWindowToSend()
+          : 1.0;
+  DVLOG(1) << ENDPOINT << "Set stream receive window to " << stream_window;
+  config_.SetInitialStreamFlowControlWindowToSend(stream_window);
+  // Reduce the session window as well, motivation is reducing resource waste
+  // and denial of service vulnerability, as with the stream window.  Session
+  // size is set according to the ratio between session and stream window size
+  // previous to auto-tuning. Note that the ratio may change dynamically, since
+  // auto-tuning acts independently for each flow controller.
+  size_t session_window = session_window_multiplier * stream_window;
+  DVLOG(1) << ENDPOINT << "Set session receive window to " << session_window;
+  config_.SetInitialSessionFlowControlWindowToSend(session_window);
+  flow_controller_.UpdateReceiveWindowSize(session_window);
+  // Inform all existing streams about the new window.
+  for (auto const& kv : static_stream_map_) {
+    kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
+  }
+  for (auto const& kv : dynamic_stream_map_) {
+    kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
+  }
+}
+
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid stream flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
       connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
     }
     return;
   }
@@ skipping 282 matching lines @@
   base::debug::StackTrace stack_trace = stack_trace_;
 
   base::debug::Alias(&liveness);
   base::debug::Alias(&stack_trace);
 
   CHECK_EQ(ALIVE, liveness);
 #endif
 }
 
 }  // namespace net