OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 16 matching lines...) Expand all Loading... |
27 void(uint32_t min_send_bitrate_bps, | 27 void(uint32_t min_send_bitrate_bps, |
28 uint32_t max_padding_bitrate_bps)); | 28 uint32_t max_padding_bitrate_bps)); |
29 }; | 29 }; |
30 | 30 |
31 class TestBitrateObserver : public BitrateAllocatorObserver { | 31 class TestBitrateObserver : public BitrateAllocatorObserver { |
32 public: | 32 public: |
33 TestBitrateObserver() | 33 TestBitrateObserver() |
34 : last_bitrate_bps_(0), | 34 : last_bitrate_bps_(0), |
35 last_fraction_loss_(0), | 35 last_fraction_loss_(0), |
36 last_rtt_ms_(0), | 36 last_rtt_ms_(0), |
| 37 last_probing_interval_ms_(0), |
37 protection_ratio_(0.0) {} | 38 protection_ratio_(0.0) {} |
38 | 39 |
39 void SetBitrateProtectionRatio(double protection_ratio) { | 40 void SetBitrateProtectionRatio(double protection_ratio) { |
40 protection_ratio_ = protection_ratio; | 41 protection_ratio_ = protection_ratio; |
41 } | 42 } |
42 | 43 |
43 uint32_t OnBitrateUpdated(uint32_t bitrate_bps, | 44 uint32_t OnBitrateUpdated(uint32_t bitrate_bps, |
44 uint8_t fraction_loss, | 45 uint8_t fraction_loss, |
45 int64_t rtt) override { | 46 int64_t rtt, |
| 47 int64_t probing_interval_ms) override { |
46 last_bitrate_bps_ = bitrate_bps; | 48 last_bitrate_bps_ = bitrate_bps; |
47 last_fraction_loss_ = fraction_loss; | 49 last_fraction_loss_ = fraction_loss; |
48 last_rtt_ms_ = rtt; | 50 last_rtt_ms_ = rtt; |
| 51 last_probing_interval_ms_ = probing_interval_ms; |
49 return bitrate_bps * protection_ratio_; | 52 return bitrate_bps * protection_ratio_; |
50 } | 53 } |
51 uint32_t last_bitrate_bps_; | 54 uint32_t last_bitrate_bps_; |
52 uint8_t last_fraction_loss_; | 55 uint8_t last_fraction_loss_; |
53 int64_t last_rtt_ms_; | 56 int64_t last_rtt_ms_; |
| 57 int last_probing_interval_ms_; |
54 double protection_ratio_; | 58 double protection_ratio_; |
55 }; | 59 }; |
56 | 60 |
| 61 namespace { |
| 62 constexpr int64_t kDefaultProbingIntervalMs = 3000; |
| 63 } |
| 64 |
57 class BitrateAllocatorTest : public ::testing::Test { | 65 class BitrateAllocatorTest : public ::testing::Test { |
58 protected: | 66 protected: |
59 BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) { | 67 BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) { |
60 allocator_->OnNetworkChanged(300000u, 0, 0); | 68 allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); |
61 } | 69 } |
62 ~BitrateAllocatorTest() {} | 70 ~BitrateAllocatorTest() {} |
63 | 71 |
64 NiceMock<MockLimitObserver> limit_observer_; | 72 NiceMock<MockLimitObserver> limit_observer_; |
65 std::unique_ptr<BitrateAllocator> allocator_; | 73 std::unique_ptr<BitrateAllocator> allocator_; |
66 }; | 74 }; |
67 | 75 |
68 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { | 76 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
69 TestBitrateObserver bitrate_observer; | 77 TestBitrateObserver bitrate_observer; |
70 const uint32_t kMinSendBitrateBps = 100000; | 78 const uint32_t kMinSendBitrateBps = 100000; |
71 const uint32_t kPadUpToBitrateBps = 50000; | 79 const uint32_t kPadUpToBitrateBps = 50000; |
72 | 80 |
73 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, | 81 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, |
74 kPadUpToBitrateBps)); | 82 kPadUpToBitrateBps)); |
75 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, | 83 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, |
76 kPadUpToBitrateBps, true); | 84 kPadUpToBitrateBps, true); |
77 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); | 85 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); |
78 allocator_->OnNetworkChanged(200000, 0, 0); | 86 allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs); |
79 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); | 87 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); |
80 | 88 |
81 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max | 89 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max |
82 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). | 90 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). |
83 allocator_->OnNetworkChanged(4000000, 0, 0); | 91 allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs); |
84 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); | 92 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); |
85 | 93 |
86 // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. | 94 // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. |
87 EXPECT_CALL(limit_observer_, | 95 EXPECT_CALL(limit_observer_, |
88 OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); | 96 OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); |
89 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, | 97 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, |
90 true); | 98 true); |
91 EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); | 99 EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); |
92 | 100 |
93 EXPECT_CALL(limit_observer_, | 101 EXPECT_CALL(limit_observer_, |
94 OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); | 102 OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); |
95 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, | 103 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, |
96 true); | 104 true); |
97 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); | 105 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); |
98 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); | 106 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
99 allocator_->OnNetworkChanged(1500000, 0, 0); | 107 allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs); |
100 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); | 108 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); |
101 } | 109 } |
102 | 110 |
103 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { | 111 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
104 TestBitrateObserver bitrate_observer_1; | 112 TestBitrateObserver bitrate_observer_1; |
105 TestBitrateObserver bitrate_observer_2; | 113 TestBitrateObserver bitrate_observer_2; |
106 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0)); | 114 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0)); |
107 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true); | 115 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true); |
108 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 116 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
109 EXPECT_CALL(limit_observer_, | 117 EXPECT_CALL(limit_observer_, |
110 OnAllocationLimitsChanged(100000 + 200000, 0)); | 118 OnAllocationLimitsChanged(100000 + 200000, 0)); |
111 allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true); | 119 allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true); |
112 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); | 120 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
113 | 121 |
114 // Test too low start bitrate, hence lower than sum of min. Min bitrates | 122 // Test too low start bitrate, hence lower than sum of min. Min bitrates |
115 // will | 123 // will |
116 // be allocated to all observers. | 124 // be allocated to all observers. |
117 allocator_->OnNetworkChanged(200000, 0, 50); | 125 allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); |
118 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 126 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
119 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); | 127 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); |
120 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); | 128 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); |
121 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); | 129 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
122 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); | 130 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
123 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); | 131 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); |
124 | 132 |
125 // Test a bitrate which should be distributed equally. | 133 // Test a bitrate which should be distributed equally. |
126 allocator_->OnNetworkChanged(500000, 0, 50); | 134 allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs); |
127 const uint32_t kBitrateToShare = 500000 - 200000 - 100000; | 135 const uint32_t kBitrateToShare = 500000 - 200000 - 100000; |
128 EXPECT_EQ(100000u + kBitrateToShare / 2, | 136 EXPECT_EQ(100000u + kBitrateToShare / 2, |
129 bitrate_observer_1.last_bitrate_bps_); | 137 bitrate_observer_1.last_bitrate_bps_); |
130 EXPECT_EQ(200000u + kBitrateToShare / 2, | 138 EXPECT_EQ(200000u + kBitrateToShare / 2, |
131 bitrate_observer_2.last_bitrate_bps_); | 139 bitrate_observer_2.last_bitrate_bps_); |
132 | 140 |
133 // Limited by 2x max bitrates since we leave room for FEC and | 141 // Limited by 2x max bitrates since we leave room for FEC and |
134 // retransmissions. | 142 // retransmissions. |
135 allocator_->OnNetworkChanged(1500000, 0, 50); | 143 allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); |
136 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_); | 144 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_); |
137 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_); | 145 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_); |
138 | 146 |
139 // Verify that if the bandwidth estimate is set to zero, the allocated | 147 // Verify that if the bandwidth estimate is set to zero, the allocated |
140 // rate is | 148 // rate is |
141 // zero. | 149 // zero. |
142 allocator_->OnNetworkChanged(0, 0, 50); | 150 allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs); |
143 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 151 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
144 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 152 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
145 } | 153 } |
146 | 154 |
147 TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) { | 155 TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) { |
148 TestBitrateObserver bitrate_observer; | 156 TestBitrateObserver bitrate_observer; |
149 const uint32_t kMinSendBitrateBps = 100000; | 157 const uint32_t kMinSendBitrateBps = 100000; |
150 const uint32_t kPadUpToBitrateBps = 50000; | 158 const uint32_t kPadUpToBitrateBps = 50000; |
151 | 159 |
152 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, | 160 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, |
153 kPadUpToBitrateBps)); | 161 kPadUpToBitrateBps)); |
154 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, | 162 allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, |
155 kPadUpToBitrateBps, true); | 163 kPadUpToBitrateBps, true); |
156 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); | 164 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
157 allocator_->RemoveObserver(&bitrate_observer); | 165 allocator_->RemoveObserver(&bitrate_observer); |
158 } | 166 } |
159 | 167 |
160 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { | 168 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
161 protected: | 169 protected: |
162 BitrateAllocatorTestNoEnforceMin() | 170 BitrateAllocatorTestNoEnforceMin() |
163 : allocator_(new BitrateAllocator(&limit_observer_)) { | 171 : allocator_(new BitrateAllocator(&limit_observer_)) { |
164 allocator_->OnNetworkChanged(300000u, 0, 0); | 172 allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); |
165 } | 173 } |
166 ~BitrateAllocatorTestNoEnforceMin() {} | 174 ~BitrateAllocatorTestNoEnforceMin() {} |
167 | 175 |
168 NiceMock<MockLimitObserver> limit_observer_; | 176 NiceMock<MockLimitObserver> limit_observer_; |
169 std::unique_ptr<BitrateAllocator> allocator_; | 177 std::unique_ptr<BitrateAllocator> allocator_; |
170 }; | 178 }; |
171 | 179 |
172 // The following three tests verify enforcing a minimum bitrate works as | 180 // The following three tests verify enforcing a minimum bitrate works as |
173 // intended. | 181 // intended. |
174 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { | 182 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
175 TestBitrateObserver bitrate_observer_1; | 183 TestBitrateObserver bitrate_observer_1; |
176 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since | 184 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since |
177 // AddObserver is called with |enforce_min_bitrate| = false. | 185 // AddObserver is called with |enforce_min_bitrate| = false. |
178 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); | 186 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
179 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); | 187 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); |
180 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 188 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
181 | 189 |
182 // High BWE. | 190 // High BWE. |
183 allocator_->OnNetworkChanged(150000, 0, 0); | 191 allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); |
184 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); | 192 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); |
185 | 193 |
186 // Low BWE. | 194 // Low BWE. |
187 allocator_->OnNetworkChanged(10000, 0, 0); | 195 allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); |
188 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 196 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
189 | 197 |
190 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); | 198 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
191 allocator_->RemoveObserver(&bitrate_observer_1); | 199 allocator_->RemoveObserver(&bitrate_observer_1); |
192 } | 200 } |
193 | 201 |
194 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { | 202 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
195 TestBitrateObserver bitrate_observer_1; | 203 TestBitrateObserver bitrate_observer_1; |
196 TestBitrateObserver bitrate_observer_2; | 204 TestBitrateObserver bitrate_observer_2; |
197 TestBitrateObserver bitrate_observer_3; | 205 TestBitrateObserver bitrate_observer_3; |
198 // Set up the observers with min bitrates at 100000, 200000, and 300000. | 206 // Set up the observers with min bitrates at 100000, 200000, and 300000. |
199 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); | 207 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); |
200 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 208 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
201 | 209 |
202 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); | 210 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); |
203 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); | 211 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
204 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 212 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
205 | 213 |
206 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false); | 214 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false); |
207 EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3)); | 215 EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3)); |
208 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 216 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
209 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); | 217 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
210 | 218 |
211 // High BWE. Make sure the controllers get a fair share of the surplus (i.e., | 219 // High BWE. Make sure the controllers get a fair share of the surplus (i.e., |
212 // what is left after each controller gets its min rate). | 220 // what is left after each controller gets its min rate). |
213 allocator_->OnNetworkChanged(690000, 0, 0); | 221 allocator_->OnNetworkChanged(690000, 0, 0, kDefaultProbingIntervalMs); |
214 // Verify that each observer gets its min rate (sum of min rates is 600000), | 222 // Verify that each observer gets its min rate (sum of min rates is 600000), |
215 // and that the remaining 90000 is divided equally among the three. | 223 // and that the remaining 90000 is divided equally among the three. |
216 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; | 224 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; |
217 EXPECT_EQ(100000u + bitrate_to_share / 3, | 225 EXPECT_EQ(100000u + bitrate_to_share / 3, |
218 bitrate_observer_1.last_bitrate_bps_); | 226 bitrate_observer_1.last_bitrate_bps_); |
219 EXPECT_EQ(200000u + bitrate_to_share / 3, | 227 EXPECT_EQ(200000u + bitrate_to_share / 3, |
220 bitrate_observer_2.last_bitrate_bps_); | 228 bitrate_observer_2.last_bitrate_bps_); |
221 EXPECT_EQ(300000u + bitrate_to_share / 3, | 229 EXPECT_EQ(300000u + bitrate_to_share / 3, |
222 bitrate_observer_3.last_bitrate_bps_); | 230 bitrate_observer_3.last_bitrate_bps_); |
223 | 231 |
224 // BWE below the sum of observer's min bitrate. | 232 // BWE below the sum of observer's min bitrate. |
225 allocator_->OnNetworkChanged(300000, 0, 0); | 233 allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); |
226 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate. | 234 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate. |
227 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate. | 235 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate. |
228 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. | 236 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
229 | 237 |
230 // Increased BWE, but still below the sum of configured min bitrates for all | 238 // Increased BWE, but still below the sum of configured min bitrates for all |
231 // observers and too little for observer 3. 1 and 2 will share the rest. | 239 // observers and too little for observer 3. 1 and 2 will share the rest. |
232 allocator_->OnNetworkChanged(500000, 0, 0); | 240 allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs); |
233 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split. | 241 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split. |
234 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split. | 242 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split. |
235 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. | 243 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
236 | 244 |
237 // Below min for all. | 245 // Below min for all. |
238 allocator_->OnNetworkChanged(10000, 0, 0); | 246 allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); |
239 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 247 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
240 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 248 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
241 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); | 249 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
242 | 250 |
243 // Verify that zero estimated bandwidth, means that that all gets zero, | 251 // Verify that zero estimated bandwidth, means that that all gets zero, |
244 // regardless of set min bitrate. | 252 // regardless of set min bitrate. |
245 allocator_->OnNetworkChanged(0, 0, 0); | 253 allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); |
246 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 254 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
247 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 255 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
248 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); | 256 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
249 | 257 |
250 allocator_->RemoveObserver(&bitrate_observer_1); | 258 allocator_->RemoveObserver(&bitrate_observer_1); |
251 allocator_->RemoveObserver(&bitrate_observer_2); | 259 allocator_->RemoveObserver(&bitrate_observer_2); |
252 allocator_->RemoveObserver(&bitrate_observer_3); | 260 allocator_->RemoveObserver(&bitrate_observer_3); |
253 } | 261 } |
254 | 262 |
255 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { | 263 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { |
256 TestBitrateObserver bitrate_observer; | 264 TestBitrateObserver bitrate_observer; |
257 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since | 265 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since |
258 // AddObserver is called with |enforce_min_bitrate| = false. | 266 // AddObserver is called with |enforce_min_bitrate| = false. |
259 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); | 267 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
260 allocator_->AddObserver( | 268 allocator_->AddObserver( |
261 &bitrate_observer, 100000, 400000, 0, false); | 269 &bitrate_observer, 100000, 400000, 0, false); |
262 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); | 270 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); |
263 | 271 |
264 // High BWE. | 272 // High BWE. |
265 allocator_->OnNetworkChanged(150000, 0, 0); | 273 allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); |
266 EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_); | 274 EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_); |
267 | 275 |
268 // Add loss and use a part of the bitrate for protection. | 276 // Add loss and use a part of the bitrate for protection. |
269 double protection_ratio = 0.4; | 277 double protection_ratio = 0.4; |
270 uint8_t fraction_loss = protection_ratio * 256; | 278 uint8_t fraction_loss = protection_ratio * 256; |
271 bitrate_observer.SetBitrateProtectionRatio(protection_ratio); | 279 bitrate_observer.SetBitrateProtectionRatio(protection_ratio); |
272 allocator_->OnNetworkChanged(200000, 0, fraction_loss); | 280 allocator_->OnNetworkChanged(200000, 0, fraction_loss, |
| 281 kDefaultProbingIntervalMs); |
273 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); | 282 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); |
274 | 283 |
275 // Above the min threshold, but not enough given the protection used. | 284 // Above the min threshold, but not enough given the protection used. |
276 allocator_->OnNetworkChanged(139000, 0, fraction_loss); | 285 allocator_->OnNetworkChanged(139000, 0, fraction_loss, |
| 286 kDefaultProbingIntervalMs); |
277 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); | 287 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); |
278 | 288 |
279 // Verify the hysteresis is added for the protection. | 289 // Verify the hysteresis is added for the protection. |
280 allocator_->OnNetworkChanged(150000, 0, fraction_loss); | 290 allocator_->OnNetworkChanged(150000, 0, fraction_loss, |
| 291 kDefaultProbingIntervalMs); |
281 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); | 292 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); |
282 | 293 |
283 // Just enough to enable video again. | 294 // Just enough to enable video again. |
284 allocator_->OnNetworkChanged(168000, 0, fraction_loss); | 295 allocator_->OnNetworkChanged(168000, 0, fraction_loss, |
| 296 kDefaultProbingIntervalMs); |
285 EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_); | 297 EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_); |
286 | 298 |
287 // Remove all protection and make sure video is not paused as earlier. | 299 // Remove all protection and make sure video is not paused as earlier. |
288 bitrate_observer.SetBitrateProtectionRatio(0.0); | 300 bitrate_observer.SetBitrateProtectionRatio(0.0); |
289 allocator_->OnNetworkChanged(140000, 0, 0); | 301 allocator_->OnNetworkChanged(140000, 0, 0, kDefaultProbingIntervalMs); |
290 EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_); | 302 EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_); |
291 | 303 |
292 allocator_->OnNetworkChanged(139000, 0, 0); | 304 allocator_->OnNetworkChanged(139000, 0, 0, kDefaultProbingIntervalMs); |
293 EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_); | 305 EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_); |
294 | 306 |
295 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); | 307 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
296 allocator_->RemoveObserver(&bitrate_observer); | 308 allocator_->RemoveObserver(&bitrate_observer); |
297 } | 309 } |
298 | 310 |
299 TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { | 311 TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { |
300 TestBitrateObserver bitrate_observer_1; | 312 TestBitrateObserver bitrate_observer_1; |
301 TestBitrateObserver bitrate_observer_2; | 313 TestBitrateObserver bitrate_observer_2; |
302 | 314 |
303 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); | 315 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); |
304 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 316 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
305 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); | 317 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); |
306 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); | 318 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
307 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 319 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
308 | 320 |
309 // Enough bitrate for both. | 321 // Enough bitrate for both. |
310 bitrate_observer_2.SetBitrateProtectionRatio(0.5); | 322 bitrate_observer_2.SetBitrateProtectionRatio(0.5); |
311 allocator_->OnNetworkChanged(300000, 0, 0); | 323 allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); |
312 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 324 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
313 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); | 325 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
314 | 326 |
315 // Above min for observer 2, but too little given the protection used. | 327 // Above min for observer 2, but too little given the protection used. |
316 allocator_->OnNetworkChanged(330000, 0, 0); | 328 allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs); |
317 EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_); | 329 EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_); |
318 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 330 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
319 | 331 |
320 allocator_->OnNetworkChanged(100000, 0, 0); | 332 allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs); |
321 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 333 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
322 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 334 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
323 | 335 |
324 allocator_->OnNetworkChanged(99999, 0, 0); | 336 allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs); |
325 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 337 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
326 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 338 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
327 | 339 |
328 allocator_->OnNetworkChanged(119000, 0, 0); | 340 allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs); |
329 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 341 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
330 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 342 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
331 | 343 |
332 allocator_->OnNetworkChanged(120000, 0, 0); | 344 allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs); |
333 EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_); | 345 EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_); |
334 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 346 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
335 | 347 |
336 // Verify the protection is accounted for before resuming observer 2. | 348 // Verify the protection is accounted for before resuming observer 2. |
337 allocator_->OnNetworkChanged(429000, 0, 0); | 349 allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs); |
338 EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_); | 350 EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_); |
339 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 351 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
340 | 352 |
341 allocator_->OnNetworkChanged(430000, 0, 0); | 353 allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs); |
342 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 354 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
343 EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_); | 355 EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_); |
344 | 356 |
345 allocator_->RemoveObserver(&bitrate_observer_1); | 357 allocator_->RemoveObserver(&bitrate_observer_1); |
346 allocator_->RemoveObserver(&bitrate_observer_2); | 358 allocator_->RemoveObserver(&bitrate_observer_2); |
347 } | 359 } |
348 | 360 |
349 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { | 361 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { |
350 TestBitrateObserver bitrate_observer_1; | 362 TestBitrateObserver bitrate_observer_1; |
351 TestBitrateObserver bitrate_observer_2; | 363 TestBitrateObserver bitrate_observer_2; |
352 TestBitrateObserver bitrate_observer_3; | 364 TestBitrateObserver bitrate_observer_3; |
353 | 365 |
354 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true); | 366 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true); |
355 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 367 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
356 | 368 |
357 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true); | 369 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true); |
358 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); | 370 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
359 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); | 371 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
360 | 372 |
361 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true); | 373 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true); |
362 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3)); | 374 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3)); |
363 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); | 375 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); |
364 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); | 376 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); |
365 | 377 |
366 // Low BWE. Verify that all observers still get their respective min | 378 // Low BWE. Verify that all observers still get their respective min |
367 // bitrate. | 379 // bitrate. |
368 allocator_->OnNetworkChanged(1000, 0, 0); | 380 allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs); |
369 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap. | 381 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap. |
370 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap. | 382 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap. |
371 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap. | 383 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap. |
372 | 384 |
373 allocator_->RemoveObserver(&bitrate_observer_1); | 385 allocator_->RemoveObserver(&bitrate_observer_1); |
374 allocator_->RemoveObserver(&bitrate_observer_2); | 386 allocator_->RemoveObserver(&bitrate_observer_2); |
375 allocator_->RemoveObserver(&bitrate_observer_3); | 387 allocator_->RemoveObserver(&bitrate_observer_3); |
376 } | 388 } |
377 | 389 |
378 TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { | 390 TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { |
379 TestBitrateObserver bitrate_observer_1; | 391 TestBitrateObserver bitrate_observer_1; |
380 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0)); | 392 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0)); |
381 | 393 |
382 allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true); | 394 allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true); |
383 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); | 395 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
384 | 396 |
385 // Set network down, ie, no available bitrate. | 397 // Set network down, ie, no available bitrate. |
386 allocator_->OnNetworkChanged(0, 0, 0); | 398 allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); |
387 | 399 |
388 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 400 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
389 | 401 |
390 TestBitrateObserver bitrate_observer_2; | 402 TestBitrateObserver bitrate_observer_2; |
391 // Adding an observer while the network is down should not affect the limits. | 403 // Adding an observer while the network is down should not affect the limits. |
392 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0)); | 404 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0)); |
393 allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true); | 405 allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true); |
394 | 406 |
395 // Expect the start_bitrate to be set as if the network was still up but that | 407 // Expect the start_bitrate to be set as if the network was still up but that |
396 // the new observer have been notified that the network is down. | 408 // the new observer have been notified that the network is down. |
397 EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2)); | 409 EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2)); |
398 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); | 410 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
399 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); | 411 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
400 | 412 |
401 // Set network back up. | 413 // Set network back up. |
402 allocator_->OnNetworkChanged(1500000, 0, 50); | 414 allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); |
403 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); | 415 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); |
404 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); | 416 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); |
405 } | 417 } |
406 | 418 |
407 TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { | 419 TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { |
408 TestBitrateObserver enforced_observer; | 420 TestBitrateObserver enforced_observer; |
409 allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true); | 421 allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true); |
410 EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer)); | 422 EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer)); |
411 | 423 |
412 TestBitrateObserver not_enforced_observer; | 424 TestBitrateObserver not_enforced_observer; |
413 allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, 0, false); | 425 allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, 0, false); |
414 EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer)); | 426 EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer)); |
415 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); | 427 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
416 | 428 |
417 allocator_->OnNetworkChanged(36000, 0, 50); | 429 allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); |
418 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); | 430 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
419 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); | 431 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); |
420 | 432 |
421 allocator_->OnNetworkChanged(35000, 0, 50); | 433 allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs); |
422 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); | 434 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
423 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); | 435 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
424 | 436 |
425 allocator_->OnNetworkChanged(5000, 0, 50); | 437 allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs); |
426 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); | 438 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
427 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); | 439 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
428 | 440 |
429 allocator_->OnNetworkChanged(36000, 0, 50); | 441 allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); |
430 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); | 442 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
431 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); | 443 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
432 | 444 |
433 allocator_->OnNetworkChanged(55000, 0, 50); | 445 allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs); |
434 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); | 446 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
435 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); | 447 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
436 | 448 |
437 allocator_->OnNetworkChanged(56000, 0, 50); | 449 allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); |
438 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); | 450 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
439 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); | 451 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); |
440 | 452 |
441 allocator_->OnNetworkChanged(56000, 0, 50); | 453 allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); |
442 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); | 454 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); |
443 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); | 455 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); |
444 | 456 |
445 allocator_->RemoveObserver(&enforced_observer); | 457 allocator_->RemoveObserver(&enforced_observer); |
446 allocator_->RemoveObserver(¬_enforced_observer); | 458 allocator_->RemoveObserver(¬_enforced_observer); |
447 } | 459 } |
448 | 460 |
449 TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { | 461 TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { |
450 TestBitrateObserver observer; | 462 TestBitrateObserver observer; |
451 allocator_->AddObserver(&observer, 30000, 300000, 0, false); | 463 allocator_->AddObserver(&observer, 30000, 300000, 0, false); |
452 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); | 464 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
453 | 465 |
454 allocator_->OnNetworkChanged(30000, 0, 50); | 466 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
455 EXPECT_EQ(30000u, observer.last_bitrate_bps_); | 467 EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
456 | 468 |
457 allocator_->OnNetworkChanged(20000, 0, 50); | 469 allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs); |
458 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 470 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
459 | 471 |
460 allocator_->OnNetworkChanged(30000, 0, 50); | 472 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
461 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 473 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
462 | 474 |
463 allocator_->OnNetworkChanged(49000, 0, 50); | 475 allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs); |
464 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 476 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
465 | 477 |
466 allocator_->OnNetworkChanged(50000, 0, 50); | 478 allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs); |
467 EXPECT_EQ(50000u, observer.last_bitrate_bps_); | 479 EXPECT_EQ(50000u, observer.last_bitrate_bps_); |
468 | 480 |
469 allocator_->OnNetworkChanged(30000, 0, 50); | 481 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
470 EXPECT_EQ(30000u, observer.last_bitrate_bps_); | 482 EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
471 | 483 |
472 allocator_->RemoveObserver(&observer); | 484 allocator_->RemoveObserver(&observer); |
473 } | 485 } |
474 | 486 |
475 TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { | 487 TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { |
476 TestBitrateObserver observer; | 488 TestBitrateObserver observer; |
477 allocator_->AddObserver(&observer, 300000, 600000, 0, false); | 489 allocator_->AddObserver(&observer, 300000, 600000, 0, false); |
478 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); | 490 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
479 | 491 |
480 allocator_->OnNetworkChanged(300000, 0, 50); | 492 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
481 EXPECT_EQ(300000u, observer.last_bitrate_bps_); | 493 EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
482 | 494 |
483 allocator_->OnNetworkChanged(200000, 0, 50); | 495 allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); |
484 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 496 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
485 | 497 |
486 allocator_->OnNetworkChanged(300000, 0, 50); | 498 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
487 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 499 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
488 | 500 |
489 allocator_->OnNetworkChanged(329000, 0, 50); | 501 allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs); |
490 EXPECT_EQ(0u, observer.last_bitrate_bps_); | 502 EXPECT_EQ(0u, observer.last_bitrate_bps_); |
491 | 503 |
492 allocator_->OnNetworkChanged(330000, 0, 50); | 504 allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs); |
493 EXPECT_EQ(330000u, observer.last_bitrate_bps_); | 505 EXPECT_EQ(330000u, observer.last_bitrate_bps_); |
494 | 506 |
495 allocator_->OnNetworkChanged(300000, 0, 50); | 507 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
496 EXPECT_EQ(300000u, observer.last_bitrate_bps_); | 508 EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
497 | 509 |
498 allocator_->RemoveObserver(&observer); | 510 allocator_->RemoveObserver(&observer); |
499 } | 511 } |
500 | 512 |
| 513 TEST_F(BitrateAllocatorTest, PassProbingInterval) { |
| 514 TestBitrateObserver observer; |
| 515 allocator_->AddObserver(&observer, 300000, 600000, 0, false); |
| 516 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
| 517 |
| 518 allocator_->OnNetworkChanged(300000, 0, 50, 5000); |
| 519 EXPECT_EQ(5000, observer.last_probing_interval_ms_); |
| 520 |
| 521 allocator_->OnNetworkChanged(300000, 0, 50, 8000); |
| 522 EXPECT_EQ(8000, observer.last_probing_interval_ms_); |
| 523 |
| 524 allocator_->RemoveObserver(&observer); |
| 525 } |
| 526 |
501 } // namespace webrtc | 527 } // namespace webrtc |
OLD | NEW |