Base QUIC BBR's CWND on SRTT instead of min_rtt. Protected by FLAGS_quic_reloadable_flag_quic_base…

net/quic/core/congestion_control/bbr_sender.cc

 // Copyright 2016 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/congestion_control/bbr_sender.h"
 
 #include <algorithm>
 #include <sstream>
 
 #include "net/quic/core/congestion_control/rtt_stats.h"
@@ skipping 136 matching lines @@
 
 QuicBandwidth BbrSender::PacingRate(QuicByteCount bytes_in_flight) const {
   if (pacing_rate_.IsZero()) {
     return kHighGain * QuicBandwidth::FromBytesAndTimeDelta(
                            initial_congestion_window_, GetMinRtt());
   }
   if (FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate &&
       mode_ == PROBE_BW && bytes_in_flight > congestion_window_) {
     QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate,
                       1, 2);
-    return max_bandwidth_.GetThirdBest();
+    if (pacing_gain_ > 1) {
+      return max_bandwidth_.GetBest();
+    } else {
+      return max_bandwidth_.GetThirdBest();
+    }
   }
   return pacing_rate_;
 }
 
 QuicBandwidth BbrSender::BandwidthEstimate() const {
   return max_bandwidth_.GetBest();
 }
 
 QuicByteCount BbrSender::GetCongestionWindow() const {
   if (mode_ == PROBE_RTT) {
     return kMinimumCongestionWindow;
   }
 
   if (InRecovery()) {
     return std::min(congestion_window_, recovery_window_);
   }
 
   if (FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate &&
-      mode_ == PROBE_BW) {
+      mode_ == PROBE_BW && pacing_gain_ >= 1) {
     QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate,
                       2, 2);
     // Send for another SRTT at a more recently measured bandwidth.
     return congestion_window_ +
            max_bandwidth_.GetThirdBest() * rtt_stats_->smoothed_rtt();
   }
 
   return congestion_window_;
 }
 
@@ skipping 100 matching lines @@
 }
 
 QuicTime::Delta BbrSender::GetMinRtt() const {
   return !min_rtt_.IsZero()
              ? min_rtt_
              : QuicTime::Delta::FromMicroseconds(rtt_stats_->initial_rtt_us());
 }
 
 QuicByteCount BbrSender::GetTargetCongestionWindow(float gain) const {
   QuicByteCount bdp = GetMinRtt() * BandwidthEstimate();
+  if (FLAGS_quic_reloadable_flag_quic_bbr_base_cwnd_on_srtt &&
+      mode_ == PROBE_BW && gain >= 1 && !rtt_stats_->smoothed_rtt().IsZero()) {
+    bdp = rtt_stats_->smoothed_rtt() * BandwidthEstimate();
+  }
   QuicByteCount congestion_window = gain * bdp;
 
   // BDP estimate will be zero if no bandwidth samples are available yet.
   if (congestion_window == 0) {
     congestion_window = gain * initial_congestion_window_;
   }
 
   return std::max(congestion_window, kMinimumCongestionWindow);
 }
 
@@ skipping 420 matching lines @@
   os << "Minimum RTT timestamp: " << state.min_rtt_timestamp.ToDebuggingValue()
      << std::endl;
 
   os << "Last sample is app-limited: "
      << (state.last_sample_is_app_limited ? "yes" : "no");
 
   return os;
 }
 
 }  // namespace net