| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/base/network_throttle_manager_impl.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/callback.h" | |
| 11 #include "base/callback_helpers.h" | |
| 12 #include "base/memory/scoped_vector.h" | |
| 13 #include "base/run_loop.h" | |
| 14 #include "base/test/simple_test_tick_clock.h" | |
| 15 #include "base/test/test_message_loop.h" | |
| 16 #include "net/base/request_priority.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 namespace net { | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 | |
| 25 const int kInitialAgeHorizonForUncountedRequests = | |
| 26 (NetworkThrottleManagerImpl::kInitialMedianInMs * | |
| 27 NetworkThrottleManagerImpl::kMedianLifetimeMultiple); | |
| 28 | |
| 29 // Must be greater than the corresponding fudge factor in | |
| 30 // network_throttle_manager_impl.cc. | |
| 31 const int kAgeHorizonFudgeFactor = 20; | |
| 32 | |
| 33 // Test fixture for throttle manager tests. | |
| 34 | |
| 35 // Note that the manager owned and managed by this fixture has a clock | |
| 36 // that is set to base::TimeTicks::Now() (which value is also exposed | |
| 37 // via an accessor) on creation but does not change without | |
| 38 // intervention by tests (to make the tests more predictable). | |
| 39 // | |
| 40 // HOWEVER, also note that that manager uses the base::Timer class, which | |
| 41 // uses the system clock, which isn't affected by the setting of the | |
| 42 // test fixture clock. So test should be written to a) avoid situations | |
| 43 // in which the manager's timer will actually go off based on the system | |
| 44 // clock, and b) call ConditionallyTriggerTimerForTesting() (which does | |
| 45 // evaluate the manager's clock) when timer based tests are necessary. | |
| 46 class NetworkThrottleManagerTest : public testing::Test, | |
| 47 NetworkThrottleManager::ThrottleDelegate { | |
| 48 public: | |
| 49 NetworkThrottleManagerTest() | |
| 50 : clock_(new base::SimpleTestTickClock), | |
| 51 now_(base::TimeTicks::Now()), | |
| 52 throttle_state_change_count_(0), | |
| 53 last_throttle_to_change_state_(nullptr), | |
| 54 throttle_manager_(new NetworkThrottleManagerImpl) { | |
| 55 clock_->SetNowTicks(now_); | |
| 56 throttle_manager_->SetTickClockForTesting( | |
| 57 std::unique_ptr<base::TickClock>(clock_)); | |
| 58 } | |
| 59 | |
| 60 protected: | |
| 61 enum ExpectedThrottleBlockState { BLOCKED, UNBLOCKED }; | |
| 62 | |
| 63 base::TimeTicks now() { return now_; } | |
| 64 NetworkThrottleManagerImpl* throttle_manager() { | |
| 65 return throttle_manager_.get(); | |
| 66 } | |
| 67 | |
| 68 // Set the offset of the test clock from now_. | |
| 69 void SetClockDelta(base::TimeDelta time_delta) { | |
| 70 clock_->SetNowTicks(now_ + time_delta); | |
| 71 } | |
| 72 | |
| 73 // Throttle creation | |
| 74 std::unique_ptr<NetworkThrottleManager::Throttle> CreateThrottle( | |
| 75 net::RequestPriority priority, | |
| 76 ExpectedThrottleBlockState throttle_state) { | |
| 77 std::unique_ptr<NetworkThrottleManager::Throttle> throttle( | |
| 78 throttle_manager_->CreateThrottle(this, priority, false)); | |
| 79 EXPECT_EQ(throttle_state == BLOCKED, throttle->IsBlocked()); | |
| 80 return throttle; | |
| 81 } | |
| 82 std::unique_ptr<NetworkThrottleManager::Throttle> | |
| 83 CreateThrottleIgnoringLimits(net::RequestPriority priority) { | |
| 84 std::unique_ptr<NetworkThrottleManager::Throttle> throttle( | |
| 85 throttle_manager_->CreateThrottle(this, priority, true)); | |
| 86 EXPECT_FALSE(throttle->IsBlocked()); | |
| 87 return throttle; | |
| 88 } | |
| 89 | |
| 90 // Throttle state change information. | |
| 91 int throttle_state_change_count() { return throttle_state_change_count_; } | |
| 92 NetworkThrottleManager::Throttle* last_throttle_to_change_state() { | |
| 93 return last_throttle_to_change_state_; | |
| 94 } | |
| 95 | |
| 96 // Setting a callback to be invoked when a throttle's state changes. | |
| 97 void SetThrottleStateChangedCallback(const base::Closure& callback) { | |
| 98 throttle_state_changed_callback_ = callback; | |
| 99 } | |
| 100 | |
| 101 private: | |
| 102 // NetworkThrottleManager::Delegate | |
| 103 void OnThrottleUnblocked( | |
| 104 NetworkThrottleManager::Throttle* throttle) override { | |
| 105 ++throttle_state_change_count_; | |
| 106 last_throttle_to_change_state_ = throttle; | |
| 107 if (!throttle_state_changed_callback_.is_null()) | |
| 108 base::ResetAndReturn(&throttle_state_changed_callback_).Run(); | |
| 109 } | |
| 110 | |
| 111 base::SimpleTestTickClock* clock_; | |
| 112 base::TimeTicks now_; | |
| 113 int throttle_state_change_count_; | |
| 114 NetworkThrottleManager::Throttle* last_throttle_to_change_state_; | |
| 115 std::unique_ptr<NetworkThrottleManagerImpl> throttle_manager_; | |
| 116 base::Closure throttle_state_changed_callback_; | |
| 117 | |
| 118 DISALLOW_COPY_AND_ASSIGN(NetworkThrottleManagerTest); | |
| 119 }; | |
| 120 | |
| 121 // Check to confirm that all created throttles at priorities other than | |
| 122 // THROTTLED start unblocked. | |
| 123 TEST_F(NetworkThrottleManagerTest, AllUnthrottled) { | |
| 124 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { | |
| 125 if (i == THROTTLED) | |
| 126 continue; | |
| 127 CreateThrottle(static_cast<RequestPriority>(i), UNBLOCKED); | |
| 128 } | |
| 129 } | |
| 130 | |
| 131 // Check for basic semantics around the new THROTTLED level. | |
| 132 TEST_F(NetworkThrottleManagerTest, ThrottledBlocking) { | |
| 133 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 134 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 135 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 136 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 137 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 138 CreateThrottle(THROTTLED, BLOCKED)); | |
| 139 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 140 CreateThrottle(THROTTLED, BLOCKED)); | |
| 141 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 142 CreateThrottle(THROTTLED, BLOCKED)); | |
| 143 | |
| 144 EXPECT_EQ(0, throttle_state_change_count()); | |
| 145 | |
| 146 throttle1.reset(); | |
| 147 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 148 EXPECT_EQ(1, throttle_state_change_count()); | |
| 149 EXPECT_EQ(throttle3.get(), last_throttle_to_change_state()); | |
| 150 | |
| 151 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 152 EXPECT_TRUE(throttle4->IsBlocked()); | |
| 153 EXPECT_TRUE(throttle5->IsBlocked()); | |
| 154 | |
| 155 throttle2.reset(); | |
| 156 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 157 EXPECT_EQ(2, throttle_state_change_count()); | |
| 158 EXPECT_EQ(throttle4.get(), last_throttle_to_change_state()); | |
| 159 | |
| 160 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 161 EXPECT_FALSE(throttle4->IsBlocked()); | |
| 162 EXPECT_TRUE(throttle5->IsBlocked()); | |
| 163 } | |
| 164 | |
| 165 // Check that THROTTLED semantics are dependent on all outstanding requests. | |
| 166 TEST_F(NetworkThrottleManagerTest, ThrottledBlockingMultiPriority) { | |
| 167 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 168 CreateThrottle(HIGHEST, UNBLOCKED)); | |
| 169 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 170 CreateThrottle(LOW, UNBLOCKED)); | |
| 171 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 172 CreateThrottle(IDLE, UNBLOCKED)); | |
| 173 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 174 CreateThrottle(THROTTLED, BLOCKED)); | |
| 175 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 176 CreateThrottle(THROTTLED, BLOCKED)); | |
| 177 | |
| 178 EXPECT_EQ(0, throttle_state_change_count()); | |
| 179 | |
| 180 throttle1.reset(); | |
| 181 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 182 EXPECT_EQ(0, throttle_state_change_count()); | |
| 183 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 184 EXPECT_TRUE(throttle4->IsBlocked()); | |
| 185 EXPECT_TRUE(throttle5->IsBlocked()); | |
| 186 | |
| 187 throttle2.reset(); | |
| 188 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 189 EXPECT_EQ(1, throttle_state_change_count()); | |
| 190 EXPECT_EQ(throttle4.get(), last_throttle_to_change_state()); | |
| 191 | |
| 192 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 193 EXPECT_FALSE(throttle4->IsBlocked()); | |
| 194 EXPECT_TRUE(throttle5->IsBlocked()); | |
| 195 | |
| 196 throttle3.reset(); | |
| 197 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 198 EXPECT_EQ(2, throttle_state_change_count()); | |
| 199 EXPECT_EQ(throttle5.get(), last_throttle_to_change_state()); | |
| 200 | |
| 201 EXPECT_FALSE(throttle4->IsBlocked()); | |
| 202 EXPECT_FALSE(throttle5->IsBlocked()); | |
| 203 } | |
| 204 | |
| 205 // Check that a SetPriority() away from THROTTLED results in unblocking | |
| 206 // and an upcall. | |
| 207 TEST_F(NetworkThrottleManagerTest, ThrottledSetPriority) { | |
| 208 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 209 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 210 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 211 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 212 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 213 CreateThrottle(THROTTLED, BLOCKED)); | |
| 214 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 215 CreateThrottle(THROTTLED, BLOCKED)); | |
| 216 | |
| 217 EXPECT_EQ(0, throttle_state_change_count()); | |
| 218 | |
| 219 throttle3->SetPriority(LOW); | |
| 220 EXPECT_EQ(1, throttle_state_change_count()); | |
| 221 EXPECT_EQ(throttle3.get(), last_throttle_to_change_state()); | |
| 222 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 223 EXPECT_TRUE(throttle4->IsBlocked()); | |
| 224 } | |
| 225 | |
| 226 void ResetThrottles(bool* function_called, | |
| 227 ScopedVector<NetworkThrottleManager::Throttle> throttles) { | |
| 228 *function_called = true; | |
| 229 // All pointers in the vector should be deleted on exit. | |
| 230 } | |
| 231 | |
| 232 // Check that tearing down all elements in the NTM on a SetPriority | |
| 233 // upcall doesn't create any problems. | |
| 234 TEST_F(NetworkThrottleManagerTest, ThrottleTeardown) { | |
| 235 ScopedVector<NetworkThrottleManager::Throttle> throttles; | |
| 236 std::unique_ptr<NetworkThrottleManager::Throttle> throttle_temporary; | |
| 237 | |
| 238 throttles.push_back(std::unique_ptr<NetworkThrottleManager::Throttle>( | |
| 239 CreateThrottle(THROTTLED, UNBLOCKED))); | |
| 240 throttles.push_back(std::unique_ptr<NetworkThrottleManager::Throttle>( | |
| 241 CreateThrottle(THROTTLED, UNBLOCKED))); | |
| 242 | |
| 243 // Note that if there is more than one throttle blocked, then the | |
| 244 // number of throttle state changes is dependent on destruction order. | |
| 245 // So only one blocked throttle is created. | |
| 246 throttle_temporary = CreateThrottle(THROTTLED, BLOCKED); | |
| 247 NetworkThrottleManager::Throttle* throttle3 = throttle_temporary.get(); | |
| 248 throttles.push_back(std::move(throttle_temporary)); | |
| 249 | |
| 250 bool callback_called(false); | |
| 251 SetThrottleStateChangedCallback( | |
| 252 base::Bind(&ResetThrottles, &callback_called, base::Passed(&throttles))); | |
| 253 | |
| 254 EXPECT_EQ(0, throttle_state_change_count()); | |
| 255 | |
| 256 throttle3->SetPriority(LOW); | |
| 257 | |
| 258 // If the test is functioning as expected, throttle3 now points to | |
| 259 // a deleted object and can no longer be indirected through. | |
| 260 | |
| 261 EXPECT_TRUE(callback_called); | |
| 262 EXPECT_EQ(1, throttle_state_change_count()); | |
| 263 EXPECT_EQ(throttle3, last_throttle_to_change_state()); | |
| 264 } | |
| 265 | |
| 266 // Note that this routine is dependent on priority setting *not* resulting in | |
| 267 // destruction of any throttle and should only be used in tests where that is | |
| 268 // true. | |
| 269 void SetAllToPriority( | |
| 270 RequestPriority priority, | |
| 271 std::vector<NetworkThrottleManager::Throttle*> throttles) { | |
| 272 for (size_t i = 0; i < throttles.size(); ++i) | |
| 273 throttles[i]->SetPriority(priority); | |
| 274 } | |
| 275 | |
| 276 // Check that modifying all the priorities of the allocated throttles in | |
| 277 // the callback works properly. | |
| 278 TEST_F(NetworkThrottleManagerTest, ThrottlePriorityReset) { | |
| 279 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 280 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 281 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 282 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 283 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 284 CreateThrottle(THROTTLED, BLOCKED)); | |
| 285 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 286 CreateThrottle(THROTTLED, BLOCKED)); | |
| 287 | |
| 288 std::vector<NetworkThrottleManager::Throttle*> throttles; | |
| 289 throttles.push_back(throttle1.get()); | |
| 290 throttles.push_back(throttle2.get()); | |
| 291 throttles.push_back(throttle3.get()); | |
| 292 | |
| 293 SetThrottleStateChangedCallback( | |
| 294 base::Bind(&SetAllToPriority, MEDIUM, base::Passed(&throttles))); | |
| 295 | |
| 296 EXPECT_EQ(0, throttle_state_change_count()); | |
| 297 throttle3->SetPriority(HIGHEST); | |
| 298 | |
| 299 // Expected result: throttles 1-3 @ medium priority (the callback should | |
| 300 // have overridden the priority setting above), only throttle 4 blocked | |
| 301 // (throttle3 should have been unblocked by either of the priority changes), | |
| 302 // and one state changes (the unblocking). | |
| 303 EXPECT_EQ(MEDIUM, throttle1->Priority()); | |
| 304 EXPECT_EQ(MEDIUM, throttle2->Priority()); | |
| 305 EXPECT_EQ(MEDIUM, throttle3->Priority()); | |
| 306 EXPECT_EQ(THROTTLED, throttle4->Priority()); | |
| 307 EXPECT_FALSE(throttle1->IsBlocked()); | |
| 308 EXPECT_FALSE(throttle2->IsBlocked()); | |
| 309 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 310 EXPECT_TRUE(throttle4->IsBlocked()); | |
| 311 EXPECT_EQ(1, throttle_state_change_count()); | |
| 312 } | |
| 313 | |
| 314 // Check that modifying the priority of a request from a non-THROTTLED | |
| 315 // value to THROTTLED causes no change in behavior. | |
| 316 TEST_F(NetworkThrottleManagerTest, ThrottlePriorityResetToThrottled) { | |
| 317 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 318 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 319 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 320 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 321 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 322 CreateThrottle(LOW, UNBLOCKED)); | |
| 323 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 324 CreateThrottle(THROTTLED, BLOCKED)); | |
| 325 | |
| 326 EXPECT_EQ(0, throttle_state_change_count()); | |
| 327 throttle3->SetPriority(THROTTLED); | |
| 328 EXPECT_EQ(0, throttle_state_change_count()); | |
| 329 | |
| 330 EXPECT_FALSE(throttle1->IsBlocked()); | |
| 331 EXPECT_FALSE(throttle2->IsBlocked()); | |
| 332 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 333 EXPECT_TRUE(throttle4->IsBlocked()); | |
| 334 | |
| 335 EXPECT_EQ(THROTTLED, throttle1->Priority()); | |
| 336 EXPECT_EQ(THROTTLED, throttle2->Priority()); | |
| 337 EXPECT_EQ(THROTTLED, throttle3->Priority()); | |
| 338 EXPECT_EQ(THROTTLED, throttle4->Priority()); | |
| 339 } | |
| 340 | |
| 341 // Confirm that old requests don't count against the limit. | |
| 342 TEST_F(NetworkThrottleManagerTest, DontCountAgedRequests) { | |
| 343 const int age_in_days_of_old_throttles = 4; | |
| 344 | |
| 345 // Confirm default median and timing means that 4 days is long enough ago | |
| 346 // to be aged out. | |
| 347 EXPECT_GT(age_in_days_of_old_throttles * 24 * 60 * 60 * 1000, | |
| 348 kInitialAgeHorizonForUncountedRequests); | |
| 349 | |
| 350 SetClockDelta(-base::TimeDelta::FromDays(age_in_days_of_old_throttles)); | |
| 351 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 352 CreateThrottle(IDLE, UNBLOCKED)); | |
| 353 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 354 CreateThrottle(IDLE, UNBLOCKED)); | |
| 355 | |
| 356 SetClockDelta(base::TimeDelta()); | |
| 357 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 358 CreateThrottle(LOW, UNBLOCKED)); | |
| 359 | |
| 360 // First throttled request should not be blocked. | |
| 361 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 362 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 363 | |
| 364 // Second should be. | |
| 365 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 366 CreateThrottle(THROTTLED, BLOCKED)); | |
| 367 | |
| 368 // Destroying the old requests should not result in any upcalls. | |
| 369 EXPECT_EQ(0, throttle_state_change_count()); | |
| 370 throttle1.reset(); | |
| 371 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 372 EXPECT_EQ(0, throttle_state_change_count()); | |
| 373 throttle2.reset(); | |
| 374 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 375 EXPECT_EQ(0, throttle_state_change_count()); | |
| 376 | |
| 377 // But destroying a new request should result in a state change. | |
| 378 throttle3.reset(); | |
| 379 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 380 EXPECT_EQ(1, throttle_state_change_count()); | |
| 381 EXPECT_EQ(throttle5.get(), last_throttle_to_change_state()); | |
| 382 } | |
| 383 | |
| 384 // Confirm that a slew of throttles of a specific age will shift the | |
| 385 // median for determining "aged requests" to that age. | |
| 386 TEST_F(NetworkThrottleManagerTest, ShiftMedian) { | |
| 387 // Setup two throttles of age *just short* of aging out; confirm | |
| 388 // they result in blocked THROTTLED requests. | |
| 389 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 390 CreateThrottle(IDLE, UNBLOCKED)); | |
| 391 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 392 CreateThrottle(IDLE, UNBLOCKED)); | |
| 393 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 394 kInitialAgeHorizonForUncountedRequests - 1)); | |
| 395 EXPECT_FALSE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 396 | |
| 397 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 398 CreateThrottle(THROTTLED, BLOCKED)); | |
| 399 | |
| 400 throttle1.reset(); | |
| 401 throttle2.reset(); | |
| 402 throttle3.reset(); | |
| 403 base::RunLoop().RunUntilIdle(); // Allow posttasks to run. | |
| 404 | |
| 405 // Create 100 throttles and destroy them, effectively with lifetime zero. | |
| 406 // This should substantially decrease the median age estimate. | |
| 407 SetClockDelta(base::TimeDelta()); | |
| 408 for (int i = 0; i < 100; ++i) { | |
| 409 std::unique_ptr<NetworkThrottleManager::Throttle> tmp( | |
| 410 CreateThrottle(IDLE, UNBLOCKED)); | |
| 411 } | |
| 412 | |
| 413 // Clear out any possible leftover timer by setting the clock to a point | |
| 414 // in the future at which it will definitely go off, and triggering it. | |
| 415 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 416 2 * kInitialAgeHorizonForUncountedRequests + kAgeHorizonFudgeFactor)); | |
| 417 throttle_manager()->ConditionallyTriggerTimerForTesting(); | |
| 418 | |
| 419 // The identical test above should no longer result in blocked throttles. | |
| 420 SetClockDelta(base::TimeDelta()); | |
| 421 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 422 CreateThrottle(IDLE, UNBLOCKED)); | |
| 423 std::unique_ptr<NetworkThrottleManager::Throttle> throttle6( | |
| 424 CreateThrottle(IDLE, UNBLOCKED)); | |
| 425 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 426 kInitialAgeHorizonForUncountedRequests - 1)); | |
| 427 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 428 std::unique_ptr<NetworkThrottleManager::Throttle> throttle7( | |
| 429 CreateThrottle(THROTTLED, UNBLOCKED)); | |
| 430 } | |
| 431 | |
| 432 // Confirm that just "aging out" requests will result in unblocking | |
| 433 // blocked requests. | |
| 434 TEST_F(NetworkThrottleManagerTest, AgeInvalidThrottles) { | |
| 435 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 436 CreateThrottle(IDLE, UNBLOCKED)); | |
| 437 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 438 CreateThrottle(IDLE, UNBLOCKED)); | |
| 439 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 440 CreateThrottle(THROTTLED, BLOCKED)); | |
| 441 | |
| 442 EXPECT_EQ(0, throttle_state_change_count()); | |
| 443 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 444 kInitialAgeHorizonForUncountedRequests + kAgeHorizonFudgeFactor)); | |
| 445 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 446 EXPECT_EQ(1, throttle_state_change_count()); | |
| 447 EXPECT_EQ(throttle3.get(), last_throttle_to_change_state()); | |
| 448 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 449 } | |
| 450 | |
| 451 // Confirm that if throttles are unblocked and made active by all | |
| 452 // existing outstanding throttles aging out, they will also eventually | |
| 453 // age out and let new throttles through. | |
| 454 TEST_F(NetworkThrottleManagerTest, NewlyUnblockedThrottlesAlsoAge) { | |
| 455 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 456 CreateThrottle(IDLE, UNBLOCKED)); | |
| 457 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 458 CreateThrottle(IDLE, UNBLOCKED)); | |
| 459 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 460 CreateThrottle(THROTTLED, BLOCKED)); | |
| 461 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 462 CreateThrottle(THROTTLED, BLOCKED)); | |
| 463 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 464 CreateThrottle(THROTTLED, BLOCKED)); | |
| 465 std::unique_ptr<NetworkThrottleManager::Throttle> throttle6( | |
| 466 CreateThrottle(THROTTLED, BLOCKED)); | |
| 467 | |
| 468 // Age the first two throttles out of the outstanding, which should | |
| 469 // result in the next two throttles becoming unblocked (and in the | |
| 470 // oustanding list). (The internal implementation will zero out | |
| 471 // the outstanding queue and then add in the two new unblocked throttles.) | |
| 472 EXPECT_EQ(0, throttle_state_change_count()); | |
| 473 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 474 kInitialAgeHorizonForUncountedRequests + kAgeHorizonFudgeFactor)); | |
| 475 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 476 EXPECT_EQ(2, throttle_state_change_count()); | |
| 477 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 478 EXPECT_FALSE(throttle4->IsBlocked()); | |
| 479 | |
| 480 // Age the next two throttles out of the outstanding queue, which | |
| 481 // should result in the next two throttles becoming unblocked (and | |
| 482 // in the oustanding list). This will only happen if a timer was properly | |
| 483 // set in the above age process as the oustanding queue went through | |
| 484 // the empty state. | |
| 485 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 486 2 * (kInitialAgeHorizonForUncountedRequests + kAgeHorizonFudgeFactor))); | |
| 487 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 488 EXPECT_EQ(4, throttle_state_change_count()); | |
| 489 EXPECT_FALSE(throttle5->IsBlocked()); | |
| 490 EXPECT_FALSE(throttle6->IsBlocked()); | |
| 491 } | |
| 492 | |
| 493 // Confirm that throttles that are blocked for a while and then | |
| 494 // unblocked don't "age out". | |
| 495 TEST_F(NetworkThrottleManagerTest, AgeBlockedThrottles) { | |
| 496 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 497 CreateThrottle(IDLE, UNBLOCKED)); | |
| 498 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 499 CreateThrottle(IDLE, UNBLOCKED)); | |
| 500 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 501 CreateThrottle(THROTTLED, BLOCKED)); | |
| 502 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 503 CreateThrottle(THROTTLED, BLOCKED)); | |
| 504 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 505 CreateThrottle(THROTTLED, BLOCKED)); | |
| 506 | |
| 507 EXPECT_EQ(0, throttle_state_change_count()); | |
| 508 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 509 kInitialAgeHorizonForUncountedRequests + kAgeHorizonFudgeFactor)); | |
| 510 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 511 | |
| 512 // If blocked throttles aged out, all three throttles should have been | |
| 513 // unblocked. If not, only the two replacing the IDLE throttles should | |
| 514 // have. | |
| 515 EXPECT_EQ(2, throttle_state_change_count()); | |
| 516 } | |
| 517 | |
| 518 // Confirm that deleting old throttles before they age out doesn't | |
| 519 // interfere with the aging out of more recent throttles. | |
| 520 TEST_F(NetworkThrottleManagerTest, DeletionAgingInterference) { | |
| 521 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 522 CreateThrottle(IDLE, UNBLOCKED)); | |
| 523 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 524 CreateThrottle(IDLE, UNBLOCKED)); | |
| 525 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 526 CreateThrottle(THROTTLED, BLOCKED)); | |
| 527 EXPECT_EQ(0, throttle_state_change_count()); | |
| 528 | |
| 529 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 530 kInitialAgeHorizonForUncountedRequests / 2)); | |
| 531 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 532 CreateThrottle(IDLE, UNBLOCKED)); | |
| 533 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 534 CreateThrottle(IDLE, UNBLOCKED)); | |
| 535 EXPECT_FALSE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 536 EXPECT_EQ(0, throttle_state_change_count()); | |
| 537 | |
| 538 throttle1.reset(); | |
| 539 throttle2.reset(); | |
| 540 EXPECT_FALSE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 541 EXPECT_EQ(0, throttle_state_change_count()); | |
| 542 | |
| 543 SetClockDelta(base::TimeDelta::FromMilliseconds( | |
| 544 (3 * kInitialAgeHorizonForUncountedRequests / 2 + | |
| 545 2 * kAgeHorizonFudgeFactor))); | |
| 546 EXPECT_TRUE(throttle_manager()->ConditionallyTriggerTimerForTesting()); | |
| 547 EXPECT_EQ(1, throttle_state_change_count()); | |
| 548 EXPECT_EQ(throttle3.get(), last_throttle_to_change_state()); | |
| 549 EXPECT_FALSE(throttle3->IsBlocked()); | |
| 550 } | |
| 551 | |
| 552 // Confirm that "ignore_limits" boolean is respected. | |
| 553 TEST_F(NetworkThrottleManagerTest, IgnoreLimits) { | |
| 554 std::unique_ptr<NetworkThrottleManager::Throttle> throttle1( | |
| 555 CreateThrottle(HIGHEST, UNBLOCKED)); | |
| 556 std::unique_ptr<NetworkThrottleManager::Throttle> throttle2( | |
| 557 CreateThrottle(LOW, UNBLOCKED)); | |
| 558 std::unique_ptr<NetworkThrottleManager::Throttle> throttle3( | |
| 559 CreateThrottle(IDLE, UNBLOCKED)); | |
| 560 std::unique_ptr<NetworkThrottleManager::Throttle> throttle4( | |
| 561 CreateThrottle(THROTTLED, BLOCKED)); | |
| 562 std::unique_ptr<NetworkThrottleManager::Throttle> throttle5( | |
| 563 CreateThrottleIgnoringLimits(THROTTLED)); | |
| 564 } | |
| 565 | |
| 566 } // namespace | |
| 567 | |
| 568 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2511493002:
Revert of Implement THROTTLED priority semantics. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@NetworkStreamThrottler