From d6e9749942e6cc827385bc6f071b0e0fc0e0aca0 Mon Sep 17 00:00:00 2001 From: Per Kjellander Date: Mon, 29 Aug 2022 15:22:15 +0200 Subject: [PATCH] Replace int with Timestamp and DataRate in ProbeController MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace most instances. SetAlrStartTime is set as is should be cleaned up together with the callsite. Bug: webrtc:14404 Change-Id: I8ec532828ef665afbf08f0943465a429ab40baa1 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/273300 Reviewed-by: Erik Språng Commit-Queue: Per Kjellander Cr-Commit-Position: refs/heads/main@{#37932} --- .../congestion_controller/goog_cc/BUILD.gn | 1 + .../goog_cc/goog_cc_network_control.cc | 29 +- .../goog_cc/probe_controller.cc | 282 ++++++----- .../goog_cc/probe_controller.h | 63 +-- .../goog_cc/probe_controller_unittest.cc | 458 +++++++++--------- 5 files changed, 416 insertions(+), 417 deletions(-) diff --git a/modules/congestion_controller/goog_cc/BUILD.gn b/modules/congestion_controller/goog_cc/BUILD.gn index ff95ef7f9a..1335a1ebc7 100644 --- a/modules/congestion_controller/goog_cc/BUILD.gn +++ b/modules/congestion_controller/goog_cc/BUILD.gn @@ -262,6 +262,7 @@ rtc_library("probe_controller") { "../../../api/rtc_event_log", "../../../api/transport:network_control", "../../../api/units:data_rate", + "../../../api/units:data_size", "../../../api/units:time_delta", "../../../api/units:timestamp", "../../../logging:rtc_event_bwe", diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc index 5647145d2c..dfbb2b7efb 100644 --- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc +++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc @@ -24,6 +24,7 @@ #include "absl/strings/match.h" #include "api/units/data_rate.h" #include "api/units/time_delta.h" +#include "api/units/timestamp.h" #include "logging/rtc_event_log/events/rtc_event_remote_estimate.h" #include "modules/congestion_controller/goog_cc/alr_detector.h" #include "modules/congestion_controller/goog_cc/probe_controller.h" @@ -51,15 +52,6 @@ constexpr float kDefaultPaceMultiplier = 2.5f; // below the current throughput estimate to drain the network queues. constexpr double kProbeDropThroughputFraction = 0.85; -int64_t GetBpsOrDefault(const absl::optional& rate, - int64_t fallback_bps) { - if (rate && rate->IsFinite()) { - return rate->bps(); - } else { - return fallback_bps; - } -} - bool IsEnabled(const FieldTrialsView* config, absl::string_view key) { return absl::StartsWith(config->Lookup(key), "Enabled"); } @@ -173,7 +165,7 @@ NetworkControlUpdate GoogCcNetworkController::OnNetworkRouteChange( delay_based_bwe_.reset(new DelayBasedBwe(key_value_config_, event_log_, network_state_predictor_.get())); bandwidth_estimation_->OnRouteChange(); - probe_controller_->Reset(msg.at_time.ms()); + probe_controller_->Reset(msg.at_time); NetworkControlUpdate update; update.probe_cluster_configs = ResetConstraints(msg.constraints); MaybeTriggerOnNetworkChanged(&update, msg.at_time); @@ -196,7 +188,7 @@ NetworkControlUpdate GoogCcNetworkController::OnProcessInterval( initial_config_->stream_based_config.max_total_allocated_bitrate; if (total_bitrate) { auto probes = probe_controller_->OnMaxTotalAllocatedBitrate( - total_bitrate->bps(), msg.at_time.ms()); + *total_bitrate, msg.at_time); update.probe_cluster_configs.insert(update.probe_cluster_configs.end(), probes.begin(), probes.end()); @@ -213,7 +205,7 @@ NetworkControlUpdate GoogCcNetworkController::OnProcessInterval( alr_detector_->GetApplicationLimitedRegionStartTime(); probe_controller_->SetAlrStartTimeMs(start_time_ms); - auto probes = probe_controller_->Process(msg.at_time.ms()); + auto probes = probe_controller_->Process(msg.at_time); update.probe_cluster_configs.insert(update.probe_cluster_configs.end(), probes.begin(), probes.end()); @@ -299,9 +291,9 @@ NetworkControlUpdate GoogCcNetworkController::OnStreamsConfig( if (rate_control_settings_.TriggerProbeOnMaxAllocatedBitrateChange()) { update.probe_cluster_configs = probe_controller_->OnMaxTotalAllocatedBitrate( - msg.max_total_allocated_bitrate->bps(), msg.at_time.ms()); + *msg.max_total_allocated_bitrate, msg.at_time); } else { - probe_controller_->SetMaxBitrate(msg.max_total_allocated_bitrate->bps()); + probe_controller_->SetMaxBitrate(*msg.max_total_allocated_bitrate); } max_total_allocated_bitrate_ = *msg.max_total_allocated_bitrate; } @@ -373,8 +365,8 @@ std::vector GoogCcNetworkController::ResetConstraints( delay_based_bwe_->SetMinBitrate(min_data_rate_); return probe_controller_->SetBitrates( - min_data_rate_.bps(), GetBpsOrDefault(starting_rate_, -1), - max_data_rate_.bps_or(-1), new_constraints.at_time.ms()); + min_data_rate_, starting_rate_.value_or(DataRate::Zero()), max_data_rate_, + new_constraints.at_time); } NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport( @@ -564,7 +556,7 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( if (recovered_from_overuse) { probe_controller_->SetAlrStartTimeMs(alr_start_time); - auto probes = probe_controller_->RequestProbe(report.feedback_time.ms()); + auto probes = probe_controller_->RequestProbe(report.feedback_time); update.probe_cluster_configs.insert(update.probe_cluster_configs.end(), probes.begin(), probes.end()); } @@ -682,8 +674,7 @@ void GoogCcNetworkController::MaybeTriggerOnNetworkChanged( update->target_rate = target_rate_msg; auto probes = probe_controller_->SetEstimatedBitrate( - loss_based_target_rate.bps(), bwe_limited_due_to_packet_loss, - at_time.ms()); + loss_based_target_rate, bwe_limited_due_to_packet_loss, at_time); update->probe_cluster_configs.insert(update->probe_cluster_configs.end(), probes.begin(), probes.end()); update->pacer_config = GetPacingRates(at_time); diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc index 287f717d84..23dc0d47d6 100644 --- a/modules/congestion_controller/goog_cc/probe_controller.cc +++ b/modules/congestion_controller/goog_cc/probe_controller.cc @@ -18,6 +18,7 @@ #include "absl/strings/match.h" #include "absl/types/optional.h" #include "api/units/data_rate.h" +#include "api/units/data_size.h" #include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h" @@ -31,32 +32,28 @@ namespace webrtc { namespace { // Maximum waiting time from the time of initiating probing to getting // the measured results back. -constexpr int64_t kMaxWaitingTimeForProbingResultMs = 1000; - -// Value of `min_bitrate_to_probe_further_bps_` that indicates -// further probing is disabled. -constexpr int kExponentialProbingDisabled = 0; +constexpr TimeDelta kMaxWaitingTimeForProbingResult = TimeDelta::Seconds(1); // Default probing bitrate limit. Applied only when the application didn't // specify max bitrate. -constexpr int64_t kDefaultMaxProbingBitrateBps = 5000000; +constexpr DataRate kDefaultMaxProbingBitrate = DataRate::KilobitsPerSec(5000); // If the bitrate drops to a factor `kBitrateDropThreshold` or lower // and we recover within `kBitrateDropTimeoutMs`, then we'll send // a probe at a fraction `kProbeFractionAfterDrop` of the original bitrate. constexpr double kBitrateDropThreshold = 0.66; -constexpr int kBitrateDropTimeoutMs = 5000; +constexpr TimeDelta kBitrateDropTimeout = TimeDelta::Seconds(5); constexpr double kProbeFractionAfterDrop = 0.85; // Timeout for probing after leaving ALR. If the bitrate drops significantly, // (as determined by the delay based estimator) and we leave ALR, then we will // send a probe if we recover within `kLeftAlrTimeoutMs` ms. -constexpr int kAlrEndedTimeoutMs = 3000; +constexpr TimeDelta kAlrEndedTimeout = TimeDelta::Seconds(3); // The expected uncertainty of probe result (as a fraction of the target probe // This is a limit on how often probing can be done when there is a BW // drop detected in ALR. -constexpr int64_t kMinTimeBetweenAlrProbesMs = 5000; +constexpr TimeDelta kMinTimeBetweenAlrProbes = TimeDelta::Seconds(5); // bitrate). Used to avoid probing if the probe bitrate is close to our current // estimate. @@ -73,11 +70,10 @@ void MaybeLogProbeClusterCreated(RtcEventLog* event_log, return; } - size_t min_bytes = static_cast(probe.target_data_rate.bps() * - probe.target_duration.ms() / 8000); + DataSize min_data_size = probe.target_data_rate * probe.target_duration; event_log->Log(std::make_unique( probe.id, probe.target_data_rate.bps(), probe.target_probe_count, - min_bytes)); + min_data_size.bytes())); } } // namespace @@ -138,32 +134,33 @@ ProbeController::ProbeController(const FieldTrialsView* key_value_config, "Enabled")), event_log_(event_log), config_(ProbeControllerConfig(key_value_config)) { - Reset(0); + Reset(Timestamp::Zero()); } ProbeController::~ProbeController() {} std::vector ProbeController::SetBitrates( - int64_t min_bitrate_bps, - int64_t start_bitrate_bps, - int64_t max_bitrate_bps, - int64_t at_time_ms) { - if (start_bitrate_bps > 0) { - start_bitrate_bps_ = start_bitrate_bps; - estimated_bitrate_bps_ = start_bitrate_bps; - } else if (start_bitrate_bps_ == 0) { - start_bitrate_bps_ = min_bitrate_bps; + DataRate min_bitrate, + DataRate start_bitrate, + DataRate max_bitrate, + Timestamp at_time) { + if (start_bitrate > DataRate::Zero()) { + start_bitrate_ = start_bitrate; + estimated_bitrate_ = start_bitrate; + } else if (start_bitrate_.IsZero()) { + start_bitrate_ = min_bitrate; } // The reason we use the variable `old_max_bitrate_pbs` is because we - // need to set `max_bitrate_bps_` before we call InitiateProbing. - int64_t old_max_bitrate_bps = max_bitrate_bps_; - max_bitrate_bps_ = max_bitrate_bps; + // need to set `max_bitrate_` before we call InitiateProbing. + DataRate old_max_bitrate = max_bitrate_; + max_bitrate_ = + max_bitrate.IsFinite() ? max_bitrate : kDefaultMaxProbingBitrate; switch (state_) { case State::kInit: if (network_available_) - return InitiateExponentialProbing(at_time_ms); + return InitiateExponentialProbing(at_time); break; case State::kWaitingForProbingResult: @@ -172,21 +169,20 @@ std::vector ProbeController::SetBitrates( case State::kProbingComplete: // If the new max bitrate is higher than both the old max bitrate and the // estimate then initiate probing. - if (estimated_bitrate_bps_ != 0 && - old_max_bitrate_bps < max_bitrate_bps_ && - estimated_bitrate_bps_ < max_bitrate_bps_) { + if (!estimated_bitrate_.IsZero() && old_max_bitrate < max_bitrate_ && + estimated_bitrate_ < max_bitrate_) { // The assumption is that if we jump more than 20% in the bandwidth // estimate or if the bandwidth estimate is within 90% of the new // max bitrate then the probing attempt was successful. mid_call_probing_succcess_threshold_ = - std::min(estimated_bitrate_bps_ * 1.2, max_bitrate_bps_ * 0.9); + std::min(estimated_bitrate_ * 1.2, max_bitrate_ * 0.9); mid_call_probing_waiting_for_result_ = true; - mid_call_probing_bitrate_bps_ = max_bitrate_bps_; + mid_call_probing_bitrate_ = max_bitrate_; RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.Initiated", - max_bitrate_bps_ / 1000); + max_bitrate_.kbps()); - return InitiateProbing(at_time_ms, {max_bitrate_bps_}, false); + return InitiateProbing(at_time, {max_bitrate_}, false); } break; } @@ -194,37 +190,35 @@ std::vector ProbeController::SetBitrates( } std::vector ProbeController::OnMaxTotalAllocatedBitrate( - int64_t max_total_allocated_bitrate, - int64_t at_time_ms) { - const bool in_alr = alr_start_time_ms_.has_value(); + DataRate max_total_allocated_bitrate, + Timestamp at_time) { + const bool in_alr = alr_start_time_.has_value(); const bool allow_allocation_probe = in_alr; if (state_ == State::kProbingComplete && max_total_allocated_bitrate != max_total_allocated_bitrate_ && - estimated_bitrate_bps_ != 0 && - (max_bitrate_bps_ <= 0 || estimated_bitrate_bps_ < max_bitrate_bps_) && - estimated_bitrate_bps_ < max_total_allocated_bitrate && + estimated_bitrate_ < max_bitrate_ && + estimated_bitrate_ < max_total_allocated_bitrate && allow_allocation_probe) { max_total_allocated_bitrate_ = max_total_allocated_bitrate; if (!config_.first_allocation_probe_scale) return std::vector(); - DataRate first_probe_rate = - DataRate::BitsPerSec(max_total_allocated_bitrate) * - config_.first_allocation_probe_scale.Value(); + DataRate first_probe_rate = max_total_allocated_bitrate * + config_.first_allocation_probe_scale.Value(); DataRate probe_cap = config_.allocation_probe_max.Get(); first_probe_rate = std::min(first_probe_rate, probe_cap); - std::vector probes = {first_probe_rate.bps()}; + std::vector probes = {first_probe_rate}; if (config_.second_allocation_probe_scale) { DataRate second_probe_rate = - DataRate::BitsPerSec(max_total_allocated_bitrate) * + max_total_allocated_bitrate * config_.second_allocation_probe_scale.Value(); second_probe_rate = std::min(second_probe_rate, probe_cap); if (second_probe_rate > first_probe_rate) - probes.push_back(second_probe_rate.bps()); + probes.push_back(second_probe_rate); } - return InitiateProbing(at_time_ms, probes, + return InitiateProbing(at_time, probes, config_.allocation_allow_further_probing.Get()); } max_total_allocated_bitrate_ = max_total_allocated_bitrate; @@ -237,65 +231,61 @@ std::vector ProbeController::OnNetworkAvailability( if (!network_available_ && state_ == State::kWaitingForProbingResult) { state_ = State::kProbingComplete; - min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled; + min_bitrate_to_probe_further_ = DataRate::PlusInfinity(); } - if (network_available_ && state_ == State::kInit && start_bitrate_bps_ > 0) - return InitiateExponentialProbing(msg.at_time.ms()); + if (network_available_ && state_ == State::kInit && !start_bitrate_.IsZero()) + return InitiateExponentialProbing(msg.at_time); return std::vector(); } std::vector ProbeController::InitiateExponentialProbing( - int64_t at_time_ms) { + Timestamp at_time) { RTC_DCHECK(network_available_); RTC_DCHECK(state_ == State::kInit); - RTC_DCHECK_GT(start_bitrate_bps_, 0); + RTC_DCHECK_GT(start_bitrate_, DataRate::Zero()); // When probing at 1.8 Mbps ( 6x 300), this represents a threshold of // 1.2 Mbps to continue probing. - std::vector probes = {static_cast( - config_.first_exponential_probe_scale * start_bitrate_bps_)}; + std::vector probes = {config_.first_exponential_probe_scale * + start_bitrate_}; if (config_.second_exponential_probe_scale) { probes.push_back(config_.second_exponential_probe_scale.Value() * - start_bitrate_bps_); + start_bitrate_); } - return InitiateProbing(at_time_ms, probes, true); + return InitiateProbing(at_time, probes, true); } std::vector ProbeController::SetEstimatedBitrate( - int64_t bitrate_bps, + DataRate bitrate, bool bwe_limited_due_to_packet_loss, - int64_t at_time_ms) { + Timestamp at_time) { bwe_limited_due_to_packet_loss_ = bwe_limited_due_to_packet_loss; - if (bitrate_bps < kBitrateDropThreshold * estimated_bitrate_bps_) { - time_of_last_large_drop_ms_ = at_time_ms; - bitrate_before_last_large_drop_bps_ = estimated_bitrate_bps_; + if (bitrate < kBitrateDropThreshold * estimated_bitrate_) { + time_of_last_large_drop_ = at_time; + bitrate_before_last_large_drop_ = estimated_bitrate_; } - estimated_bitrate_bps_ = bitrate_bps; + estimated_bitrate_ = bitrate; if (mid_call_probing_waiting_for_result_ && - bitrate_bps >= mid_call_probing_succcess_threshold_) { + bitrate >= mid_call_probing_succcess_threshold_) { RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.Success", - mid_call_probing_bitrate_bps_ / 1000); + mid_call_probing_bitrate_.kbps()); RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.ProbedKbps", - bitrate_bps / 1000); + bitrate.kbps()); mid_call_probing_waiting_for_result_ = false; } std::vector pending_probes; if (state_ == State::kWaitingForProbingResult) { // Continue probing if probing results indicate channel has greater // capacity. - RTC_LOG(LS_INFO) << "Measured bitrate: " << bitrate_bps + RTC_LOG(LS_INFO) << "Measured bitrate: " << bitrate << " Minimum to probe further: " - << min_bitrate_to_probe_further_bps_; + << min_bitrate_to_probe_further_; - if (min_bitrate_to_probe_further_bps_ != kExponentialProbingDisabled && - bitrate_bps > min_bitrate_to_probe_further_bps_) { + if (bitrate > min_bitrate_to_probe_further_) { pending_probes = InitiateProbing( - at_time_ms, - {static_cast(config_.further_exponential_probe_scale * - bitrate_bps)}, - true); + at_time, {config_.further_exponential_probe_scale * bitrate}, true); } } @@ -308,50 +298,54 @@ void ProbeController::EnablePeriodicAlrProbing(bool enable) { void ProbeController::SetAlrStartTimeMs( absl::optional alr_start_time_ms) { - alr_start_time_ms_ = alr_start_time_ms; + if (alr_start_time_ms) { + alr_start_time_ = Timestamp::Millis(*alr_start_time_ms); + } else { + alr_start_time_ = absl::nullopt; + } } void ProbeController::SetAlrEndedTimeMs(int64_t alr_end_time_ms) { - alr_end_time_ms_.emplace(alr_end_time_ms); + alr_end_time_.emplace(Timestamp::Millis(alr_end_time_ms)); } std::vector ProbeController::RequestProbe( - int64_t at_time_ms) { + Timestamp at_time) { // Called once we have returned to normal state after a large drop in // estimated bandwidth. The current response is to initiate a single probe // session (if not already probing) at the previous bitrate. // // If the probe session fails, the assumption is that this drop was a // real one from a competing flow or a network change. - bool in_alr = alr_start_time_ms_.has_value(); + bool in_alr = alr_start_time_.has_value(); bool alr_ended_recently = - (alr_end_time_ms_.has_value() && - at_time_ms - alr_end_time_ms_.value() < kAlrEndedTimeoutMs); + (alr_end_time_.has_value() && + at_time - alr_end_time_.value() < kAlrEndedTimeout); if (in_alr || alr_ended_recently || in_rapid_recovery_experiment_) { if (state_ == State::kProbingComplete) { - uint32_t suggested_probe_bps = - kProbeFractionAfterDrop * bitrate_before_last_large_drop_bps_; - uint32_t min_expected_probe_result_bps = - (1 - kProbeUncertainty) * suggested_probe_bps; - int64_t time_since_drop_ms = at_time_ms - time_of_last_large_drop_ms_; - int64_t time_since_probe_ms = at_time_ms - last_bwe_drop_probing_time_ms_; - if (min_expected_probe_result_bps > estimated_bitrate_bps_ && - time_since_drop_ms < kBitrateDropTimeoutMs && - time_since_probe_ms > kMinTimeBetweenAlrProbesMs) { + DataRate suggested_probe = + kProbeFractionAfterDrop * bitrate_before_last_large_drop_; + DataRate min_expected_probe_result = + (1 - kProbeUncertainty) * suggested_probe; + TimeDelta time_since_drop = at_time - time_of_last_large_drop_; + TimeDelta time_since_probe = at_time - last_bwe_drop_probing_time_; + if (min_expected_probe_result > estimated_bitrate_ && + time_since_drop < kBitrateDropTimeout && + time_since_probe > kMinTimeBetweenAlrProbes) { RTC_LOG(LS_INFO) << "Detected big bandwidth drop, start probing."; // Track how often we probe in response to bandwidth drop in ALR. RTC_HISTOGRAM_COUNTS_10000( "WebRTC.BWE.BweDropProbingIntervalInS", - (at_time_ms - last_bwe_drop_probing_time_ms_) / 1000); - last_bwe_drop_probing_time_ms_ = at_time_ms; - return InitiateProbing(at_time_ms, {suggested_probe_bps}, false); + (at_time - last_bwe_drop_probing_time_).seconds()); + last_bwe_drop_probing_time_ = at_time; + return InitiateProbing(at_time, {suggested_probe}, false); } } } return std::vector(); } -void ProbeController::SetMaxBitrate(int64_t max_bitrate_bps) { - max_bitrate_bps_ = max_bitrate_bps; +void ProbeController::SetMaxBitrate(DataRate max_bitrate) { + max_bitrate_ = max_bitrate; } void ProbeController::SetNetworkStateEstimate( @@ -359,112 +353,106 @@ void ProbeController::SetNetworkStateEstimate( network_estimate_ = estimate; } -void ProbeController::Reset(int64_t at_time_ms) { +void ProbeController::Reset(Timestamp at_time) { network_available_ = true; bwe_limited_due_to_packet_loss_ = false; state_ = State::kInit; - min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled; - time_last_probing_initiated_ms_ = 0; - estimated_bitrate_bps_ = 0; + min_bitrate_to_probe_further_ = DataRate::PlusInfinity(); + time_last_probing_initiated_ = Timestamp::Zero(); + estimated_bitrate_ = DataRate::Zero(); network_estimate_ = absl::nullopt; - start_bitrate_bps_ = 0; - max_bitrate_bps_ = 0; - int64_t now_ms = at_time_ms; - last_bwe_drop_probing_time_ms_ = now_ms; - alr_end_time_ms_.reset(); + start_bitrate_ = DataRate::Zero(); + max_bitrate_ = kDefaultMaxProbingBitrate; + Timestamp now = at_time; + last_bwe_drop_probing_time_ = now; + alr_end_time_.reset(); mid_call_probing_waiting_for_result_ = false; - time_of_last_large_drop_ms_ = now_ms; - bitrate_before_last_large_drop_bps_ = 0; - max_total_allocated_bitrate_ = 0; + time_of_last_large_drop_ = now; + bitrate_before_last_large_drop_ = DataRate::Zero(); + max_total_allocated_bitrate_ = DataRate::Zero(); } -bool ProbeController::TimeForAlrProbe(int64_t at_time_ms) const { - if (enable_periodic_alr_probing_ && alr_start_time_ms_) { - int64_t next_probe_time_ms = - std::max(*alr_start_time_ms_, time_last_probing_initiated_ms_) + - config_.alr_probing_interval->ms(); - return at_time_ms >= next_probe_time_ms; +bool ProbeController::TimeForAlrProbe(Timestamp at_time) const { + if (enable_periodic_alr_probing_ && alr_start_time_) { + Timestamp next_probe_time = + std::max(*alr_start_time_, time_last_probing_initiated_) + + config_.alr_probing_interval; + return at_time >= next_probe_time; } return false; } -bool ProbeController::TimeForNetworkStateProbe(int64_t at_time_ms) const { +bool ProbeController::TimeForNetworkStateProbe(Timestamp at_time) const { if (config_.network_state_estimate_probing_interval->IsFinite() && network_estimate_ && network_estimate_->link_capacity_upper.IsFinite() && - estimated_bitrate_bps_ < network_estimate_->link_capacity_upper.bps()) { - int64_t next_probe_time_ms = - time_last_probing_initiated_ms_ + - config_.network_state_estimate_probing_interval->ms(); - return at_time_ms >= next_probe_time_ms; + estimated_bitrate_ < network_estimate_->link_capacity_upper) { + Timestamp next_probe_time = time_last_probing_initiated_ + + config_.network_state_estimate_probing_interval; + return at_time >= next_probe_time; } return false; } -std::vector ProbeController::Process(int64_t at_time_ms) { - if (at_time_ms - time_last_probing_initiated_ms_ > - kMaxWaitingTimeForProbingResultMs) { +std::vector ProbeController::Process(Timestamp at_time) { + if (at_time - time_last_probing_initiated_ > + kMaxWaitingTimeForProbingResult) { mid_call_probing_waiting_for_result_ = false; if (state_ == State::kWaitingForProbingResult) { RTC_LOG(LS_INFO) << "kWaitingForProbingResult: timeout"; state_ = State::kProbingComplete; - min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled; + min_bitrate_to_probe_further_ = DataRate::PlusInfinity(); } } - if (estimated_bitrate_bps_ <= 0 || state_ != State::kProbingComplete) { + if (estimated_bitrate_.IsZero() || state_ != State::kProbingComplete) { return {}; } - if (TimeForAlrProbe(at_time_ms) || TimeForNetworkStateProbe(at_time_ms)) { - return InitiateProbing(at_time_ms, - {static_cast(estimated_bitrate_bps_ * - config_.alr_probe_scale)}, - true); + if (TimeForAlrProbe(at_time) || TimeForNetworkStateProbe(at_time)) { + return InitiateProbing( + at_time, {estimated_bitrate_ * config_.alr_probe_scale}, true); } return std::vector(); } std::vector ProbeController::InitiateProbing( - int64_t now_ms, - std::vector bitrates_to_probe, + Timestamp now, + std::vector bitrates_to_probe, bool probe_further) { if (bwe_limited_due_to_packet_loss_ && !config_.probe_if_bwe_limited_due_to_loss) { return {}; } - int64_t max_probe_bitrate_bps = - max_bitrate_bps_ > 0 ? max_bitrate_bps_ : kDefaultMaxProbingBitrateBps; + DataRate max_probe_bitrate = max_bitrate_; if (config_.network_state_estimate_probing_interval->IsFinite() && network_estimate_ && network_estimate_->link_capacity_upper > DataRate::Zero()) { - max_probe_bitrate_bps = std::min( - max_probe_bitrate_bps, - static_cast(network_estimate_->link_capacity_upper.bps() * - config_.network_state_probe_scale)); + max_probe_bitrate = + std::min(max_probe_bitrate, network_estimate_->link_capacity_upper * + config_.network_state_probe_scale); } - if (max_total_allocated_bitrate_ > 0) { + if (max_total_allocated_bitrate_ > DataRate::Zero()) { // If a max allocated bitrate has been configured, allow probing up to 2x // that rate. This allows some overhead to account for bursty streams, // which otherwise would have to ramp up when the overshoot is already in // progress. // It also avoids minor quality reduction caused by probes often being // received at slightly less than the target probe bitrate. - max_probe_bitrate_bps = - std::min(max_probe_bitrate_bps, max_total_allocated_bitrate_ * 2); + max_probe_bitrate = + std::min(max_probe_bitrate, max_total_allocated_bitrate_ * 2); } std::vector pending_probes; - for (int64_t bitrate : bitrates_to_probe) { - RTC_DCHECK_GT(bitrate, 0); + for (DataRate bitrate : bitrates_to_probe) { + RTC_DCHECK(!bitrate.IsZero()); - if (bitrate > max_probe_bitrate_bps) { - bitrate = max_probe_bitrate_bps; + if (bitrate > max_probe_bitrate) { + bitrate = max_probe_bitrate; probe_further = false; } ProbeClusterConfig config; - config.at_time = Timestamp::Millis(now_ms); - config.target_data_rate = - DataRate::BitsPerSec(rtc::dchecked_cast(bitrate)); + config.at_time = now; + config.target_data_rate = bitrate; config.target_duration = config_.min_probe_duration; config.target_probe_count = config_.min_probe_packets_sent; config.id = next_probe_cluster_id_; @@ -472,14 +460,14 @@ std::vector ProbeController::InitiateProbing( MaybeLogProbeClusterCreated(event_log_, config); pending_probes.push_back(config); } - time_last_probing_initiated_ms_ = now_ms; + time_last_probing_initiated_ = now; if (probe_further) { state_ = State::kWaitingForProbingResult; - min_bitrate_to_probe_further_bps_ = + min_bitrate_to_probe_further_ = (*(bitrates_to_probe.end() - 1)) * config_.further_probe_threshold; } else { state_ = State::kProbingComplete; - min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled; + min_bitrate_to_probe_further_ = DataRate::PlusInfinity(); } return pending_probes; } diff --git a/modules/congestion_controller/goog_cc/probe_controller.h b/modules/congestion_controller/goog_cc/probe_controller.h index 14cbb6af1d..489a335200 100644 --- a/modules/congestion_controller/goog_cc/probe_controller.h +++ b/modules/congestion_controller/goog_cc/probe_controller.h @@ -23,6 +23,7 @@ #include "api/transport/network_control.h" #include "api/transport/network_types.h" #include "api/units/data_rate.h" +#include "api/units/timestamp.h" #include "rtc_base/experiments/field_trial_parser.h" namespace webrtc { @@ -34,7 +35,7 @@ struct ProbeControllerConfig { ~ProbeControllerConfig(); // These parameters configure the initial probes. First we send one or two - // probes of sizes p1 * start_bitrate_bps_ and p2 * start_bitrate_bps_. + // probes of sizes p1 * start_bitrate_ and p2 * start_bitrate_. // Then whenever we get a bitrate estimate of at least further_probe_threshold // times the size of the last sent probe we'll send another one of size // step_size times the new estimate. @@ -78,24 +79,24 @@ class ProbeController { ProbeController& operator=(const ProbeController&) = delete; ABSL_MUST_USE_RESULT std::vector SetBitrates( - int64_t min_bitrate_bps, - int64_t start_bitrate_bps, - int64_t max_bitrate_bps, - int64_t at_time_ms); + DataRate min_bitrate, + DataRate start_bitrate, + DataRate max_bitrate, + Timestamp at_time); // The total bitrate, as opposed to the max bitrate, is the sum of the // configured bitrates for all active streams. ABSL_MUST_USE_RESULT std::vector - OnMaxTotalAllocatedBitrate(int64_t max_total_allocated_bitrate, - int64_t at_time_ms); + OnMaxTotalAllocatedBitrate(DataRate max_total_allocated_bitrate, + Timestamp at_time); ABSL_MUST_USE_RESULT std::vector OnNetworkAvailability( NetworkAvailability msg); ABSL_MUST_USE_RESULT std::vector SetEstimatedBitrate( - int64_t target_bitrate_bps, + DataRate bitrate, bool bwe_limited_due_to_packet_loss, - int64_t at_time_ms); + Timestamp at_time); void EnablePeriodicAlrProbing(bool enable); @@ -103,18 +104,18 @@ class ProbeController { void SetAlrEndedTimeMs(int64_t alr_end_time); ABSL_MUST_USE_RESULT std::vector RequestProbe( - int64_t at_time_ms); + Timestamp at_time); // Sets a new maximum probing bitrate, without generating a new probe cluster. - void SetMaxBitrate(int64_t max_bitrate_bps); + void SetMaxBitrate(DataRate max_bitrate); void SetNetworkStateEstimate(webrtc::NetworkStateEstimate estimate); // Resets the ProbeController to a state equivalent to as if it was just // created EXCEPT for `enable_periodic_alr_probing_`. - void Reset(int64_t at_time_ms); + void Reset(Timestamp at_time); ABSL_MUST_USE_RESULT std::vector Process( - int64_t at_time_ms); + Timestamp at_time); private: enum class State { @@ -127,36 +128,36 @@ class ProbeController { }; ABSL_MUST_USE_RESULT std::vector - InitiateExponentialProbing(int64_t at_time_ms); + InitiateExponentialProbing(Timestamp at_time); ABSL_MUST_USE_RESULT std::vector InitiateProbing( - int64_t now_ms, - std::vector bitrates_to_probe, + Timestamp now, + std::vector bitrates_to_probe, bool probe_further); - bool TimeForAlrProbe(int64_t at_time_ms) const; - bool TimeForNetworkStateProbe(int64_t at_time_ms) const; + bool TimeForAlrProbe(Timestamp at_time) const; + bool TimeForNetworkStateProbe(Timestamp at_time) const; bool network_available_; bool bwe_limited_due_to_packet_loss_; State state_; - int64_t min_bitrate_to_probe_further_bps_; - int64_t time_last_probing_initiated_ms_; - int64_t estimated_bitrate_bps_; + DataRate min_bitrate_to_probe_further_ = DataRate::PlusInfinity(); + Timestamp time_last_probing_initiated_ = Timestamp::MinusInfinity(); + DataRate estimated_bitrate_ = DataRate::Zero(); absl::optional network_estimate_; - int64_t start_bitrate_bps_; - int64_t max_bitrate_bps_; - int64_t last_bwe_drop_probing_time_ms_; - absl::optional alr_start_time_ms_; - absl::optional alr_end_time_ms_; + DataRate start_bitrate_ = DataRate::Zero(); + DataRate max_bitrate_ = DataRate::PlusInfinity(); + Timestamp last_bwe_drop_probing_time_ = Timestamp::Zero(); + absl::optional alr_start_time_; + absl::optional alr_end_time_; bool enable_periodic_alr_probing_; - int64_t time_of_last_large_drop_ms_; - int64_t bitrate_before_last_large_drop_bps_; - int64_t max_total_allocated_bitrate_; + Timestamp time_of_last_large_drop_ = Timestamp::MinusInfinity(); + DataRate bitrate_before_last_large_drop_ = DataRate::Zero(); + DataRate max_total_allocated_bitrate_ = DataRate::Zero(); const bool in_rapid_recovery_experiment_; // For WebRTC.BWE.MidCallProbing.* metric. bool mid_call_probing_waiting_for_result_; - int64_t mid_call_probing_bitrate_bps_; - int64_t mid_call_probing_succcess_threshold_; + DataRate mid_call_probing_bitrate_ = DataRate::Zero(); + DataRate mid_call_probing_succcess_threshold_ = DataRate::Zero(); RtcEventLog* event_log_; int32_t next_probe_cluster_id_ = 1; diff --git a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc index 4587ecd014..8070820a77 100644 --- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc +++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc @@ -11,9 +11,8 @@ #include -#include "api/transport/field_trial_based_config.h" -#include "api/transport/network_types.h" #include "api/units/data_rate.h" +#include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "logging/rtc_event_log/mock/mock_rtc_event_log.h" #include "rtc_base/logging.h" @@ -22,27 +21,22 @@ #include "test/gmock.h" #include "test/gtest.h" -using ::testing::_; -using ::testing::AtLeast; -using ::testing::Field; -using ::testing::Matcher; using ::testing::NiceMock; -using ::testing::Return; namespace webrtc { namespace test { namespace { -constexpr int kMinBitrateBps = 100; -constexpr int kStartBitrateBps = 300; -constexpr int kMaxBitrateBps = 10000; +constexpr DataRate kMinBitrate = DataRate::BitsPerSec(100); +constexpr DataRate kStartBitrate = DataRate::BitsPerSec(300); +constexpr DataRate kMaxBitrate = DataRate::BitsPerSec(10000); -constexpr int kExponentialProbingTimeoutMs = 5000; +constexpr TimeDelta kExponentialProbingTimeout = TimeDelta::Seconds(5); -constexpr int kAlrProbeInterval = 5000; -constexpr int kAlrEndedTimeoutMs = 3000; -constexpr int kBitrateDropTimeoutMs = 5000; +constexpr TimeDelta kAlrProbeInterval = TimeDelta::Seconds(5); +constexpr TimeDelta kAlrEndedTimeout = TimeDelta::Seconds(3); +constexpr TimeDelta kBitrateDropTimeout = TimeDelta::Seconds(5); } // namespace class ProbeControllerFixture { @@ -56,10 +50,7 @@ class ProbeControllerFixture { } Timestamp CurrentTime() { return clock_.CurrentTime(); } - int64_t NowMs() { return clock_.TimeInMilliseconds(); } - void AdvanceTimeMilliseconds(int64_t delta_ms) { - clock_.AdvanceTimeMilliseconds(delta_ms); - } + void AdvanceTime(TimeDelta delta) { clock_.AdvanceTime(delta); } ExplicitKeyValueConfig field_trial_config_; SimulatedClock clock_; @@ -71,8 +62,8 @@ TEST(ProbeControllerTest, InitiatesProbingAtStart) { std::unique_ptr probe_controller = fixture.CreateController(); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_GE(probes.size(), 2u); } @@ -81,7 +72,7 @@ TEST(ProbeControllerTest, SetsDefaultTargetDurationAndTargetProbeCount) { std::unique_ptr probe_controller = fixture.CreateController(); std::vector probes = probe_controller->SetBitrates( - kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps, fixture.NowMs()); + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); ASSERT_GE(probes.size(), 2u); EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(15)); @@ -96,7 +87,7 @@ TEST(ProbeControllerTest, std::unique_ptr probe_controller = fixture.CreateController(); std::vector probes = probe_controller->SetBitrates( - kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps, fixture.NowMs()); + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); ASSERT_GE(probes.size(), 2u); EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(123)); @@ -109,8 +100,8 @@ TEST(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) { fixture.CreateController(); auto probes = probe_controller->OnNetworkAvailability( {.at_time = fixture.CurrentTime(), .network_available = false}); - probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, + kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); probes = probe_controller->OnNetworkAvailability( {.at_time = fixture.CurrentTime(), .network_available = true}); @@ -121,45 +112,46 @@ TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); // Long enough to time out exponential probing. - fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs); + fixture.AdvanceTime(kExponentialProbingTimeout); probes = probe_controller->SetEstimatedBitrate( - kStartBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probes = probe_controller->Process(fixture.NowMs()); - probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps + 100, fixture.NowMs()); + kStartBitrate, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + probes = probe_controller->Process(fixture.CurrentTime()); + probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100), + fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps + 100); + EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrate.bps() + 100); } TEST(ProbeControllerTest, ProbesOnMaxBitrateIncreaseOnlyWhenInAlr) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - kMaxBitrateBps - 1, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + kMaxBitrate - DataRate::BitsPerSec(1), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); // Wait long enough to time out exponential probing. - fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(kExponentialProbingTimeout); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); // Probe when in alr. - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - probes = probe_controller->OnMaxTotalAllocatedBitrate(kMaxBitrateBps + 1, - fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + probes = probe_controller->OnMaxTotalAllocatedBitrate( + kMaxBitrate + DataRate::BitsPerSec(1), fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); // Do not probe when not in alr. probe_controller->SetAlrStartTimeMs(absl::nullopt); - probes = probe_controller->OnMaxTotalAllocatedBitrate(kMaxBitrateBps + 2, - fixture.NowMs()); + probes = probe_controller->OnMaxTotalAllocatedBitrate( + kMaxBitrate + DataRate::BitsPerSec(2), fixture.CurrentTime()); EXPECT_TRUE(probes.empty()); } @@ -167,38 +159,42 @@ TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); // Long enough to time out exponential probing. - fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs); + fixture.AdvanceTime(kExponentialProbingTimeout); probes = probe_controller->SetEstimatedBitrate( - kStartBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probes = probe_controller->Process(fixture.NowMs()); + kStartBitrate, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - kMaxBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps + 100, fixture.NowMs()); + kMaxBitrate, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100), + fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps + 100); + EXPECT_EQ(probes[0].target_data_rate, + kMaxBitrate + DataRate::BitsPerSec(100)); } TEST(ProbeControllerTest, TestExponentialProbing) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); // Repeated probe should only be sent when estimated bitrate climbs above - // 0.7 * 6 * kStartBitrateBps = 1260. + // 0.7 * 6 * kStartBitrate = 1260. probes = probe_controller->SetEstimatedBitrate( - 1000, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(1000), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); probes = probe_controller->SetEstimatedBitrate( - 1800, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(1800), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800); } @@ -207,15 +203,15 @@ TEST(ProbeControllerTest, TestExponentialProbingTimeout) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); // Advance far enough to cause a time out in waiting for probing result. - fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(kExponentialProbingTimeout); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 1800, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(1800), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); } @@ -223,19 +219,20 @@ TEST(ProbeControllerTest, RequestProbeInAlr) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_GE(probes.size(), 2u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 250, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probes = probe_controller->RequestProbe(fixture.NowMs()); + DataRate::BitsPerSec(250), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); + probes = probe_controller->RequestProbe(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500); @@ -245,21 +242,22 @@ TEST(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); probe_controller->SetAlrStartTimeMs(absl::nullopt); - fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 250, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probe_controller->SetAlrEndedTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs - 1); - probes = probe_controller->RequestProbe(fixture.NowMs()); + DataRate::BitsPerSec(250), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); + probe_controller->SetAlrEndedTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(kAlrEndedTimeout - TimeDelta::Millis(1)); + probes = probe_controller->RequestProbe(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500); @@ -269,21 +267,22 @@ TEST(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); probe_controller->SetAlrStartTimeMs(absl::nullopt); - fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 250, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - probe_controller->SetAlrEndedTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs + 1); - probes = probe_controller->RequestProbe(fixture.NowMs()); + DataRate::BitsPerSec(250), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); + probe_controller->SetAlrEndedTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(kAlrEndedTimeout + TimeDelta::Millis(1)); + probes = probe_controller->RequestProbe(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); } @@ -291,20 +290,21 @@ TEST(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 250, kBweLimitedDuetoPacketLoss, fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(kBitrateDropTimeoutMs + 1); - probes = probe_controller->RequestProbe(fixture.NowMs()); + DataRate::BitsPerSec(250), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); + fixture.AdvanceTime(kBitrateDropTimeout + TimeDelta::Millis(1)); + probes = probe_controller->RequestProbe(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); } @@ -312,40 +312,43 @@ TEST(ProbeControllerTest, PeriodicProbing) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; probe_controller->EnablePeriodicAlrProbing(true); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); - int64_t start_time = fixture.NowMs(); + Timestamp start_time = fixture.CurrentTime(); // Expect the controller to send a new probe after 5s has passed. - probe_controller->SetAlrStartTimeMs(start_time); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(start_time.ms()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate.bps(), 1000); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); // The following probe should be sent at 10s into ALR. - probe_controller->SetAlrStartTimeMs(start_time); - fixture.AdvanceTimeMilliseconds(4000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(start_time.ms()); + fixture.AdvanceTime(TimeDelta::Seconds(4)); + probes = probe_controller->Process(fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); - probe_controller->SetAlrStartTimeMs(start_time); - fixture.AdvanceTimeMilliseconds(1000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(start_time.ms()); + fixture.AdvanceTime(TimeDelta::Seconds(1)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); probes = probe_controller->SetEstimatedBitrate( - 500, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(500), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); } @@ -353,49 +356,50 @@ TEST(ProbeControllerTest, PeriodicProbingAfterReset) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - int64_t alr_start_time = fixture.NowMs(); + Timestamp alr_start_time = fixture.CurrentTime(); - probe_controller->SetAlrStartTimeMs(alr_start_time); + probe_controller->SetAlrStartTimeMs(alr_start_time.ms()); probe_controller->EnablePeriodicAlrProbing(true); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); - probe_controller->Reset(fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); + probe_controller->Reset(fixture.CurrentTime()); - fixture.AdvanceTimeMilliseconds(10000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(10)); + probes = probe_controller->Process(fixture.CurrentTime()); // Since bitrates are not yet set, no probe is sent event though we are in ALR // mode. EXPECT_EQ(probes.size(), 0u); - probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, + kMaxBitrate, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); // Make sure we use `kStartBitrateBps` as the estimated bitrate // until SetEstimatedBitrate is called with an updated estimate. - fixture.AdvanceTimeMilliseconds(10000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(10)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), kStartBitrateBps * 2); + EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2); } TEST(ProbeControllerTest, TestExponentialProbingOverflow) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - const int64_t kMbpsMultiplier = 1000000; - auto probes = - probe_controller->SetBitrates(kMinBitrateBps, 10 * kMbpsMultiplier, - 100 * kMbpsMultiplier, fixture.NowMs()); + const DataRate kMbpsMultiplier = DataRate::KilobitsPerSec(1000); + auto probes = probe_controller->SetBitrates(kMinBitrate, 10 * kMbpsMultiplier, + 100 * kMbpsMultiplier, + fixture.CurrentTime()); // Verify that probe bitrate is capped at the specified max bitrate. probes = probe_controller->SetEstimatedBitrate( - 60 * kMbpsMultiplier, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + 60 * kMbpsMultiplier, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), 100 * kMbpsMultiplier); + EXPECT_EQ(probes[0].target_data_rate, 100 * kMbpsMultiplier); // Verify that repeated probes aren't sent. probes = probe_controller->SetEstimatedBitrate( - 100 * kMbpsMultiplier, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + 100 * kMbpsMultiplier, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); } @@ -403,40 +407,42 @@ TEST(ProbeControllerTest, TestAllocatedBitrateCap) { ProbeControllerFixture fixture; std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - const int64_t kMbpsMultiplier = 1000000; - const int64_t kMaxBitrateBps = 100 * kMbpsMultiplier; + const DataRate kMbpsMultiplier = DataRate::KilobitsPerSec(1000); + const DataRate kMaxBitrate = 100 * kMbpsMultiplier; auto probes = probe_controller->SetBitrates( - kMinBitrateBps, 10 * kMbpsMultiplier, kMaxBitrateBps, fixture.NowMs()); + kMinBitrate, 10 * kMbpsMultiplier, kMaxBitrate, fixture.CurrentTime()); // Configure ALR for periodic probing. probe_controller->EnablePeriodicAlrProbing(true); - int64_t alr_start_time = fixture.NowMs(); - probe_controller->SetAlrStartTimeMs(alr_start_time); + Timestamp alr_start_time = fixture.CurrentTime(); + probe_controller->SetAlrStartTimeMs(alr_start_time.ms()); - int64_t estimated_bitrate_bps = kMaxBitrateBps / 10; + DataRate estimated_bitrate = kMaxBitrate / 10; probes = probe_controller->SetEstimatedBitrate( - estimated_bitrate_bps, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + estimated_bitrate, /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); // Set a max allocated bitrate below the current estimate. - int64_t max_allocated_bps = estimated_bitrate_bps - 1 * kMbpsMultiplier; - probes = probe_controller->OnMaxTotalAllocatedBitrate(max_allocated_bps, - fixture.NowMs()); + DataRate max_allocated = estimated_bitrate - 1 * kMbpsMultiplier; + probes = probe_controller->OnMaxTotalAllocatedBitrate(max_allocated, + fixture.CurrentTime()); EXPECT_TRUE(probes.empty()); // No probe since lower than current max. // Probes such as ALR capped at 2x the max allocation limit. - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * max_allocated_bps); + EXPECT_EQ(probes[0].target_data_rate, 2 * max_allocated); // Remove allocation limit. EXPECT_TRUE( - probe_controller->OnMaxTotalAllocatedBitrate(0, fixture.NowMs()).empty()); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller + ->OnMaxTotalAllocatedBitrate(DataRate::Zero(), fixture.CurrentTime()) + .empty()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), estimated_bitrate_bps * 2); + EXPECT_EQ(probes[0].target_data_rate, estimated_bitrate * 2); } TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) { @@ -446,10 +452,10 @@ TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) { "alloc_p1:2,alloc_p2/"); std::unique_ptr probe_controller = fixture.CreateController(); - const bool kBweLimitedDuetoPacketLoss = false; - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - 5000000, fixture.NowMs()); + auto probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, + DataRate::KilobitsPerSec(5000), + fixture.CurrentTime()); EXPECT_EQ(probes.size(), 2u); EXPECT_EQ(probes[0].target_data_rate.bps(), 600); EXPECT_EQ(probes[1].target_data_rate.bps(), 1500); @@ -457,22 +463,24 @@ TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) { // Repeated probe should only be sent when estimated bitrate climbs above // 0.8 * 5 * kStartBitrateBps = 1200. probes = probe_controller->SetEstimatedBitrate( - 1100, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(1100), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 0u); probes = probe_controller->SetEstimatedBitrate( - 1250, kBweLimitedDuetoPacketLoss, fixture.NowMs()); + DataRate::BitsPerSec(1250), + /*bwe_limited_due_to_packet_loss=*/false, fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate.bps(), 3 * 1250); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - probes = - probe_controller->OnMaxTotalAllocatedBitrate(200000, fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + probes = probe_controller->OnMaxTotalAllocatedBitrate( + DataRate::KilobitsPerSec(200), fixture.CurrentTime()); EXPECT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), 400000); + EXPECT_EQ(probes[0].target_data_rate.bps(), 400'000); } TEST(ProbeControllerTest, PauseAlrProbeWhenLossBasedBweLimited) { @@ -482,27 +490,30 @@ TEST(ProbeControllerTest, PauseAlrProbeWhenLossBasedBweLimited) { std::unique_ptr probe_controller = fixture.CreateController(); probe_controller->EnablePeriodicAlrProbing(true); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); // Expect the controller to send a new probe after 5s has passed. - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss*/ true, fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(6000); - probes = probe_controller->Process(fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss*/ true, + fixture.CurrentTime()); + fixture.AdvanceTime(TimeDelta::Seconds(6)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_TRUE(probes.empty()); // ALR probing resumed when estimate is no longer restricted by loss based // BWE. probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(6000); - probes = probe_controller->Process(fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + fixture.AdvanceTime(TimeDelta::Seconds(6)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_TRUE(!probes.empty()); } @@ -513,19 +524,21 @@ TEST(ProbeControllerTest, AlrProbeStartWhenNotLossBasedBweLimited) { std::unique_ptr probe_controller = fixture.CreateController(); probe_controller->EnablePeriodicAlrProbing(true); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/true, fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/true, + fixture.CurrentTime()); // Expect the controller to send a new probe after 5s has passed. - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_TRUE(probes.empty()); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss*/ false, fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(1000); - probes = probe_controller->Process(fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss*/ false, + fixture.CurrentTime()); + fixture.AdvanceTime(TimeDelta::Seconds(1)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_TRUE(!probes.empty()); } @@ -535,21 +548,22 @@ TEST(ProbeControllerTest, PeriodicProbeAtUpperNetworkStateEstimate) { std::unique_ptr probe_controller = fixture.CreateController(); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 5000, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); + DataRate::BitsPerSec(5000), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); // Expect the controller to send a new probe after 5s has passed. NetworkStateEstimate state_estimate; - state_estimate.link_capacity_upper = DataRate::BitsPerSec(6000); + state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(6); probe_controller->SetNetworkStateEstimate(state_estimate); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); } @@ -562,29 +576,32 @@ TEST(ProbeControllerTest, std::unique_ptr probe_controller = fixture.CreateController(); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); // Expect the controller to send a new probe after 5s has passed. NetworkStateEstimate state_estimate; state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(600); probe_controller->SetNetworkStateEstimate(state_estimate); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/true, fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/true, + fixture.CurrentTime()); // Expect the controller to send a new probe after 5s has passed. - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_TRUE(probes.empty()); probes = probe_controller->SetEstimatedBitrate( - 500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + DataRate::BitsPerSec(500), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); EXPECT_FALSE(probes.empty()); } @@ -594,22 +611,23 @@ TEST(ProbeControllerTest, AlrProbesLimitedByNetworkStateEstimate) { std::unique_ptr probe_controller = fixture.CreateController(); probe_controller->EnablePeriodicAlrProbing(true); - auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps, - kMaxBitrateBps, fixture.NowMs()); + auto probes = probe_controller->SetBitrates( + kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); probes = probe_controller->SetEstimatedBitrate( - 6000, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs()); - probe_controller->SetAlrStartTimeMs(fixture.NowMs()); + DataRate::KilobitsPerSec(6), /*bwe_limited_due_to_packet_loss=*/false, + fixture.CurrentTime()); + probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms()); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); - EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps); + EXPECT_EQ(probes[0].target_data_rate, kMaxBitrate); NetworkStateEstimate state_estimate; state_estimate.link_capacity_upper = DataRate::BitsPerSec(8000); probe_controller->SetNetworkStateEstimate(state_estimate); - fixture.AdvanceTimeMilliseconds(5000); - probes = probe_controller->Process(fixture.NowMs()); + fixture.AdvanceTime(TimeDelta::Seconds(5)); + probes = probe_controller->Process(fixture.CurrentTime()); ASSERT_EQ(probes.size(), 1u); EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); }