deprecate FLAGS_quic_auto_tune_receive_window, FLAGS_quic_enable_autotune_by_defau…

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/crypto/proof_verifier.h"
@@ skipping 27 matching lines @@
           perspective() == Perspective::IS_SERVER ? 1 : 0),
       num_dynamic_incoming_streams_(0),
       num_draining_incoming_streams_(0),
       num_locally_closed_incoming_streams_highest_offset_(0),
       error_(QUIC_NO_ERROR),
       flow_controller_(connection_.get(),
                        0,
                        perspective(),
                        kMinimumFlowControlSendWindow,
                        config_.GetInitialSessionFlowControlWindowToSend(),
-                       FLAGS_quic_enable_autotune_by_default
-                           ? perspective() == Perspective::IS_SERVER
-                           : false),
+                       perspective() == Perspective::IS_SERVER),
       currently_writing_stream_id_(0) {}
 
 void QuicSession::Initialize() {
   connection_->set_visitor(this);
   connection_->SetFromConfig(config_);
 
   DCHECK_EQ(kCryptoStreamId, GetCryptoStream()->id());
   static_stream_map_[kCryptoStreamId] = GetCryptoStream();
 }
 
@@ skipping 332 matching lines @@
 
   const QuicVersion version = connection()->version();
   uint32_t max_streams = 0;
   if (version > QUIC_VERSION_34 &&
       config_.HasReceivedMaxIncomingDynamicStreams()) {
     max_streams = config_.ReceivedMaxIncomingDynamicStreams();
   } else {
     max_streams = config_.MaxStreamsPerConnection();
   }
   set_max_open_outgoing_streams(max_streams);
-  if (!FLAGS_quic_enable_autotune_by_default &&
-      perspective() == Perspective::IS_SERVER) {
-    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();
-      }
-    }
-  }
 
   if (version <= QUIC_VERSION_34) {
     // A small number of additional incoming streams beyond the limit should be
     // allowed. 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.
     uint32_t max_incoming_streams =
         max(max_streams + kMaxStreamsMinimumIncrement,
             static_cast<uint32_t>(max_streams * kMaxStreamsMultiplier));
@@ skipping 13 matching lines @@
     // requests) are now informed of the peer's initial flow control window.
     OnNewStreamFlowControlWindow(
         config_.ReceivedInitialStreamFlowControlWindowBytes());
   }
   if (config_.HasReceivedInitialSessionFlowControlWindowBytes()) {
     OnNewSessionFlowControlWindow(
         config_.ReceivedInitialSessionFlowControlWindowBytes());
   }
 }
 
-// TODO(ckrasic): remove the following two methods when deprecating
-// FLAGS_quic_enable_autotune_by_default.
-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::HandleFrameOnNonexistentOutgoingStream(
     QuicStreamId stream_id) {
   DCHECK(!IsClosedStream(stream_id));
   // Received a frame for a locally-created stream that is not currently
   // active. This is an error.
   connection()->CloseConnection(
       QUIC_INVALID_STREAM_ID, "Data for nonexistent stream",
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
@@ skipping 321 matching lines @@
 
 size_t QuicSession::MaxAvailableStreams() const {
   return max_open_incoming_streams_ * kMaxAvailableStreamsMultiplier;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net