Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(386)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/call/bitrate_allocator_unittest.cc

Issue 2518923003: Pass time constant to bwe smoothing filter. (Closed)
Patch Set: Add probing_interval_ms to NullBitrateObserver. Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/call/bitrate_allocator.cc ('k') | webrtc/call/call.cc » ('j') | webrtc/modules/congestion_controller/include/congestion_controller.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/call/bitrate_allocator_unittest.cc
diff --git a/webrtc/call/bitrate_allocator_unittest.cc b/webrtc/call/bitrate_allocator_unittest.cc
index 5d0395d82cae9d2dfe94140e547c9c7f729ea8b3..751ec93657d54c815c3b268744a46773c968bf3f 100644
--- a/webrtc/call/bitrate_allocator_unittest.cc
+++ b/webrtc/call/bitrate_allocator_unittest.cc
@@ -34,6 +34,7 @@ class TestBitrateObserver : public BitrateAllocatorObserver {
: last_bitrate_bps_(0),
last_fraction_loss_(0),
last_rtt_ms_(0),
+ last_probing_interval_ms_(0),
protection_ratio_(0.0) {}
void SetBitrateProtectionRatio(double protection_ratio) {
@@ -42,22 +43,29 @@ class TestBitrateObserver : public BitrateAllocatorObserver {
uint32_t OnBitrateUpdated(uint32_t bitrate_bps,
uint8_t fraction_loss,
- int64_t rtt) override {
+ int64_t rtt,
+ int64_t probing_interval_ms) override {
last_bitrate_bps_ = bitrate_bps;
last_fraction_loss_ = fraction_loss;
last_rtt_ms_ = rtt;
+ last_probing_interval_ms_ = probing_interval_ms;
return bitrate_bps * protection_ratio_;
}
uint32_t last_bitrate_bps_;
uint8_t last_fraction_loss_;
int64_t last_rtt_ms_;
+ int last_probing_interval_ms_;
double protection_ratio_;
};
+namespace {
+constexpr int64_t kDefaultProbingIntervalMs = 3000;
+}
+
class BitrateAllocatorTest : public ::testing::Test {
protected:
BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) {
- allocator_->OnNetworkChanged(300000u, 0, 0);
+ allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
}
~BitrateAllocatorTest() {}
@@ -75,12 +83,12 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
kPadUpToBitrateBps, true);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
- allocator_->OnNetworkChanged(200000, 0, 0);
+ allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
// TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max
// bitrate for FEC/retransmissions (see todo in BitrateAllocator).
- allocator_->OnNetworkChanged(4000000, 0, 0);
+ allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
@@ -96,7 +104,7 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
true);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(1500000, 0, 0);
+ allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
}
@@ -114,7 +122,7 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
// Test too low start bitrate, hence lower than sum of min. Min bitrates
// will
// be allocated to all observers.
- allocator_->OnNetworkChanged(200000, 0, 50);
+ allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
@@ -123,7 +131,7 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_);
// Test a bitrate which should be distributed equally.
- allocator_->OnNetworkChanged(500000, 0, 50);
+ allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs);
const uint32_t kBitrateToShare = 500000 - 200000 - 100000;
EXPECT_EQ(100000u + kBitrateToShare / 2,
bitrate_observer_1.last_bitrate_bps_);
@@ -132,14 +140,14 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
// Limited by 2x max bitrates since we leave room for FEC and
// retransmissions.
- allocator_->OnNetworkChanged(1500000, 0, 50);
+ allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_);
// Verify that if the bandwidth estimate is set to zero, the allocated
// rate is
// zero.
- allocator_->OnNetworkChanged(0, 0, 50);
+ allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
}
@@ -161,7 +169,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
protected:
BitrateAllocatorTestNoEnforceMin()
: allocator_(new BitrateAllocator(&limit_observer_)) {
- allocator_->OnNetworkChanged(300000u, 0, 0);
+ allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
}
~BitrateAllocatorTestNoEnforceMin() {}
@@ -180,11 +188,11 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// High BWE.
- allocator_->OnNetworkChanged(150000, 0, 0);
+ allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
// Low BWE.
- allocator_->OnNetworkChanged(10000, 0, 0);
+ allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
@@ -210,7 +218,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
// High BWE. Make sure the controllers get a fair share of the surplus (i.e.,
// what is left after each controller gets its min rate).
- allocator_->OnNetworkChanged(690000, 0, 0);
+ allocator_->OnNetworkChanged(690000, 0, 0, kDefaultProbingIntervalMs);
// Verify that each observer gets its min rate (sum of min rates is 600000),
// and that the remaining 90000 is divided equally among the three.
uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
@@ -222,27 +230,27 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
bitrate_observer_3.last_bitrate_bps_);
// BWE below the sum of observer's min bitrate.
- allocator_->OnNetworkChanged(300000, 0, 0);
+ allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate.
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate.
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
// Increased BWE, but still below the sum of configured min bitrates for all
// observers and too little for observer 3. 1 and 2 will share the rest.
- allocator_->OnNetworkChanged(500000, 0, 0);
+ allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split.
EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split.
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
// Below min for all.
- allocator_->OnNetworkChanged(10000, 0, 0);
+ allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
// Verify that zero estimated bandwidth, means that that all gets zero,
// regardless of set min bitrate.
- allocator_->OnNetworkChanged(0, 0, 0);
+ allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
@@ -262,34 +270,38 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
// High BWE.
- allocator_->OnNetworkChanged(150000, 0, 0);
+ allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
// Add loss and use a part of the bitrate for protection.
double protection_ratio = 0.4;
uint8_t fraction_loss = protection_ratio * 256;
bitrate_observer.SetBitrateProtectionRatio(protection_ratio);
- allocator_->OnNetworkChanged(200000, 0, fraction_loss);
+ allocator_->OnNetworkChanged(200000, 0, fraction_loss,
+ kDefaultProbingIntervalMs);
EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
// Above the min threshold, but not enough given the protection used.
- allocator_->OnNetworkChanged(139000, 0, fraction_loss);
+ allocator_->OnNetworkChanged(139000, 0, fraction_loss,
+ kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
// Verify the hysteresis is added for the protection.
- allocator_->OnNetworkChanged(150000, 0, fraction_loss);
+ allocator_->OnNetworkChanged(150000, 0, fraction_loss,
+ kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
// Just enough to enable video again.
- allocator_->OnNetworkChanged(168000, 0, fraction_loss);
+ allocator_->OnNetworkChanged(168000, 0, fraction_loss,
+ kDefaultProbingIntervalMs);
EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_);
// Remove all protection and make sure video is not paused as earlier.
bitrate_observer.SetBitrateProtectionRatio(0.0);
- allocator_->OnNetworkChanged(140000, 0, 0);
+ allocator_->OnNetworkChanged(140000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(139000, 0, 0);
+ allocator_->OnNetworkChanged(139000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
@@ -308,37 +320,37 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
// Enough bitrate for both.
bitrate_observer_2.SetBitrateProtectionRatio(0.5);
- allocator_->OnNetworkChanged(300000, 0, 0);
+ allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
// Above min for observer 2, but too little given the protection used.
- allocator_->OnNetworkChanged(330000, 0, 0);
+ allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
- allocator_->OnNetworkChanged(100000, 0, 0);
+ allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
- allocator_->OnNetworkChanged(99999, 0, 0);
+ allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
- allocator_->OnNetworkChanged(119000, 0, 0);
+ allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
- allocator_->OnNetworkChanged(120000, 0, 0);
+ allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
// Verify the protection is accounted for before resuming observer 2.
- allocator_->OnNetworkChanged(429000, 0, 0);
+ allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
- allocator_->OnNetworkChanged(430000, 0, 0);
+ allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);
@@ -365,7 +377,7 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
// Low BWE. Verify that all observers still get their respective min
// bitrate.
- allocator_->OnNetworkChanged(1000, 0, 0);
+ allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap.
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap.
EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap.
@@ -383,7 +395,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// Set network down, ie, no available bitrate.
- allocator_->OnNetworkChanged(0, 0, 0);
+ allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
@@ -399,7 +411,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
// Set network back up.
- allocator_->OnNetworkChanged(1500000, 0, 50);
+ allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);
}
@@ -414,31 +426,31 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(36000, 0, 50);
+ allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(35000, 0, 50);
+ allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(5000, 0, 50);
+ allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(36000, 0, 50);
+ allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(55000, 0, 50);
+ allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(56000, 0, 50);
+ allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(56000, 0, 50);
+ allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);
@@ -451,22 +463,22 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
allocator_->AddObserver(&observer, 30000, 300000, 0, false);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
- allocator_->OnNetworkChanged(30000, 0, 50);
+ allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(30000u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(20000, 0, 50);
+ allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(30000, 0, 50);
+ allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(49000, 0, 50);
+ allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(50000, 0, 50);
+ allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(50000u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(30000, 0, 50);
+ allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(30000u, observer.last_bitrate_bps_);
allocator_->RemoveObserver(&observer);
@@ -477,25 +489,36 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
allocator_->AddObserver(&observer, 300000, 600000, 0, false);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
- allocator_->OnNetworkChanged(300000, 0, 50);
+ allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(300000u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(200000, 0, 50);
+ allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(300000, 0, 50);
+ allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(329000, 0, 50);
+ allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(330000, 0, 50);
+ allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(330000u, observer.last_bitrate_bps_);
- allocator_->OnNetworkChanged(300000, 0, 50);
+ allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
EXPECT_EQ(300000u, observer.last_bitrate_bps_);
allocator_->RemoveObserver(&observer);
}
+TEST_F(BitrateAllocatorTest, PassProbingInterval) {
+ TestBitrateObserver observer;
+ allocator_->AddObserver(&observer, 300000, 600000, 0, false);
+ EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
+
+ allocator_->OnNetworkChanged(300000, 0, 50, 5000);
+ EXPECT_EQ(5000, observer.last_probing_interval_ms_);
+
+ allocator_->RemoveObserver(&observer);
+}
+
} // namespace webrtc
« no previous file with comments | « webrtc/call/bitrate_allocator.cc ('k') | webrtc/call/call.cc » ('j') | webrtc/modules/congestion_controller/include/congestion_controller.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698