zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add field trial to periodically probe at networkstate estimate.

Browse Source 
Add field trial to not probe if loss based limited

If both Alr probing and periodic probing of networkstate estimate is enabled, probes are limited by the network state estimate * factor controlled by field trial.


Bug: webrtc:14392
Change-Id: I46e1dbdd8b14f63a7c223b4c03c114717b802023
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/272805
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Reviewed-by: Diep Bui <diepbp@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37915}
This commit is contained in:
Per Kjellander
2022-08-25 17:57:23 +02:00
committed by WebRTC LUCI CQ
parent bd00010bb8
commit 6d47f2e1fa
6 changed files with 291 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
modules/congestion_controller/goog_cc/probe_controller_unittest.cc
View File

@ -121,12 +121,13 @@ TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
// Long enough to time out exponential probing.
fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probes =
probe_controller->SetEstimatedBitrate(kStartBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
kStartBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, fixture.NowMs());
@ -138,10 +139,11 @@ TEST(ProbeControllerTest, ProbesOnMaxBitrateIncreaseOnlyWhenInAlr) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(kMaxBitrateBps - 1,
fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
kMaxBitrateBps - 1, kBweLimitedDuetoPacketLoss, fixture.NowMs());
// Wait long enough to time out exponential probing.
fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
@ -165,15 +167,16 @@ TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
// Long enough to time out exponential probing.
fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probes =
probe_controller->SetEstimatedBitrate(kStartBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
kStartBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probes = probe_controller->Process(fixture.NowMs());
probes =
probe_controller->SetEstimatedBitrate(kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
kMaxBitrateBps, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
@ -184,15 +187,18 @@ TEST(ProbeControllerTest, TestExponentialProbing) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
// Repeated probe should only be sent when estimated bitrate climbs above
// 0.7 * 6 * kStartBitrateBps = 1260.
probes = probe_controller->SetEstimatedBitrate(1000, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
1000, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
probes = probe_controller->SetEstimatedBitrate(1800, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
1800, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800);
}
@ -201,13 +207,15 @@ TEST(ProbeControllerTest, TestExponentialProbingTimeout) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
// Advance far enough to cause a time out in waiting for probing result.
fixture.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(1800, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
1800, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
}
@ -215,15 +223,18 @@ TEST(ProbeControllerTest, RequestProbeInAlr) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
EXPECT_GE(probes.size(), 2u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrStartTimeMs(fixture.NowMs());
fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(250, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
250, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probes = probe_controller->RequestProbe(fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
@ -234,15 +245,18 @@ TEST(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrStartTimeMs(absl::nullopt);
fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(250, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
250, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrEndedTimeMs(fixture.NowMs());
fixture.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs - 1);
probes = probe_controller->RequestProbe(fixture.NowMs());
@ -255,15 +269,18 @@ TEST(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrStartTimeMs(absl::nullopt);
fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(250, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
250, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrEndedTimeMs(fixture.NowMs());
fixture.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs + 1);
probes = probe_controller->RequestProbe(fixture.NowMs());
@ -274,15 +291,18 @@ TEST(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
probe_controller->SetAlrStartTimeMs(fixture.NowMs());
fixture.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(250, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
250, kBweLimitedDuetoPacketLoss, fixture.NowMs());
fixture.AdvanceTimeMilliseconds(kBitrateDropTimeoutMs + 1);
probes = probe_controller->RequestProbe(fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
@ -292,11 +312,13 @@ TEST(ProbeControllerTest, PeriodicProbing) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
probe_controller->EnablePeriodicAlrProbing(true);
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
int64_t start_time = fixture.NowMs();
@ -307,20 +329,23 @@ TEST(ProbeControllerTest, PeriodicProbing) {
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 1000);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
// The following probe should be sent at 10s into ALR.
probe_controller->SetAlrStartTimeMs(start_time);
fixture.AdvanceTimeMilliseconds(4000);
probes = probe_controller->Process(fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
probe_controller->SetAlrStartTimeMs(start_time);
fixture.AdvanceTimeMilliseconds(1000);
probes = probe_controller->Process(fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
probes = probe_controller->SetEstimatedBitrate(500, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
}
@ -358,18 +383,19 @@ TEST(ProbeControllerTest, TestExponentialProbingOverflow) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> 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());
// Verify that probe bitrate is capped at the specified max bitrate.
probes = probe_controller->SetEstimatedBitrate(60 * kMbpsMultiplier,
fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
60 * kMbpsMultiplier, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 100 * kMbpsMultiplier);
// Verify that repeated probes aren't sent.
probes = probe_controller->SetEstimatedBitrate(100 * kMbpsMultiplier,
fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
100 * kMbpsMultiplier, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
}
@ -377,6 +403,7 @@ TEST(ProbeControllerTest, TestAllocatedBitrateCap) {
ProbeControllerFixture fixture;
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
const int64_t kMbpsMultiplier = 1000000;
const int64_t kMaxBitrateBps = 100 * kMbpsMultiplier;
auto probes = probe_controller->SetBitrates(
@ -388,8 +415,8 @@ TEST(ProbeControllerTest, TestAllocatedBitrateCap) {
probe_controller->SetAlrStartTimeMs(alr_start_time);
int64_t estimated_bitrate_bps = kMaxBitrateBps / 10;
probes = probe_controller->SetEstimatedBitrate(estimated_bitrate_bps,
fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
estimated_bitrate_bps, kBweLimitedDuetoPacketLoss, fixture.NowMs());
// Set a max allocated bitrate below the current estimate.
int64_t max_allocated_bps = estimated_bitrate_bps - 1 * kMbpsMultiplier;
@ -419,6 +446,7 @@ TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) {
"alloc_p1:2,alloc_p2/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
const bool kBweLimitedDuetoPacketLoss = false;
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
5000000, fixture.NowMs());
@ -428,10 +456,12 @@ TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) {
// Repeated probe should only be sent when estimated bitrate climbs above
// 0.8 * 5 * kStartBitrateBps = 1200.
probes = probe_controller->SetEstimatedBitrate(1100, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
1100, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 0u);
probes = probe_controller->SetEstimatedBitrate(1250, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
1250, kBweLimitedDuetoPacketLoss, fixture.NowMs());
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 3 * 1250);
@ -445,5 +475,144 @@ TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) {
EXPECT_EQ(probes[0].target_data_rate.bps(), 400000);
}
TEST(ProbeControllerTest, PauseAlrProbeWhenLossBasedBweLimited) {
ProbeControllerFixture fixture(
"WebRTC-Bwe-ProbingConfiguration/"
"probe_if_bwe_limited_due_to_loss:false/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
probe_controller->EnablePeriodicAlrProbing(true);
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs());
// 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());
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());
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());
EXPECT_TRUE(!probes.empty());
}
TEST(ProbeControllerTest, AlrProbeStartWhenNotLossBasedBweLimited) {
ProbeControllerFixture fixture(
"WebRTC-Bwe-ProbingConfiguration/"
"probe_if_bwe_limited_due_to_loss:false/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
probe_controller->EnablePeriodicAlrProbing(true);
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, /*bwe_limited_due_to_packet_loss=*/true, fixture.NowMs());
// 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());
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());
EXPECT_TRUE(!probes.empty());
}
TEST(ProbeControllerTest, PeriodicProbeAtUpperNetworkStateEstimate) {
ProbeControllerFixture fixture(
"WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
5000, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs());
// Expect the controller to send a new probe after 5s has passed.
NetworkStateEstimate state_estimate;
state_estimate.link_capacity_upper = DataRate::BitsPerSec(6000);
probe_controller->SetNetworkStateEstimate(state_estimate);
fixture.AdvanceTimeMilliseconds(5000);
probes = probe_controller->Process(fixture.NowMs());
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());
ASSERT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
}
TEST(ProbeControllerTest,
PausePeriodicProbeAtUpperNetworkStateEstimateIfLossBasedLimited) {
ProbeControllerFixture fixture(
"WebRTC-Bwe-ProbingConfiguration/"
"network_state_interval:5s,probe_if_bwe_limited_due_to_loss:false/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
500, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs());
// 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());
ASSERT_EQ(probes.size(), 1u);
probes = probe_controller->SetEstimatedBitrate(
500, /*bwe_limited_due_to_packet_loss=*/true, fixture.NowMs());
// Expect the controller to send a new probe after 5s has passed.
fixture.AdvanceTimeMilliseconds(5000);
probes = probe_controller->Process(fixture.NowMs());
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());
EXPECT_FALSE(probes.empty());
}
TEST(ProbeControllerTest, AlrProbesLimitedByNetworkStateEstimate) {
ProbeControllerFixture fixture(
"WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/");
std::unique_ptr<ProbeController> probe_controller =
fixture.CreateController();
probe_controller->EnablePeriodicAlrProbing(true);
auto probes = probe_controller->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, fixture.NowMs());
probes = probe_controller->SetEstimatedBitrate(
6000, /*bwe_limited_due_to_packet_loss=*/false, fixture.NowMs());
probe_controller->SetAlrStartTimeMs(fixture.NowMs());
fixture.AdvanceTimeMilliseconds(5000);
probes = probe_controller->Process(fixture.NowMs());
ASSERT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps);
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());
ASSERT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
}
} // namespace test
} // namespace webrtc