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

Reland "Remove the injectable bitrate allocation strategy API."

Browse Source 
This is a reland of 80cb3f6db622442b6360e67851e8903aa0d06d03

Original change's description:
> Remove the injectable bitrate allocation strategy API.
>
> This removes PeerConnectionInterface::SetBitrateAllocationStrategy()
> plus a ton of now-dead code.
>
> Bug: webrtc:10556
> Change-Id: Icfae3bdd011588552934d9db4df16000847db7c3
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/133169
> Reviewed-by: Henrik Andreassson <henrika@webrtc.org>
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Sebastian Jansson <srte@webrtc.org>
> Commit-Queue: Jonas Olsson <jonasolsson@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#28523}

TBR=kwiberg@webrtc.org

Bug: webrtc:10556
Change-Id: Ic17a7a7cc447292306876ee9582ad62fd2499765
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/145900
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28585}
This commit is contained in:
Jonas Olsson
2019-07-09 12:31:20 +02:00
committed by Commit Bot
parent ea3dddf1d0
commit 0182a0300f
34 changed files with 81 additions and 847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
call/bitrate_allocator_unittest.cc
View File

@ -97,12 +97,11 @@ class BitrateAllocatorTest : public ::testing::Test {
uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
/* priority_bitrate */ 0, enforce_min_bitrate, track_id,
bitrate_priority});
observer,
{min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
/* priority_bitrate */ 0, enforce_min_bitrate, bitrate_priority});
}
MediaStreamAllocationConfig DefaultConfig() const {
MediaStreamAllocationConfig default_config;
@ -111,7 +110,6 @@ class BitrateAllocatorTest : public ::testing::Test {
default_config.pad_up_bitrate_bps = 0;
default_config.priority_bitrate_bps = 0;
default_config.enforce_min_bitrate = true;
default_config.track_id = "";
default_config.bitrate_priority = kDefaultBitratePriority;
return default_config;
}
@ -165,7 +163,7 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
kMaxBitrateBps));
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kDefaultBitratePriority);
kPadUpToBitrateBps, true, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
@ -178,14 +176,14 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true, "",
AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true,
kDefaultBitratePriority);
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true,
"", kDefaultBitratePriority);
kDefaultBitratePriority);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
@ -204,14 +202,14 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
limit_observer_,
OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps));
AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0,
true, "", kDefaultBitratePriority);
true, kDefaultBitratePriority);
EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
allocator_->GetStartBitrate(&bitrate_observer_1));
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
kObs1StartBitrateBps + kObs2StartBitrateBps,
0, kObs1MaxBitrateBps + kObs2MaxBitrateBps));
AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0,
true, "", kDefaultBitratePriority);
true, kDefaultBitratePriority);
EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
allocator_->GetStartBitrate(&bitrate_observer_2));
@ -260,7 +258,7 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
kMaxBitrateBps));
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kDefaultBitratePriority);
kPadUpToBitrateBps, true, kDefaultBitratePriority);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer);
}
@ -282,7 +280,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,
enforce_min_bitrate, track_id, bitrate_priority});
enforce_min_bitrate, bitrate_priority});
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocatorForTest> allocator_;
@ -534,16 +532,16 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3;
AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "",
AddObserver(&bitrate_observer_1, 100000, 400000, 0, true,
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "",
AddObserver(&bitrate_observer_2, 200000, 400000, 0, true,
kDefaultBitratePriority);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "",
AddObserver(&bitrate_observer_3, 300000, 400000, 0, true,
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
@ -565,7 +563,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_1;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _));
AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
AddObserver(&bitrate_observer_1, 50000, 400000, 0, true,
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
@ -577,7 +575,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_2;
// Adding an observer while the network is down should not affect the limits.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _));
AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
AddObserver(&bitrate_observer_2, 50000, 400000, 0, true,
kDefaultBitratePriority);
// Expect the start_bitrate to be set as if the network was still up but that
@ -594,12 +592,12 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TestBitrateObserver enforced_observer;
AddObserver(&enforced_observer, 6000, 30000, 0, true, "",
AddObserver(&enforced_observer, 6000, 30000, 0, true,
kDefaultBitratePriority);
EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
TestBitrateObserver not_enforced_observer;
AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "",
AddObserver(&not_enforced_observer, 30000, 2500000, 0, false,
kDefaultBitratePriority);
EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
@ -638,7 +636,7 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TestBitrateObserver observer;
AddObserver(&observer, 30000, 300000, 0, false, "", kDefaultBitratePriority);
AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
@ -664,7 +662,7 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TestBitrateObserver observer;
AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority);
AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
@ -690,7 +688,7 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TEST_F(BitrateAllocatorTest, PassProbingInterval) {
TestBitrateObserver observer;
AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority);
AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, 5000);
@ -705,8 +703,7 @@ TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 30;
AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, "",
2.0);
AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -724,9 +721,9 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 60;
AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
"low1", 2.0);
2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
"low2", 2.0);
2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -746,9 +743,9 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 60;
AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low1", 2.0);
2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low2", 2.0);
2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -768,9 +765,9 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2;
AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low", 2.0);
2.0);
AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"mid", 4.0);
4.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -787,8 +784,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
TestBitrateObserver observer_low;
TestBitrateObserver observer_mid;
AddObserver(&observer_low, 10, 50, 0, false, "low", 2.0);
AddObserver(&observer_mid, 10, 50, 0, false, "mid", 4.0);
AddObserver(&observer_low, 10, 50, 0, false, 2.0);
AddObserver(&observer_mid, 10, 50, 0, false, 4.0);
allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
@ -813,12 +810,9 @@ TEST_F(BitrateAllocatorTest,
const double kHighBitratePriority = 8.0;
const double kTotalBitratePriority =
kLowBitratePriority + kMidBitratePriority + kHighBitratePriority;
AddObserver(&observer_low, 0, kMaxBitrate, 0, false, "low",
kLowBitratePriority);
AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, "mid",
kMidBitratePriority);
AddObserver(&observer_high, 0, kMaxBitrate, 0, false, "high",
kHighBitratePriority);
AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority);
AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority);
AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -859,11 +853,11 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
const uint32_t kRemainingBitrate =
kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate);
AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false, "low",
AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false,
kLowBitratePriority);
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid",
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high",
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
@ -903,11 +897,11 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
// available bitrate, so 70 bps would be sufficient network bandwidth.
const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate;
AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false, "low",
AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false,
kLowBitratePriority);
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid",
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high",
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
@ -937,12 +931,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
TestBitrateObserver observer_low;
TestBitrateObserver observer_mid;
TestBitrateObserver observer_high;
AddObserver(&observer_low, 10, 40, 0, false, "low", 2.0);
AddObserver(&observer_low, 10, 40, 0, false, 2.0);
// Scaled allocation above the min allocation is the same for these two,
// meaning they will get allocated their max at the same time.
// Scaled (target allocation) = (max - min) / bitrate priority
AddObserver(&observer_mid, 10, 30, 0, false, "mid", 4.0);
AddObserver(&observer_high, 10, 50, 0, false, "high", 8.0);
AddObserver(&observer_mid, 10, 30, 0, false, 4.0);
AddObserver(&observer_high, 10, 50, 0, false, 8.0);
allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(30u, observer_low.last_bitrate_bps_);