Reland "Added BBR network controller."

This is a reland of 8ac9bb4d52a687b34158dc52c8c25830b23b8333

Original change's description:
> Added BBR network controller.
> 
> BBR is a congestion control method that is initially developed for TCP.
> This CL adds an implementation of BBR ported from QUIC for use with
> WebRTC. An upcoming CL enables it via a field trial.
> 
> Bug: webrtc:8415
> Change-Id: Ie4261d2e43bafa15aa928a7cadcfec256107cdbc
> Reviewed-on: https://webrtc-review.googlesource.com/39788
> Commit-Queue: Sebastian Jansson <srte@webrtc.org>
> Reviewed-by: Philip Eliasson <philipel@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#22647}

Bug: webrtc:8415
Change-Id: I090e4116d1f470acbd64af31520654e1bd8dfcda
Reviewed-on: https://webrtc-review.googlesource.com/65200
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22766}

modules/congestion_controller/bbr/BUILD.gn

@@ -8,7 +8,37 @@
 
 import("../../../webrtc.gni")
 
+rtc_static_library("bbr") {
+  sources = [
+    "bbr_factory.cc",
+    "bbr_factory.h",
+  ]
+  deps = [
+    ":bbr_controller",
+    "../../../rtc_base:rtc_base_approved",
+    "../network_control",
+  ]
+}
+
+rtc_source_set("bbr_controller") {
+  visibility = [ ":*" ]
+  sources = [
+    "bbr_network_controller.cc",
+    "bbr_network_controller.h",
+  ]
+  deps = [
+    ":data_transfer_tracker",
+    ":rtt_stats",
+    ":windowed_filter",
+    "../../../api:optional",
+    "../../../rtc_base:checks",
+    "../../../rtc_base:rtc_base_approved",
+    "../../../rtc_base/system:fallthrough",
+    "../network_control",
+  ]
+}
 rtc_source_set("data_transfer_tracker") {
+  visibility = [ ":*" ]
   sources = [
     "data_transfer_tracker.cc",
     "data_transfer_tracker.h",
@@ -20,6 +50,7 @@ rtc_source_set("data_transfer_tracker") {
   ]
 }
 rtc_source_set("rtt_stats") {
+  visibility = [ ":*" ]
   sources = [
     "rtt_stats.cc",
     "rtt_stats.h",
@@ -30,6 +61,7 @@ rtc_source_set("rtt_stats") {
   ]
 }
 rtc_source_set("windowed_filter") {
+  visibility = [ ":*" ]
   sources = [
     "windowed_filter.h",
   ]
@@ -38,11 +70,14 @@ if (rtc_include_tests) {
   rtc_source_set("bbr_unittests") {
     testonly = true
     sources = [
+      "bbr_network_controller_unittest.cc",
       "data_transfer_tracker_unittest.cc",
       "rtt_stats_unittest.cc",
       "windowed_filter_unittest.cc",
     ]
     deps = [
+      ":bbr",
+      ":bbr_controller",
       ":data_transfer_tracker",
       ":rtt_stats",
       ":windowed_filter",
@@ -50,5 +85,9 @@ if (rtc_include_tests) {
       "../network_control",
       "../network_control:network_control_test",
     ]
+    if (!build_with_chromium && is_clang) {
+      # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
+      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
+    }
   }
 }

modules/congestion_controller/bbr/bbr_factory.cc

@@ -0,0 +1,31 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/congestion_controller/bbr/bbr_factory.h"
+#include <memory>
+
+#include "modules/congestion_controller/bbr/bbr_network_controller.h"
+#include "rtc_base/ptr_util.h"
+
+namespace webrtc {
+
+BbrNetworkControllerFactory::BbrNetworkControllerFactory() {}
+
+std::unique_ptr<NetworkControllerInterface> BbrNetworkControllerFactory::Create(
+    NetworkControllerObserver* observer,
+    NetworkControllerConfig config) {
+  return rtc::MakeUnique<bbr::BbrNetworkController>(observer, config);
+}
+
+TimeDelta BbrNetworkControllerFactory::GetProcessInterval() const {
+  return TimeDelta::PlusInfinity();
+}
+
+}  // namespace webrtc

modules/congestion_controller/bbr/bbr_factory.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_
+#define MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_
+
+#include <memory>
+
+#include "modules/congestion_controller/network_control/include/network_control.h"
+
+namespace webrtc {
+
+class BbrNetworkControllerFactory : public NetworkControllerFactoryInterface {
+ public:
+  BbrNetworkControllerFactory();
+  std::unique_ptr<NetworkControllerInterface> Create(
+      NetworkControllerObserver* observer,
+      NetworkControllerConfig config) override;
+  TimeDelta GetProcessInterval() const override;
+};
+}  // namespace webrtc
+
+#endif  // MODULES_CONGESTION_CONTROLLER_BBR_BBR_FACTORY_H_

modules/congestion_controller/bbr/bbr_network_controller.cc

@@ -0,0 +1,870 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/congestion_controller/bbr/bbr_network_controller.h"
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <vector>
+
+#include "modules/congestion_controller/network_control/include/network_units.h"
+#include "modules/congestion_controller/network_control/include/network_units_to_string.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/system/fallthrough.h"
+
+namespace webrtc {
+namespace bbr {
+namespace {
+
+// If greater than zero, mean RTT variation is multiplied by the specified
+// factor and added to the congestion window limit.
+const double kBbrRttVariationWeight = 0.0f;
+
+// Congestion window gain for QUIC BBR during PROBE_BW phase.
+const double kProbeBWCongestionWindowGain = 2.0f;
+
+// The maximum packet size of any QUIC packet, based on ethernet's max size,
+// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
+// additional 8 bytes.  This is a total overhead of 48 bytes.  Ethernet's
+// max packet size is 1500 bytes,  1500 - 48 = 1452.
+const DataSize kMaxPacketSize = DataSize::bytes(1452);
+
+// Default maximum packet size used in the Linux TCP implementation.
+// Used in QUIC for congestion window computations in bytes.
+const DataSize kDefaultTCPMSS = DataSize::bytes(1460);
+// Constants based on TCP defaults.
+const DataSize kMaxSegmentSize = kDefaultTCPMSS;
+// The minimum CWND to ensure delayed acks don't reduce bandwidth measurements.
+// Does not inflate the pacing rate.
+const DataSize kMinimumCongestionWindow = DataSize::bytes(1000);
+
+// The gain used for the slow start, equal to 2/ln(2).
+const double kHighGain = 2.885f;
+// The gain used in STARTUP after loss has been detected.
+// 1.5 is enough to allow for 25% exogenous loss and still observe a 25% growth
+// in measured bandwidth.
+const double kStartupAfterLossGain = 1.5;
+// The gain used to drain the queue after the slow start.
+const double kDrainGain = 1.f / kHighGain;
+
+// The length of the gain cycle.
+const size_t kGainCycleLength = 8;
+// The size of the bandwidth filter window, in round-trips.
+const BbrRoundTripCount kBandwidthWindowSize = kGainCycleLength + 2;
+
+// The time after which the current min_rtt value expires.
+const TimeDelta kMinRttExpiry = TimeDelta::seconds(10);
+// The minimum time the connection can spend in PROBE_RTT mode.
+const TimeDelta kProbeRttTime = TimeDelta::ms(200);
+// If the bandwidth does not increase by the factor of |kStartupGrowthTarget|
+// within |kRoundTripsWithoutGrowthBeforeExitingStartup| rounds, the connection
+// will exit the STARTUP mode.
+const double kStartupGrowthTarget = 1.25;
+// Coefficient of target congestion window to use when basing PROBE_RTT on BDP.
+const double kModerateProbeRttMultiplier = 0.75;
+// Coefficient to determine if a new RTT is sufficiently similar to min_rtt that
+// we don't need to enter PROBE_RTT.
+const double kSimilarMinRttThreshold = 1.125;
+
+const TimeDelta kInitialRtt = TimeDelta::ms(200);
+const DataRate kInitialBandwidth = DataRate::kbps(300);
+
+const TimeDelta kMaxRtt = TimeDelta::ms(1000);
+const DataRate kMaxBandwidth = DataRate::kbps(5000);
+
+const DataSize kInitialCongestionWindow = kInitialRtt * kInitialBandwidth;
+const DataSize kDefaultMaxCongestionWindow = kMaxRtt * kMaxBandwidth;
+
+static std::string ModeToString(BbrNetworkController::Mode mode) {
+  switch (mode) {
+    case BbrNetworkController::STARTUP:
+      return "STARTUP";
+    case BbrNetworkController::DRAIN:
+      return "DRAIN";
+    case BbrNetworkController::PROBE_BW:
+      return "PROBE_BW";
+    case BbrNetworkController::PROBE_RTT:
+      return "PROBE_RTT";
+  }
+  return "???";
+}
+}  // namespace
+
+BbrNetworkController::BbrControllerConfig
+BbrNetworkController::BbrControllerConfig::DefaultConfig() {
+  BbrControllerConfig config;
+  config.probe_bw_pacing_gain_offset = 0.25;
+  config.encoder_rate_gain = 1;
+  config.encoder_rate_gain_in_probe_rtt = 1;
+  config.exit_startup_rtt_threshold_ms = 0;
+  config.probe_rtt_congestion_window_gain = 0.75;
+  config.exit_startup_on_loss = true;
+  config.num_startup_rtts = 3;
+  config.rate_based_recovery = false;
+  config.max_aggregation_bytes_multiplier = 0;
+  config.slower_startup = false;
+  config.rate_based_startup = false;
+  config.fully_drain_queue = false;
+  config.initial_conservation_in_startup = CONSERVATION;
+  config.max_ack_height_window_multiplier = 1;
+  config.probe_rtt_based_on_bdp = false;
+  config.probe_rtt_skipped_if_similar_rtt = false;
+  config.probe_rtt_disabled_if_app_limited = false;
+
+  return config;
+}
+
+BbrNetworkController::DebugState::DebugState(const BbrNetworkController& sender)
+    : mode(sender.mode_),
+      max_bandwidth(sender.max_bandwidth_.GetBest()),
+      round_trip_count(sender.round_trip_count_),
+      gain_cycle_index(sender.cycle_current_offset_),
+      congestion_window(sender.congestion_window_),
+      is_at_full_bandwidth(sender.is_at_full_bandwidth_),
+      bandwidth_at_last_round(sender.bandwidth_at_last_round_),
+      rounds_without_bandwidth_gain(sender.rounds_without_bandwidth_gain_),
+      min_rtt(sender.min_rtt_),
+      min_rtt_timestamp(sender.min_rtt_timestamp_),
+      recovery_state(sender.recovery_state_),
+      recovery_window(sender.recovery_window_),
+      last_sample_is_app_limited(sender.last_sample_is_app_limited_),
+      end_of_app_limited_phase(sender.end_of_app_limited_phase_) {}
+
+BbrNetworkController::DebugState::DebugState(const DebugState& state) = default;
+
+BbrNetworkController::BbrNetworkController(NetworkControllerObserver* observer,
+                                           NetworkControllerConfig config)
+    : observer_(observer),
+      random_(10),
+      max_bandwidth_(kBandwidthWindowSize, DataRate::Zero(), 0),
+      default_bandwidth_(kInitialBandwidth),
+      max_ack_height_(kBandwidthWindowSize, DataSize::Zero(), 0),
+      congestion_window_(kInitialCongestionWindow),
+      initial_congestion_window_(kInitialCongestionWindow),
+      max_congestion_window_(kDefaultMaxCongestionWindow),
+      congestion_window_gain_constant_(kProbeBWCongestionWindowGain),
+      rtt_variance_weight_(kBbrRttVariationWeight),
+      recovery_window_(max_congestion_window_) {
+  config_ = BbrControllerConfig::DefaultConfig();
+  if (config.starting_bandwidth.IsFinite())
+    default_bandwidth_ = config.starting_bandwidth;
+  constraints_ = config.constraints;
+  Reset();
+  EnterStartupMode();
+  SignalUpdatedRates(config.constraints.at_time);
+}
+
+BbrNetworkController::~BbrNetworkController() {}
+
+void BbrNetworkController::Reset() {
+  round_trip_count_ = 0;
+  rounds_without_bandwidth_gain_ = 0;
+  is_at_full_bandwidth_ = false;
+  last_update_state_.mode = Mode::STARTUP;
+  last_update_state_.bandwidth = DataRate();
+  last_update_state_.rtt = TimeDelta();
+  last_update_state_.pacing_rate = DataRate();
+  last_update_state_.target_rate = DataRate();
+  last_update_state_.probing_for_bandwidth = false;
+  EnterStartupMode();
+}
+
+void BbrNetworkController::SignalUpdatedRates(Timestamp at_time) {
+  DataRate bandwidth = BandwidthEstimate();
+  if (bandwidth.IsZero())
+    bandwidth = default_bandwidth_;
+  TimeDelta rtt = GetMinRtt();
+  DataRate pacing_rate = PacingRate();
+  DataRate target_rate = bandwidth;
+  if (mode_ == PROBE_RTT)
+    target_rate = bandwidth * config_.encoder_rate_gain_in_probe_rtt;
+  else
+    target_rate = bandwidth * config_.encoder_rate_gain;
+  target_rate = std::min(target_rate, pacing_rate);
+
+  if (constraints_) {
+    target_rate = std::min(target_rate, constraints_->max_data_rate);
+    target_rate = std::max(target_rate, constraints_->min_data_rate);
+  }
+  bool probing_for_bandwidth = IsProbingForMoreBandwidth();
+  if (last_update_state_.mode == mode_ &&
+      last_update_state_.bandwidth == bandwidth &&
+      last_update_state_.rtt == rtt &&
+      last_update_state_.pacing_rate == pacing_rate &&
+      last_update_state_.target_rate == target_rate &&
+      last_update_state_.probing_for_bandwidth == probing_for_bandwidth)
+    return;
+  last_update_state_.mode = mode_;
+  last_update_state_.bandwidth = bandwidth;
+  last_update_state_.rtt = rtt;
+  last_update_state_.pacing_rate = pacing_rate;
+  last_update_state_.target_rate = target_rate;
+  last_update_state_.probing_for_bandwidth = probing_for_bandwidth;
+
+  RTC_LOG(LS_INFO) << "RateUpdate, mode: " << ModeToString(mode_)
+                   << ", bw: " << ToString(bandwidth)
+                   << ", min_rtt: " << ToString(rtt)
+                   << ", last_rtt: " << ToString(last_rtt_)
+                   << ", pacing_rate: " << ToString(pacing_rate)
+                   << ", target_rate: " << ToString(target_rate)
+                   << ", Probing:" << probing_for_bandwidth
+                   << ", pacing_gain: " << pacing_gain_;
+
+  TargetTransferRate target_rate_msg;
+  target_rate_msg.network_estimate.at_time = at_time;
+  target_rate_msg.network_estimate.bandwidth = bandwidth;
+  target_rate_msg.network_estimate.round_trip_time = rtt;
+
+  // TODO(srte): Fill in fields below with proper values.
+  target_rate_msg.network_estimate.loss_rate_ratio = 0;
+  target_rate_msg.network_estimate.bwe_period = TimeDelta::Zero();
+
+  target_rate_msg.target_rate = target_rate;
+  target_rate_msg.at_time = at_time;
+  observer_->OnTargetTransferRate(target_rate_msg);
+
+  PacerConfig pacer_config;
+  // A small time window ensures an even pacing rate.
+  pacer_config.time_window = rtt * 0.25;
+  pacer_config.data_window = pacer_config.time_window * pacing_rate;
+
+  if (IsProbingForMoreBandwidth())
+    pacer_config.pad_window = pacer_config.data_window;
+  else
+    pacer_config.pad_window = DataSize::Zero();
+
+  pacer_config.at_time = at_time;
+  observer_->OnPacerConfig(pacer_config);
+
+  CongestionWindow congestion_window;
+  congestion_window.data_window = GetCongestionWindow();
+  observer_->OnCongestionWindow(congestion_window);
+}
+
+void BbrNetworkController::OnNetworkAvailability(NetworkAvailability msg) {
+  Reset();
+  rtt_stats_.OnConnectionMigration();
+  SignalUpdatedRates(msg.at_time);
+}
+
+void BbrNetworkController::OnNetworkRouteChange(NetworkRouteChange msg) {
+  constraints_ = msg.constraints;
+  Reset();
+  if (msg.starting_rate.IsFinite())
+    default_bandwidth_ = msg.starting_rate;
+  rtt_stats_.OnConnectionMigration();
+  SignalUpdatedRates(msg.at_time);
+}
+
+void BbrNetworkController::OnProcessInterval(ProcessInterval) {}
+
+void BbrNetworkController::OnStreamsConfig(StreamsConfig msg) {}
+
+void BbrNetworkController::OnTargetRateConstraints(TargetRateConstraints msg) {
+  constraints_ = msg;
+  SignalUpdatedRates(msg.at_time);
+}
+
+bool BbrNetworkController::InSlowStart() const {
+  return mode_ == STARTUP;
+}
+
+void BbrNetworkController::OnSentPacket(SentPacket msg) {
+  last_send_time_ = msg.send_time;
+  if (!aggregation_epoch_start_time_.IsInitialized()) {
+    aggregation_epoch_start_time_ = msg.send_time;
+  }
+}
+
+bool BbrNetworkController::CanSend(DataSize bytes_in_flight) {
+  return bytes_in_flight < GetCongestionWindow();
+}
+
+DataRate BbrNetworkController::PacingRate() const {
+  if (pacing_rate_.IsZero()) {
+    return kHighGain * initial_congestion_window_ / GetMinRtt();
+  }
+  return pacing_rate_;
+}
+
+DataRate BbrNetworkController::BandwidthEstimate() const {
+  return max_bandwidth_.GetBest();
+}
+
+DataSize BbrNetworkController::GetCongestionWindow() const {
+  if (mode_ == PROBE_RTT) {
+    return ProbeRttCongestionWindow();
+  }
+
+  if (InRecovery() && !config_.rate_based_recovery &&
+      !(config_.rate_based_startup && mode_ == STARTUP)) {
+    return std::min(congestion_window_, recovery_window_);
+  }
+
+  return congestion_window_;
+}
+
+double BbrNetworkController::GetPacingGain(int round_offset) const {
+  if (round_offset == 0)
+    return 1 + config_.probe_bw_pacing_gain_offset;
+  else if (round_offset == 1)
+    return 1 - config_.probe_bw_pacing_gain_offset;
+  else
+    return 1;
+}
+
+bool BbrNetworkController::InRecovery() const {
+  return recovery_state_ != NOT_IN_RECOVERY;
+}
+
+bool BbrNetworkController::IsProbingForMoreBandwidth() const {
+  return (mode_ == PROBE_BW && pacing_gain_ > 1) || mode_ == STARTUP;
+}
+
+void BbrNetworkController::OnTransportPacketsFeedback(
+    TransportPacketsFeedback msg) {
+  Timestamp feedback_recv_time = msg.feedback_time;
+  rtc::Optional<SentPacket> last_sent_packet =
+      msg.PacketsWithFeedback().back().sent_packet;
+  if (!last_sent_packet.has_value()) {
+    RTC_LOG(LS_WARNING) << "Last ack packet not in history, no RTT update";
+  } else {
+    Timestamp send_time = last_sent_packet->send_time;
+    TimeDelta send_delta = feedback_recv_time - send_time;
+    rtt_stats_.UpdateRtt(send_delta, TimeDelta::Zero(), feedback_recv_time);
+  }
+
+  DataSize bytes_in_flight = msg.data_in_flight;
+  DataSize total_acked_size = DataSize::Zero();
+
+  bool is_round_start = false;
+  bool min_rtt_expired = false;
+
+  std::vector<PacketResult> acked_packets = msg.ReceivedWithSendInfo();
+  std::vector<PacketResult> lost_packets = msg.LostWithSendInfo();
+  // Input the new data into the BBR model of the connection.
+  if (!acked_packets.empty()) {
+    for (const PacketResult& packet : acked_packets) {
+      const SentPacket& sent_packet = *packet.sent_packet;
+      send_ack_tracker_.AddSample(sent_packet.size, sent_packet.send_time,
+                                  msg.feedback_time);
+      total_acked_size += sent_packet.size;
+    }
+    Timestamp last_acked_send_time =
+        acked_packets.rbegin()->sent_packet->send_time;
+    is_round_start = UpdateRoundTripCounter(last_acked_send_time);
+    UpdateBandwidth(msg.feedback_time, acked_packets);
+    // Min rtt will be the rtt for the last packet, since all packets are acked
+    // at the same time.
+    Timestamp last_send_time = acked_packets.back().sent_packet->send_time;
+    min_rtt_expired = UpdateMinRtt(msg.feedback_time, last_send_time);
+    UpdateRecoveryState(last_acked_send_time, !lost_packets.empty(),
+                        is_round_start);
+
+    UpdateAckAggregationBytes(msg.feedback_time, total_acked_size);
+    if (max_aggregation_bytes_multiplier_ > 0) {
+      if (msg.data_in_flight <=
+          1.25 * GetTargetCongestionWindow(pacing_gain_)) {
+        bytes_acked_since_queue_drained_ = DataSize::Zero();
+      } else {
+        bytes_acked_since_queue_drained_ += total_acked_size;
+      }
+    }
+  }
+  total_bytes_acked_ += total_acked_size;
+
+  // Handle logic specific to PROBE_BW mode.
+  if (mode_ == PROBE_BW) {
+    UpdateGainCyclePhase(msg.feedback_time, msg.prior_in_flight,
+                         !lost_packets.empty());
+  }
+
+  // Handle logic specific to STARTUP and DRAIN modes.
+  if (is_round_start && !is_at_full_bandwidth_) {
+    CheckIfFullBandwidthReached();
+  }
+  MaybeExitStartupOrDrain(msg);
+
+  // Handle logic specific to PROBE_RTT.
+  MaybeEnterOrExitProbeRtt(msg, is_round_start, min_rtt_expired);
+
+  // Calculate number of packets acked and lost.
+  DataSize bytes_lost = DataSize();
+  for (const PacketResult& packet : lost_packets) {
+    bytes_lost += packet.sent_packet->size;
+  }
+
+  // After the model is updated, recalculate the pacing rate and congestion
+  // window.
+  CalculatePacingRate();
+  CalculateCongestionWindow(total_acked_size);
+  CalculateRecoveryWindow(total_acked_size, bytes_lost, bytes_in_flight);
+  SignalUpdatedRates(msg.feedback_time);
+}
+
+void BbrNetworkController::OnRemoteBitrateReport(RemoteBitrateReport msg) {}
+void BbrNetworkController::OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) {}
+void BbrNetworkController::OnTransportLossReport(TransportLossReport msg) {}
+
+TimeDelta BbrNetworkController::GetMinRtt() const {
+  return !min_rtt_.IsZero() ? min_rtt_
+                            : TimeDelta::us(rtt_stats_.initial_rtt_us());
+}
+
+DataSize BbrNetworkController::GetTargetCongestionWindow(double gain) const {
+  DataSize bdp = GetMinRtt() * BandwidthEstimate();
+  DataSize congestion_window = gain * bdp;
+
+  // BDP estimate will be zero if no bandwidth samples are available yet.
+  if (congestion_window.IsZero()) {
+    congestion_window = gain * initial_congestion_window_;
+  }
+
+  return std::max(congestion_window, kMinimumCongestionWindow);
+}
+
+DataSize BbrNetworkController::ProbeRttCongestionWindow() const {
+  if (config_.probe_rtt_based_on_bdp) {
+    return GetTargetCongestionWindow(kModerateProbeRttMultiplier);
+  }
+  return kMinimumCongestionWindow;
+}
+
+void BbrNetworkController::EnterStartupMode() {
+  mode_ = STARTUP;
+  pacing_gain_ = kHighGain;
+  congestion_window_gain_ = kHighGain;
+}
+
+void BbrNetworkController::EnterProbeBandwidthMode(Timestamp now) {
+  mode_ = PROBE_BW;
+  congestion_window_gain_ = congestion_window_gain_constant_;
+
+  // Pick a random offset for the gain cycle out of {0, 2..7} range. 1 is
+  // excluded because in that case increased gain and decreased gain would not
+  // follow each other.
+  cycle_current_offset_ = random_.Rand(kGainCycleLength - 1);
+  if (cycle_current_offset_ >= 1) {
+    cycle_current_offset_ += 1;
+  }
+
+  last_cycle_start_ = now;
+  pacing_gain_ = GetPacingGain(cycle_current_offset_);
+}
+
+bool BbrNetworkController::UpdateRoundTripCounter(
+    Timestamp last_acked_send_time) {
+  if (last_acked_send_time > current_round_trip_end_) {
+    round_trip_count_++;
+    current_round_trip_end_ = last_send_time_;
+    return true;
+  }
+
+  return false;
+}
+
+bool BbrNetworkController::UpdateMinRtt(Timestamp ack_time,
+                                        Timestamp last_packet_send_time) {
+  // Note: This sample does not account for delayed acknowledgement time.  This
+  // means that the RTT measurements here can be artificially high, especially
+  // on low bandwidth connections.
+  TimeDelta sample_rtt = ack_time - last_packet_send_time;
+  last_rtt_ = sample_rtt;
+  min_rtt_since_last_probe_rtt_ =
+      std::min(min_rtt_since_last_probe_rtt_, sample_rtt);
+
+  // Do not expire min_rtt if none was ever available.
+  bool min_rtt_expired =
+      !min_rtt_.IsZero() && (ack_time > (min_rtt_timestamp_ + kMinRttExpiry));
+
+  if (min_rtt_expired || sample_rtt < min_rtt_ || min_rtt_.IsZero()) {
+    RTC_LOG(LS_INFO) << "Min RTT updated, old value: " << ToString(min_rtt_)
+                     << ", new value: " << ToString(sample_rtt)
+                     << ", current time: " << ToString(ack_time);
+
+    if (ShouldExtendMinRttExpiry()) {
+      min_rtt_expired = false;
+    } else {
+      min_rtt_ = sample_rtt;
+    }
+    min_rtt_timestamp_ = ack_time;
+    // Reset since_last_probe_rtt fields.
+    min_rtt_since_last_probe_rtt_ = TimeDelta::PlusInfinity();
+    app_limited_since_last_probe_rtt_ = false;
+  }
+
+  return min_rtt_expired;
+}
+
+void BbrNetworkController::UpdateBandwidth(
+    Timestamp ack_time,
+    const std::vector<PacketResult>& acked_packets) {
+  // There are two possible maximum receive bandwidths based on the duration
+  // from send to ack of a packet, either including or excluding the time until
+  // the current ack was received. Therefore looking at the last and the first
+  // packet is enough. This holds if at most one feedback was received during
+  // the sending of the acked packets.
+  std::array<const PacketResult, 2> packets = {
+      {acked_packets.front(), acked_packets.back()}};
+  for (const PacketResult& packet : packets) {
+    const Timestamp& send_time = packet.sent_packet->send_time;
+    is_app_limited_ = send_time > end_of_app_limited_phase_;
+    auto result = send_ack_tracker_.GetRatesByAckTime(send_time, ack_time);
+    if (result.acked_data == DataSize::Zero())
+      continue;
+    send_ack_tracker_.ClearOldSamples(send_time);
+
+    DataRate ack_rate = result.acked_data / result.ack_timespan;
+    DataRate send_rate = result.send_timespan.IsZero()
+                             ? DataRate::Infinity()
+                             : result.acked_data / result.send_timespan;
+    DataRate bandwidth = std::min(send_rate, ack_rate);
+    if (!bandwidth.IsFinite())
+      continue;
+    if (!is_app_limited_ || bandwidth > BandwidthEstimate()) {
+      max_bandwidth_.Update(bandwidth, round_trip_count_);
+    }
+  }
+}
+
+bool BbrNetworkController::ShouldExtendMinRttExpiry() const {
+  if (config_.probe_rtt_disabled_if_app_limited &&
+      app_limited_since_last_probe_rtt_) {
+    // Extend the current min_rtt if we've been app limited recently.
+    return true;
+  }
+  const bool min_rtt_increased_since_last_probe =
+      min_rtt_since_last_probe_rtt_ > min_rtt_ * kSimilarMinRttThreshold;
+  if (config_.probe_rtt_skipped_if_similar_rtt &&
+      app_limited_since_last_probe_rtt_ &&
+      !min_rtt_increased_since_last_probe) {
+    // Extend the current min_rtt if we've been app limited recently and an rtt
+    // has been measured in that time that's less than 12.5% more than the
+    // current min_rtt.
+    return true;
+  }
+  return false;
+}
+
+void BbrNetworkController::UpdateGainCyclePhase(Timestamp now,
+                                                DataSize prior_in_flight,
+                                                bool has_losses) {
+  // In most cases, the cycle is advanced after an RTT passes.
+  bool should_advance_gain_cycling = now - last_cycle_start_ > GetMinRtt();
+
+  // If the pacing gain is above 1.0, the connection is trying to probe the
+  // bandwidth by increasing the number of bytes in flight to at least
+  // pacing_gain * BDP.  Make sure that it actually reaches the target, as long
+  // as there are no losses suggesting that the buffers are not able to hold
+  // that much.
+  if (pacing_gain_ > 1.0 && !has_losses &&
+      prior_in_flight < GetTargetCongestionWindow(pacing_gain_)) {
+    should_advance_gain_cycling = false;
+  }
+
+  // If pacing gain is below 1.0, the connection is trying to drain the extra
+  // queue which could have been incurred by probing prior to it.  If the number
+  // of bytes in flight falls down to the estimated BDP value earlier, conclude
+  // that the queue has been successfully drained and exit this cycle early.
+  if (pacing_gain_ < 1.0 && prior_in_flight <= GetTargetCongestionWindow(1)) {
+    should_advance_gain_cycling = true;
+  }
+
+  if (should_advance_gain_cycling) {
+    cycle_current_offset_ = (cycle_current_offset_ + 1) % kGainCycleLength;
+    last_cycle_start_ = now;
+    // Stay in low gain mode until the target BDP is hit.
+    // Low gain mode will be exited immediately when the target BDP is achieved.
+    if (config_.fully_drain_queue && pacing_gain_ < 1 &&
+        GetPacingGain(cycle_current_offset_) == 1 &&
+        prior_in_flight > GetTargetCongestionWindow(1)) {
+      return;
+    }
+    pacing_gain_ = GetPacingGain(cycle_current_offset_);
+  }
+}
+
+void BbrNetworkController::CheckIfFullBandwidthReached() {
+  if (last_sample_is_app_limited_) {
+    return;
+  }
+
+  DataRate target = bandwidth_at_last_round_ * kStartupGrowthTarget;
+  if (BandwidthEstimate() >= target) {
+    bandwidth_at_last_round_ = BandwidthEstimate();
+    rounds_without_bandwidth_gain_ = 0;
+    return;
+  }
+
+  rounds_without_bandwidth_gain_++;
+  if ((rounds_without_bandwidth_gain_ >= config_.num_startup_rtts) ||
+      (exit_startup_on_loss_ && InRecovery())) {
+    is_at_full_bandwidth_ = true;
+  }
+}
+
+void BbrNetworkController::MaybeExitStartupOrDrain(
+    const TransportPacketsFeedback& msg) {
+  int64_t exit_threshold_ms = config_.exit_startup_rtt_threshold_ms;
+  bool rtt_over_threshold =
+      exit_threshold_ms > 0 && (last_rtt_ - min_rtt_).ms() > exit_threshold_ms;
+  if (mode_ == STARTUP && (is_at_full_bandwidth_ || rtt_over_threshold)) {
+    if (rtt_over_threshold)
+      RTC_LOG(LS_INFO) << "Exiting startup due to rtt increase from: "
+                       << ToString(min_rtt_) << " to:" << ToString(last_rtt_)
+                       << " > "
+                       << ToString(min_rtt_ + TimeDelta::ms(exit_threshold_ms));
+    mode_ = DRAIN;
+    pacing_gain_ = kDrainGain;
+    congestion_window_gain_ = kHighGain;
+  }
+  if (mode_ == DRAIN && msg.data_in_flight <= GetTargetCongestionWindow(1)) {
+    EnterProbeBandwidthMode(msg.feedback_time);
+  }
+}
+
+void BbrNetworkController::MaybeEnterOrExitProbeRtt(
+    const TransportPacketsFeedback& msg,
+    bool is_round_start,
+    bool min_rtt_expired) {
+  if (min_rtt_expired && mode_ != PROBE_RTT) {
+    mode_ = PROBE_RTT;
+    pacing_gain_ = 1;
+    // Do not decide on the time to exit PROBE_RTT until the |bytes_in_flight|
+    // is at the target small value.
+    exit_probe_rtt_at_ = Timestamp();
+    RTC_LOG(LS_INFO) << "Entering RTT Probe";
+  }
+
+  if (mode_ == PROBE_RTT) {
+    is_app_limited_ = true;
+    end_of_app_limited_phase_ = last_send_time_;
+
+    if (!exit_probe_rtt_at_.IsInitialized()) {
+      // If the window has reached the appropriate size, schedule exiting
+      // PROBE_RTT.  The CWND during PROBE_RTT is kMinimumCongestionWindow, but
+      // we allow an extra packet since QUIC checks CWND before sending a
+      // packet.
+      if (msg.data_in_flight < ProbeRttCongestionWindow() + kMaxPacketSize) {
+        exit_probe_rtt_at_ = msg.feedback_time + kProbeRttTime;
+        probe_rtt_round_passed_ = false;
+      }
+    } else {
+      if (is_round_start) {
+        probe_rtt_round_passed_ = true;
+      }
+      if (msg.feedback_time >= exit_probe_rtt_at_ && probe_rtt_round_passed_) {
+        min_rtt_timestamp_ = msg.feedback_time;
+        RTC_LOG(LS_INFO) << "Exiting RTT Probe";
+        if (!is_at_full_bandwidth_) {
+          EnterStartupMode();
+        } else {
+          EnterProbeBandwidthMode(msg.feedback_time);
+        }
+      }
+    }
+  }
+}
+
+void BbrNetworkController::UpdateRecoveryState(Timestamp last_acked_send_time,
+                                               bool has_losses,
+                                               bool is_round_start) {
+  // Exit recovery when there are no losses for a round.
+  if (has_losses) {
+    end_recovery_at_ = last_acked_send_time;
+  }
+
+  switch (recovery_state_) {
+    case NOT_IN_RECOVERY:
+      // Enter conservation on the first loss.
+      if (has_losses) {
+        recovery_state_ = CONSERVATION;
+        if (mode_ == STARTUP) {
+          recovery_state_ = config_.initial_conservation_in_startup;
+        }
+        // This will cause the |recovery_window_| to be set to the correct
+        // value in CalculateRecoveryWindow().
+        recovery_window_ = DataSize::Zero();
+        // Since the conservation phase is meant to be lasting for a whole
+        // round, extend the current round as if it were started right now.
+        current_round_trip_end_ = last_send_time_;
+      }
+      break;
+
+    case CONSERVATION:
+    case MEDIUM_GROWTH:
+      if (is_round_start) {
+        recovery_state_ = GROWTH;
+      }
+      RTC_FALLTHROUGH();
+    case GROWTH:
+      // Exit recovery if appropriate.
+      if (!has_losses && last_acked_send_time > end_recovery_at_) {
+        recovery_state_ = NOT_IN_RECOVERY;
+      }
+
+      break;
+  }
+}
+
+void BbrNetworkController::UpdateAckAggregationBytes(
+    Timestamp ack_time,
+    DataSize newly_acked_bytes) {
+  // Compute how many bytes are expected to be delivered, assuming max bandwidth
+  // is correct.
+  DataSize expected_bytes_acked =
+      max_bandwidth_.GetBest() * (ack_time - aggregation_epoch_start_time_);
+  // Reset the current aggregation epoch as soon as the ack arrival rate is less
+  // than or equal to the max bandwidth.
+  if (aggregation_epoch_bytes_ <= expected_bytes_acked) {
+    // Reset to start measuring a new aggregation epoch.
+    aggregation_epoch_bytes_ = newly_acked_bytes;
+    aggregation_epoch_start_time_ = ack_time;
+    return;
+  }
+
+  // Compute how many extra bytes were delivered vs max bandwidth.
+  // Include the bytes most recently acknowledged to account for stretch acks.
+  aggregation_epoch_bytes_ += newly_acked_bytes;
+  max_ack_height_.Update(aggregation_epoch_bytes_ - expected_bytes_acked,
+                         round_trip_count_);
+}
+
+void BbrNetworkController::CalculatePacingRate() {
+  if (BandwidthEstimate().IsZero()) {
+    return;
+  }
+
+  DataRate target_rate = pacing_gain_ * BandwidthEstimate();
+  if (config_.rate_based_recovery && InRecovery()) {
+    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_ = initial_congestion_window_ / rtt_stats_.min_rtt();
+    return;
+  }
+  // Slow the pacing rate in STARTUP once loss has ever been detected.
+  const bool has_ever_detected_loss = end_recovery_at_.IsInitialized();
+  if (config_.slower_startup && has_ever_detected_loss) {
+    pacing_rate_ = kStartupAfterLossGain * BandwidthEstimate();
+    return;
+  }
+
+  // Do not decrease the pacing rate during the startup.
+  pacing_rate_ = std::max(pacing_rate_, target_rate);
+}
+
+void BbrNetworkController::CalculateCongestionWindow(DataSize bytes_acked) {
+  if (mode_ == PROBE_RTT) {
+    return;
+  }
+
+  DataSize target_window = GetTargetCongestionWindow(congestion_window_gain_);
+
+  if (rtt_variance_weight_ > 0.f && !BandwidthEstimate().IsZero()) {
+    target_window += rtt_variance_weight_ * rtt_stats_.mean_deviation() *
+                     BandwidthEstimate();
+  } else if (max_aggregation_bytes_multiplier_ > 0 && is_at_full_bandwidth_) {
+    // Subtracting only half the bytes_acked_since_queue_drained ensures sending
+    // doesn't completely stop for a long period of time if the queue hasn't
+    // been drained recently.
+    if (max_aggregation_bytes_multiplier_ * max_ack_height_.GetBest() >
+        bytes_acked_since_queue_drained_ / 2) {
+      target_window +=
+          max_aggregation_bytes_multiplier_ * max_ack_height_.GetBest() -
+          bytes_acked_since_queue_drained_ / 2;
+    }
+  } else if (is_at_full_bandwidth_) {
+    target_window += max_ack_height_.GetBest();
+  }
+
+  // Instead of immediately setting the target CWND as the new one, BBR grows
+  // the CWND towards |target_window| by only increasing it |bytes_acked| at a
+  // time.
+  if (is_at_full_bandwidth_) {
+    congestion_window_ =
+        std::min(target_window, congestion_window_ + bytes_acked);
+  } else if (congestion_window_ < target_window ||
+             total_bytes_acked_ < initial_congestion_window_) {
+    // If the connection is not yet out of startup phase, do not decrease the
+    // window.
+    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 BbrNetworkController::CalculateRecoveryWindow(DataSize bytes_acked,
+                                                   DataSize bytes_lost,
+                                                   DataSize bytes_in_flight) {
+  if (config_.rate_based_recovery ||
+      (config_.rate_based_startup && mode_ == STARTUP)) {
+    return;
+  }
+
+  if (recovery_state_ == NOT_IN_RECOVERY) {
+    return;
+  }
+
+  // Set up the initial recovery window.
+  if (recovery_window_.IsZero()) {
+    recovery_window_ = bytes_in_flight + bytes_acked;
+    recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
+    return;
+  }
+
+  // Remove losses from the recovery window, while accounting for a potential
+  // integer underflow.
+  recovery_window_ = recovery_window_ >= bytes_lost
+                         ? recovery_window_ - bytes_lost
+                         : kMaxSegmentSize;
+
+  // In CONSERVATION mode, just subtracting losses is sufficient.  In GROWTH,
+  // release additional |bytes_acked| to achieve a slow-start-like behavior.
+  // In MEDIUM_GROWTH, release |bytes_acked| / 2 to split the difference.
+  if (recovery_state_ == GROWTH) {
+    recovery_window_ += bytes_acked;
+  } else if (recovery_state_ == MEDIUM_GROWTH) {
+    recovery_window_ += bytes_acked / 2;
+  }
+
+  // Sanity checks.  Ensure that we always allow to send at leastś
+  // |bytes_acked| in response.
+  recovery_window_ = std::max(recovery_window_, bytes_in_flight + bytes_acked);
+  recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
+}
+
+void BbrNetworkController::OnApplicationLimited(DataSize bytes_in_flight) {
+  if (bytes_in_flight >= GetCongestionWindow()) {
+    return;
+  }
+
+  app_limited_since_last_probe_rtt_ = true;
+
+  is_app_limited_ = true;
+  end_of_app_limited_phase_ = last_send_time_;
+
+  RTC_LOG(LS_INFO) << "Becoming application limited. Last sent time: "
+                   << ToString(last_send_time_)
+                   << ", CWND: " << ToString(GetCongestionWindow());
+}
+}  // namespace bbr
+}  // namespace webrtc

modules/congestion_controller/bbr/bbr_network_controller.h

@@ -0,0 +1,407 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// BBR (Bottleneck Bandwidth and RTT) congestion control algorithm.
+// Based on the Quic BBR implementation in Chromium.
+
+#ifndef MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_
+#define MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "modules/congestion_controller/bbr/data_transfer_tracker.h"
+#include "modules/congestion_controller/bbr/rtt_stats.h"
+#include "modules/congestion_controller/bbr/windowed_filter.h"
+#include "modules/congestion_controller/network_control/include/network_control.h"
+#include "modules/congestion_controller/network_control/include/network_types.h"
+#include "modules/congestion_controller/network_control/include/network_units.h"
+
+#include "api/optional.h"
+#include "rtc_base/random.h"
+
+namespace webrtc {
+namespace bbr {
+
+typedef int64_t BbrPacketCount;
+typedef int64_t BbrRoundTripCount;
+
+// BbrSender implements BBR congestion control algorithm.  BBR aims to estimate
+// the current available Bottleneck Bandwidth and RTT (hence the name), and
+// regulates the pacing rate and the size of the congestion window based on
+// those signals.
+//
+// BBR relies on pacing in order to function properly.  Do not use BBR when
+// pacing is disabled.
+class BbrNetworkController : public NetworkControllerInterface {
+ public:
+  enum Mode {
+    // Startup phase of the connection.
+    STARTUP,
+    // After achieving the highest possible bandwidth during the startup, lower
+    // the pacing rate in order to drain the queue.
+    DRAIN,
+    // Cruising mode.
+    PROBE_BW,
+    // Temporarily slow down sending in order to empty the buffer and measure
+    // the real minimum RTT.
+    PROBE_RTT,
+  };
+
+  // Indicates how the congestion control limits the amount of bytes in flight.
+  enum RecoveryState {
+    // Do not limit.
+    NOT_IN_RECOVERY,
+    // Allow an extra outstanding byte for each byte acknowledged.
+    CONSERVATION,
+    // Allow 1.5 extra outstanding bytes for each byte acknowledged.
+    MEDIUM_GROWTH,
+    // Allow two extra outstanding bytes for each byte acknowledged (slow
+    // start).
+    GROWTH
+  };
+
+  // Debug state can be exported in order to troubleshoot potential congestion
+  // control issues.
+  struct DebugState {
+    explicit DebugState(const BbrNetworkController& sender);
+    DebugState(const DebugState& state);
+
+    Mode mode;
+    DataRate max_bandwidth;
+    BbrRoundTripCount round_trip_count;
+    int gain_cycle_index;
+    DataSize congestion_window;
+
+    bool is_at_full_bandwidth;
+    DataRate bandwidth_at_last_round;
+    BbrRoundTripCount rounds_without_bandwidth_gain;
+
+    TimeDelta min_rtt;
+    Timestamp min_rtt_timestamp;
+
+    RecoveryState recovery_state;
+    DataSize recovery_window;
+
+    bool last_sample_is_app_limited;
+    Timestamp end_of_app_limited_phase;
+  };
+
+  BbrNetworkController(NetworkControllerObserver* observer,
+                       NetworkControllerConfig config);
+  ~BbrNetworkController() override;
+
+  // NetworkControllerInterface
+  void OnNetworkAvailability(NetworkAvailability msg) override;
+  void OnNetworkRouteChange(NetworkRouteChange msg) override;
+  void OnProcessInterval(ProcessInterval msg) override;
+  void OnSentPacket(SentPacket msg) override;
+  void OnStreamsConfig(StreamsConfig msg) override;
+  void OnTargetRateConstraints(TargetRateConstraints msg) override;
+  void OnTransportPacketsFeedback(TransportPacketsFeedback msg) override;
+
+  // Part of remote bitrate estimation api, not implemented for BBR
+  void OnRemoteBitrateReport(RemoteBitrateReport msg) override;
+  void OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) override;
+  void OnTransportLossReport(TransportLossReport msg) override;
+
+ private:
+  struct BbrControllerConfig {
+    // Default config based on default QUIC config
+    static BbrControllerConfig DefaultConfig();
+
+    double probe_bw_pacing_gain_offset;
+    double encoder_rate_gain;
+    double encoder_rate_gain_in_probe_rtt;
+    // RTT delta to determine if startup should be exited due to increased RTT.
+    int64_t exit_startup_rtt_threshold_ms;
+
+    double probe_rtt_congestion_window_gain;
+
+    // Configurable in QUIC BBR:
+    bool exit_startup_on_loss;
+    // The number of RTTs to stay in STARTUP mode.  Defaults to 3.
+    BbrRoundTripCount num_startup_rtts;
+    // When true, recovery is rate based rather than congestion window based.
+    bool rate_based_recovery;
+    double max_aggregation_bytes_multiplier;
+    // When true, pace at 1.5x and disable packet conservation in STARTUP.
+    bool slower_startup;
+    // When true, disables packet conservation in STARTUP.
+    bool rate_based_startup;
+    // If true, will not exit low gain mode until bytes_in_flight drops below
+    // BDP or it's time for high gain mode.
+    bool fully_drain_queue;
+    // Used as the initial packet conservation mode when first entering
+    // recovery.
+    RecoveryState initial_conservation_in_startup;
+
+    double max_ack_height_window_multiplier;
+    // If true, use a CWND of 0.75*BDP during probe_rtt instead of 4 packets.
+    bool probe_rtt_based_on_bdp;
+    // If true, skip probe_rtt and update the timestamp of the existing min_rtt
+    // to now if min_rtt over the last cycle is within 12.5% of the current
+    // min_rtt. Even if the min_rtt is 12.5% too low, the 25% gain cycling and
+    // 2x CWND gain should overcome an overly small min_rtt.
+    bool probe_rtt_skipped_if_similar_rtt;
+    // If true, disable PROBE_RTT entirely as long as the connection was
+    // recently app limited.
+    bool probe_rtt_disabled_if_app_limited;
+  };
+  // Containing values that when changed should trigger an update.
+  struct UpdateState {
+    Mode mode = Mode::STARTUP;
+    DataRate bandwidth;
+    TimeDelta rtt;
+    DataRate pacing_rate;
+    DataRate target_rate;
+    bool probing_for_bandwidth = false;
+  };
+
+  void Reset();
+  void SignalUpdatedRates(Timestamp at_time);
+
+  bool InSlowStart() const;
+  bool InRecovery() const;
+  bool IsProbingForMoreBandwidth() const;
+
+  bool CanSend(DataSize bytes_in_flight);
+  DataRate PacingRate() const;
+  DataRate BandwidthEstimate() const;
+  DataSize GetCongestionWindow() const;
+
+  double GetPacingGain(int round_offset) const;
+
+  void OnApplicationLimited(DataSize bytes_in_flight);
+  // End implementation of SendAlgorithmInterface.
+
+  typedef WindowedFilter<DataRate,
+                         MaxFilter<DataRate>,
+                         BbrRoundTripCount,
+                         BbrRoundTripCount>
+      MaxBandwidthFilter;
+
+  typedef WindowedFilter<TimeDelta,
+                         MaxFilter<TimeDelta>,
+                         BbrRoundTripCount,
+                         BbrRoundTripCount>
+      MaxAckDelayFilter;
+
+  typedef WindowedFilter<DataSize,
+                         MaxFilter<DataSize>,
+                         BbrRoundTripCount,
+                         BbrRoundTripCount>
+      MaxAckHeightFilter;
+
+  // Returns the current estimate of the RTT of the connection.  Outside of the
+  // edge cases, this is minimum RTT.
+  TimeDelta GetMinRtt() const;
+
+  // Computes the target congestion window using the specified gain.
+  DataSize GetTargetCongestionWindow(double gain) const;
+  // The target congestion window during PROBE_RTT.
+  DataSize ProbeRttCongestionWindow() const;
+  // Returns true if the current min_rtt should be kept and we should not enter
+  // PROBE_RTT immediately.
+  bool ShouldExtendMinRttExpiry() const;
+
+  // Enters the STARTUP mode.
+  void EnterStartupMode();
+  // Enters the PROBE_BW mode.
+  void EnterProbeBandwidthMode(Timestamp now);
+
+  // Updates the round-trip counter if a round-trip has passed.  Returns true if
+  // the counter has been advanced.
+  bool UpdateRoundTripCounter(Timestamp last_acked_timestamp);
+  // Updates the current bandwidth and min_rtt estimate based on the samples for
+  // the received acknowledgements.  Returns true if min_rtt has expired.
+  void UpdateBandwidth(Timestamp now,
+                       const std::vector<PacketResult>& acked_packets);
+  bool UpdateMinRtt(Timestamp ack_time, Timestamp last_packet_send_time);
+  // Updates the current gain used in PROBE_BW mode.
+  void UpdateGainCyclePhase(Timestamp now,
+                            DataSize prior_in_flight,
+                            bool has_losses);
+  // Tracks for how many round-trips the bandwidth has not increased
+  // significantly.
+  void CheckIfFullBandwidthReached();
+  // Transitions from STARTUP to DRAIN and from DRAIN to PROBE_BW if
+  // appropriate.
+  void MaybeExitStartupOrDrain(const TransportPacketsFeedback&);
+  // Decides whether to enter or exit PROBE_RTT.
+  void MaybeEnterOrExitProbeRtt(const TransportPacketsFeedback& msg,
+                                bool is_round_start,
+                                bool min_rtt_expired);
+  // Determines whether BBR needs to enter, exit or advance state of the
+  // recovery.
+  void UpdateRecoveryState(Timestamp last_acked_send_time,
+                           bool has_losses,
+                           bool is_round_start);
+
+  // Updates the ack aggregation max filter in bytes.
+  void UpdateAckAggregationBytes(Timestamp ack_time,
+                                 DataSize newly_acked_bytes);
+
+  // Determines the appropriate pacing rate for the connection.
+  void CalculatePacingRate();
+  // Determines the appropriate congestion window for the connection.
+  void CalculateCongestionWindow(DataSize bytes_acked);
+  // Determines the approriate wQuicPacketNumberindow that constrains the
+  // in-flight during recovery.
+  void CalculateRecoveryWindow(DataSize bytes_acked,
+                               DataSize bytes_lost,
+                               DataSize bytes_in_flight);
+  NetworkControllerObserver* observer_;
+
+  RttStats rtt_stats_;
+  webrtc::Random random_;
+
+  DataTransferTracker send_ack_tracker_;
+
+  rtc::Optional<TargetRateConstraints> constraints_;
+
+  Mode mode_ = STARTUP;
+
+  BbrControllerConfig config_;
+
+  // The total number of congestion controlled bytes which were acknowledged.
+  DataSize total_bytes_acked_;
+
+  // The total number of congestion controlled bytes sent during the connection.
+  DataSize total_bytes_sent_;
+
+  // The time at which the last acknowledged packet was sent. Set to
+  // Timestamp::ms(0) if no valid timestamp is available.
+  Timestamp last_acked_packet_sent_time_ = Timestamp::ms(0);
+
+  // The time at which the most recent packet was acknowledged.
+  Timestamp last_acked_packet_ack_time_ = Timestamp::ms(0);
+
+  bool is_app_limited_ = false;
+
+  // The packet that will be acknowledged after this one will cause the sampler
+  // to exit the app-limited phase.
+  Timestamp end_of_app_limited_phase_ = Timestamp::ms(0);
+
+  // The number of the round trips that have occurred during the connection.
+  BbrRoundTripCount round_trip_count_ = 0;
+
+  // The send time of the most recently sent packet.
+  Timestamp last_send_time_ = Timestamp::ms(0);
+
+  // Acknowledgement of any packet after |current_round_trip_end_| will cause
+  // the round trip counter to advance.
+  Timestamp current_round_trip_end_ = Timestamp::ms(0);
+
+  // The filter that tracks the maximum bandwidth over the multiple recent
+  // round-trips.
+  MaxBandwidthFilter max_bandwidth_;
+
+  DataRate default_bandwidth_;
+
+  // Tracks the maximum number of bytes acked faster than the sending rate.
+  MaxAckHeightFilter max_ack_height_;
+
+  // The time this aggregation started and the number of bytes acked during it.
+  Timestamp aggregation_epoch_start_time_;
+  DataSize aggregation_epoch_bytes_;
+
+  // The number of bytes acknowledged since the last time bytes in flight
+  // dropped below the target window.
+  DataSize bytes_acked_since_queue_drained_;
+
+  // The muliplier for calculating the max amount of extra CWND to add to
+  // compensate for ack aggregation.
+  double max_aggregation_bytes_multiplier_ = 0;
+
+  // Minimum RTT estimate.  Automatically expires within 10 seconds (and
+  // triggers PROBE_RTT mode) if no new value is sampled during that period.
+  TimeDelta min_rtt_ = TimeDelta::Zero();
+  TimeDelta last_rtt_ = TimeDelta::Zero();
+  // The time at which the current value of |min_rtt_| was assigned.
+  Timestamp min_rtt_timestamp_ = Timestamp::ms(0);
+
+  // The maximum allowed number of bytes in flight.
+  DataSize congestion_window_;
+
+  // The initial value of the |congestion_window_|.
+  DataSize initial_congestion_window_;
+
+  // The largest value the |congestion_window_| can achieve.
+  DataSize max_congestion_window_;
+
+  // The current pacing rate of the connection.
+  DataRate pacing_rate_ = DataRate::Zero();
+
+  // The gain currently applied to the pacing rate.
+  double pacing_gain_ = 1;
+  // The gain currently applied to the congestion window.
+  double congestion_window_gain_ = 1;
+
+  // The gain used for the congestion window during PROBE_BW.  Latched from
+  // quic_bbr_cwnd_gain flag.
+  const double congestion_window_gain_constant_;
+  // The coefficient by which mean RTT variance is added to the congestion
+  // window.  Latched from quic_bbr_rtt_variation_weight flag.
+  const double rtt_variance_weight_;
+  // If true, exit startup if 1RTT has passed with no bandwidth increase and
+  // the connection is in recovery.
+  bool exit_startup_on_loss_ = false;
+
+  // Number of round-trips in PROBE_BW mode, used for determining the current
+  // pacing gain cycle.
+  int cycle_current_offset_ = 0;
+  // The time at which the last pacing gain cycle was started.
+  Timestamp last_cycle_start_;
+
+  // Indicates whether the connection has reached the full bandwidth mode.
+  bool is_at_full_bandwidth_ = false;
+  // Number of rounds during which there was no significant bandwidth increase.
+  BbrRoundTripCount rounds_without_bandwidth_gain_ = 0;
+  // The bandwidth compared to which the increase is measured.
+  DataRate bandwidth_at_last_round_ = DataRate::Zero();
+
+  // Time at which PROBE_RTT has to be exited.  Setting it to zero indicates
+  // that the time is yet unknown as the number of packets in flight has not
+  // reached the required value.
+  Timestamp exit_probe_rtt_at_;
+  // Indicates whether a round-trip has passed since PROBE_RTT became active.
+  bool probe_rtt_round_passed_ = false;
+
+  // Indicates whether the most recent bandwidth sample was marked as
+  // app-limited.
+  bool last_sample_is_app_limited_ = false;
+
+  // Current state of recovery.
+  RecoveryState recovery_state_ = NOT_IN_RECOVERY;
+  // Receiving acknowledgement of a packet after |end_recovery_at_| will cause
+  // BBR to exit the recovery mode.  A value after epoch indicates at least one
+  // loss has been detected, so it must not be set back to epoch.
+  Timestamp end_recovery_at_ = Timestamp::ms(0);
+  // A window used to limit the number of bytes in flight during loss recovery.
+  DataSize recovery_window_;
+
+  bool app_limited_since_last_probe_rtt_ = false;
+  TimeDelta min_rtt_since_last_probe_rtt_ = TimeDelta::PlusInfinity();
+  UpdateState last_update_state_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(BbrNetworkController);
+};
+
+// Used in log output
+std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& os,      // no-presubmit-check TODO(webrtc:8982)
+    const BbrNetworkController::Mode& mode);
+
+}  // namespace bbr
+}  // namespace webrtc
+
+#endif  // MODULES_CONGESTION_CONTROLLER_BBR_BBR_NETWORK_CONTROLLER_H_

modules/congestion_controller/bbr/bbr_network_controller_unittest.cc

@@ -0,0 +1,148 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <algorithm>
+#include <memory>
+
+#include "modules/congestion_controller/bbr/bbr_factory.h"
+#include "modules/congestion_controller/bbr/bbr_network_controller.h"
+#include "modules/congestion_controller/network_control/test/mock_network_control.h"
+#include "modules/congestion_controller/network_control/test/network_control_tester.h"
+#include "test/gtest.h"
+
+using testing::Field;
+using testing::Matcher;
+using testing::AllOf;
+using testing::Ge;
+using testing::Le;
+using testing::NiceMock;
+using testing::Property;
+using testing::StrictMock;
+using testing::_;
+
+namespace webrtc {
+namespace bbr {
+namespace test {
+namespace {
+
+const DataRate kInitialBitrate = DataRate::kbps(60);
+const Timestamp kDefaultStartTime = Timestamp::ms(10000000);
+
+constexpr double kDataRateMargin = 0.3;
+constexpr double kMinDataRateFactor = 1 - kDataRateMargin;
+constexpr double kMaxDataRateFactor = 1 + kDataRateMargin;
+inline Matcher<TargetTransferRate> TargetRateCloseTo(DataRate rate) {
+  DataRate min_data_rate = rate * kMinDataRateFactor;
+  DataRate max_data_rate = rate * kMaxDataRateFactor;
+  return Field(&TargetTransferRate::target_rate,
+               AllOf(Ge(min_data_rate), Le(max_data_rate)));
+}
+
+NetworkControllerConfig InitialConfig(
+    int starting_bandwidth_kbps = kInitialBitrate.kbps(),
+    int min_data_rate_kbps = 0,
+    int max_data_rate_kbps = 5 * kInitialBitrate.kbps()) {
+  NetworkControllerConfig config;
+  config.constraints.at_time = kDefaultStartTime;
+  config.constraints.min_data_rate = DataRate::kbps(min_data_rate_kbps);
+  config.constraints.max_data_rate = DataRate::kbps(max_data_rate_kbps);
+  config.starting_bandwidth = DataRate::kbps(starting_bandwidth_kbps);
+  return config;
+}
+
+NetworkRouteChange CreateRouteChange(Timestamp at_time,
+                                     DataRate start_rate,
+                                     DataRate min_rate = DataRate::Zero(),
+                                     DataRate max_rate = DataRate::Infinity()) {
+  NetworkRouteChange route_change;
+  route_change.at_time = at_time;
+  route_change.constraints.at_time = at_time;
+  route_change.constraints.min_data_rate = min_rate;
+  route_change.constraints.max_data_rate = max_rate;
+  route_change.starting_rate = start_rate;
+  return route_change;
+}
+}  // namespace
+
+class BbrNetworkControllerTest : public ::testing::Test {
+ protected:
+  BbrNetworkControllerTest() {}
+  ~BbrNetworkControllerTest() override {}
+};
+
+TEST_F(BbrNetworkControllerTest, SendsConfigurationOnInitialization) {
+  StrictMock<webrtc::test::MockNetworkControllerObserver> observer;
+  EXPECT_CALL(observer,
+              OnTargetTransferRate(TargetRateCloseTo(kInitialBitrate)));
+  EXPECT_CALL(observer, OnPacerConfig(Property(&PacerConfig::data_rate,
+                                               Ge(kInitialBitrate))));
+  EXPECT_CALL(observer,
+              OnCongestionWindow(Field(&CongestionWindow::data_window,
+                                       Property(&DataSize::IsFinite, true))));
+
+  std::unique_ptr<NetworkControllerInterface> controller_;
+  controller_.reset(new BbrNetworkController(&observer, InitialConfig()));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+}
+
+TEST_F(BbrNetworkControllerTest, SendsConfigurationOnNetworkRouteChanged) {
+  StrictMock<webrtc::test::MockNetworkControllerObserver> observer;
+  EXPECT_CALL(observer, OnTargetTransferRate(_));
+  EXPECT_CALL(observer, OnPacerConfig(_));
+  EXPECT_CALL(observer, OnCongestionWindow(_));
+  std::unique_ptr<NetworkControllerInterface> controller_;
+  controller_.reset(new BbrNetworkController(&observer, InitialConfig()));
+
+  DataRate new_bitrate = DataRate::bps(200000);
+  EXPECT_CALL(observer, OnTargetTransferRate(TargetRateCloseTo(new_bitrate)));
+  EXPECT_CALL(observer, OnPacerConfig(Property(&PacerConfig::data_rate,
+                                               Ge(kInitialBitrate))));
+  EXPECT_CALL(observer, OnCongestionWindow(_));
+  controller_->OnNetworkRouteChange(
+      CreateRouteChange(kDefaultStartTime, new_bitrate));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+}
+
+// Bandwidth estimation is updated when feedbacks are received.
+// Feedbacks which show an increasing delay cause the estimation to be reduced.
+TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) {
+  BbrNetworkControllerFactory factory;
+  webrtc::test::NetworkControllerTester tester(&factory,
+                                               InitialConfig(60, 0, 600));
+  auto packet_producer = &webrtc::test::SimpleTargetRateProducer::ProduceNext;
+
+  tester.RunSimulation(TimeDelta::seconds(5), TimeDelta::ms(10),
+                       DataRate::kbps(300), TimeDelta::ms(100),
+                       packet_producer);
+  EXPECT_GE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(300) * kMinDataRateFactor);
+  EXPECT_LE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(300) * kMaxDataRateFactor);
+
+  tester.RunSimulation(TimeDelta::seconds(30), TimeDelta::ms(10),
+                       DataRate::kbps(500), TimeDelta::ms(100),
+                       packet_producer);
+  EXPECT_GE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(500) * kMinDataRateFactor);
+  EXPECT_LE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(500) * kMaxDataRateFactor);
+
+  tester.RunSimulation(TimeDelta::seconds(30), TimeDelta::ms(10),
+                       DataRate::kbps(100), TimeDelta::ms(200),
+                       packet_producer);
+  EXPECT_GE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(100) * kMinDataRateFactor);
+  EXPECT_LE(tester.GetState().target_rate->target_rate,
+            DataRate::kbps(100) * kMaxDataRateFactor);
+}
+
+}  // namespace test
+}  // namespace bbr
+}  // namespace webrtc

modules/congestion_controller/network_control/test/network_control_tester.cc

@@ -57,7 +57,7 @@ SentPacket SimpleTargetRateProducer::ProduceNext(
   return packet;
 }
 
-FeedbackBasedNetworkControllerTester::FeedbackBasedNetworkControllerTester(
+NetworkControllerTester::NetworkControllerTester(
     NetworkControllerFactoryInterface* factory,
     NetworkControllerConfig initial_config)
     : current_time_(Timestamp::seconds(100000)),
@@ -67,14 +67,12 @@ FeedbackBasedNetworkControllerTester::FeedbackBasedNetworkControllerTester(
   process_interval_ = factory->GetProcessInterval();
 }
 
-FeedbackBasedNetworkControllerTester::~FeedbackBasedNetworkControllerTester() =
+NetworkControllerTester::~NetworkControllerTester() = default;
-    default;
 
-PacketResult FeedbackBasedNetworkControllerTester::SimulateSend(
+PacketResult NetworkControllerTester::SimulateSend(SentPacket packet,
-    SentPacket packet,
+                                                   TimeDelta time_delta,
-    TimeDelta time_delta,
+                                                   TimeDelta propagation_delay,
-    TimeDelta propagation_delay,
+                                                   DataRate actual_bandwidth) {
-    DataRate actual_bandwidth) {
   TimeDelta bandwidth_delay = packet.size / actual_bandwidth;
   accumulated_delay_ =
       std::max(accumulated_delay_ - time_delta, TimeDelta::Zero());
@@ -87,12 +85,11 @@ PacketResult FeedbackBasedNetworkControllerTester::SimulateSend(
   return result;
 }
 
-void FeedbackBasedNetworkControllerTester::RunSimulation(
+void NetworkControllerTester::RunSimulation(TimeDelta duration,
-    TimeDelta duration,
+                                            TimeDelta packet_interval,
-    TimeDelta packet_interval,
+                                            DataRate actual_bandwidth,
-    DataRate actual_bandwidth,
+                                            TimeDelta propagation_delay,
-    TimeDelta propagation_delay,
+                                            PacketProducer next_packet) {
-    PacketProducer next_packet) {
   Timestamp start_time = current_time_;
   Timestamp last_process_time = current_time_;
   while (current_time_ - start_time < duration) {

modules/congestion_controller/network_control/test/network_control_tester.h

@@ -51,7 +51,7 @@ class NetworkControlCacher : public NetworkControllerObserver {
   NetworkControlState current_state_;
 };
 
-class FeedbackBasedNetworkControllerTester {
+class NetworkControllerTester {
  public:
   // A PacketProducer is a function that takes a network control state, a
   // timestamp representing the expected send time and a time delta of the send
@@ -59,10 +59,9 @@ class FeedbackBasedNetworkControllerTester {
   // SentPacket struct with actual send time and packet size.
   using PacketProducer = std::function<
       SentPacket(const NetworkControlState&, Timestamp, TimeDelta)>;
-  FeedbackBasedNetworkControllerTester(
+  NetworkControllerTester(NetworkControllerFactoryInterface* factory,
-      NetworkControllerFactoryInterface* factory,
+                          NetworkControllerConfig initial_config);
-      NetworkControllerConfig initial_config);
+  ~NetworkControllerTester();
-  ~FeedbackBasedNetworkControllerTester();
 
   // Runs the simulations for the given duration, the PacketProducer will be
   // called repeatedly based on the given packet interval and the network will