Add a new connection option(BBRR) to enable BBR's rate based recovery. Protected by FLAGS_quic_rel…

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 101 matching lines @@
       is_at_full_bandwidth_(false),
       rounds_without_bandwidth_gain_(0),
       bandwidth_at_last_round_(QuicBandwidth::Zero()),
       exiting_quiescence_(false),
       exit_probe_rtt_at_(QuicTime::Zero()),
       probe_rtt_round_passed_(false),
       last_sample_is_app_limited_(false),
       recovery_state_(NOT_IN_RECOVERY),
       end_recovery_at_(0),
       recovery_window_(max_congestion_window_),
-      bytes_recently_acked_(0) {
+      bytes_recently_acked_(0),
+      rate_based_recovery_(false) {
   EnterStartupMode();
 }
 
 BbrSender::~BbrSender() {}
 
 bool BbrSender::InSlowStart() const {
   return mode_ == STARTUP;
 }
 
 bool BbrSender::OnPacketSent(QuicTime sent_time,
@@ skipping 64 matching lines @@
 
 QuicBandwidth BbrSender::BandwidthEstimate() const {
   return max_bandwidth_.GetBest();
 }
 
 QuicByteCount BbrSender::GetCongestionWindow() const {
   if (mode_ == PROBE_RTT) {
     return kMinimumCongestionWindow;
   }
 
-  if (InRecovery()) {
+  if (InRecovery() && !rate_based_recovery_) {
     return std::min(congestion_window_, recovery_window_);
   }
 
   return congestion_window_;
 }
 
 QuicByteCount BbrSender::GetSlowStartThreshold() const {
   return 0;
 }
 
 bool BbrSender::InRecovery() const {
   return recovery_state_ != NOT_IN_RECOVERY;
 }
 
 void BbrSender::SetFromConfig(const QuicConfig& config,
                               Perspective perspective) {
   if (config.HasClientRequestedIndependentOption(k1RTT, perspective)) {
     num_startup_rtts_ = 1;
   }
   if (config.HasClientRequestedIndependentOption(k2RTT, perspective)) {
     num_startup_rtts_ = 2;
   }
+  if (FLAGS_quic_reloadable_flag_quic_bbr_rate_recovery &&
+      config.HasClientRequestedIndependentOption(kBBRR, perspective)) {
+    rate_based_recovery_ = true;
+  }
 }
 
 void BbrSender::ResumeConnectionState(
     const CachedNetworkParameters& cached_network_params,
     bool max_bandwidth_resumption) {
   if (!FLAGS_quic_reloadable_flag_quic_bbr_bandwidth_resumption) {
     return;
   }
 
   QUIC_FLAG_COUNT(quic_reloadable_flag_quic_bbr_bandwidth_resumption);
@@ skipping 363 matching lines @@
   max_ack_height_.Update(aggregation_epoch_bytes_ - expected_bytes_acked,
                          round_trip_count_);
 }
 
 void BbrSender::CalculatePacingRate() {
   if (BandwidthEstimate().IsZero()) {
     return;
   }
 
   QuicBandwidth target_rate = pacing_gain_ * BandwidthEstimate();
+  if (rate_based_recovery_ && InRecovery()) {
+    QUIC_FLAG_COUNT(quic_reloadable_flag_quic_bbr_rate_recovery);
+    pacing_rate_ = pacing_gain_ * max_bandwidth_.GetThirdBest();
+  }
   if (is_at_full_bandwidth_) {
     pacing_rate_ = target_rate;
     return;
   }
 
   // Pace at the rate of initial_window / RTT as soon as RTT measurements are
   // available.
   if (pacing_rate_.IsZero() && !rtt_stats_->min_rtt().IsZero()) {
     pacing_rate_ = QuicBandwidth::FromBytesAndTimeDelta(
         initial_congestion_window_, rtt_stats_->min_rtt());
@@ skipping 50 matching lines @@
     congestion_window_ = congestion_window_ + bytes_acked;
   }
 
   // Enforce the limits on the congestion window.
   congestion_window_ = std::max(congestion_window_, kMinimumCongestionWindow);
   congestion_window_ = std::min(congestion_window_, max_congestion_window_);
 }
 
 void BbrSender::CalculateRecoveryWindow(QuicByteCount bytes_acked,
                                         QuicByteCount bytes_lost) {
+  if (rate_based_recovery_) {
+    return;
+  }
   if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation2) {
     if (recovery_state_ == NOT_IN_RECOVERY) {
       return;
     }
 
     // Set up the initial recovery window.
     if (recovery_window_ == 0) {
       QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation2, 2, 3);
       recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
       recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
@@ skipping 94 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