src/content/browser/loader/resource_scheduler_unittest.cc

   1 // Copyright (c) 2012 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 "content/browser/loader/resource_scheduler.h"
   6
   7 #include "base/memory/scoped_vector.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/run_loop.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/timer/mock_timer.h"
  12 #include "base/timer/timer.h"
  13 #include "content/browser/browser_thread_impl.h"
  14 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  15 #include "content/browser/loader/resource_message_filter.h"
  16 #include "content/browser/loader/resource_request_info_impl.h"
  17 #include "content/common/resource_messages.h"
  18 #include "content/public/browser/resource_context.h"
  19 #include "content/public/browser/resource_controller.h"
  20 #include "content/public/browser/resource_throttle.h"
  21 #include "content/public/common/process_type.h"
  22 #include "content/public/common/resource_type.h"
  23 #include "content/public/test/mock_render_process_host.h"
  24 #include "content/public/test/test_browser_context.h"
  25 #include "content/test/test_web_contents.h"
  26 #include "net/base/host_port_pair.h"
  27 #include "net/base/request_priority.h"
  28 #include "net/http/http_server_properties_impl.h"
  29 #include "net/url_request/url_request.h"
  30 #include "net/url_request/url_request_test_util.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32 #include "ui/events/latency_info.h"
  33
  34 namespace content {
  35
  36 namespace {
  37
  38 class TestRequestFactory;
  39
  40 const int kChildId = 30;
  41 const int kRouteId = 75;
  42 const int kChildId2 = 43;
  43 const int kRouteId2 = 67;
  44 const int kBackgroundChildId = 35;
  45 const int kBackgroundRouteId = 43;
  46 const int kBackgroundChildId2 = 54;
  47 const int kBackgroundRouteId2 = 82;
  48
  49 class TestRequest : public ResourceController {
  50  public:
  51   TestRequest(scoped_ptr<ResourceThrottle> throttle,
  52               scoped_ptr<net::URLRequest> url_request)
  53       : started_(false),
  54         throttle_(throttle.Pass()),
  55         url_request_(url_request.Pass()) {
  56     throttle_->set_controller_for_testing(this);
  57   }
  58   virtual ~TestRequest() {}
  59
  60   bool started() const { return started_; }
  61
  62   void Start() {
  63     bool deferred = false;
  64     throttle_->WillStartRequest(&deferred);
  65     started_ = !deferred;
  66   }
  67
  68   virtual void Cancel() OVERRIDE {
  69     // Alert the scheduler that the request can be deleted.
  70     throttle_.reset(0);
  71   }
  72
  73   const net::URLRequest* url_request() const { return url_request_.get(); }
  74
  75  protected:
  76   // ResourceController interface:
  77   virtual void CancelAndIgnore() OVERRIDE {}
  78   virtual void CancelWithError(int error_code) OVERRIDE {}
  79   virtual void Resume() OVERRIDE { started_ = true; }
  80
  81  private:
  82   bool started_;
  83   scoped_ptr<ResourceThrottle> throttle_;
  84   scoped_ptr<net::URLRequest> url_request_;
  85 };
  86
  87 class CancelingTestRequest : public TestRequest {
  88  public:
  89   CancelingTestRequest(scoped_ptr<ResourceThrottle> throttle,
  90                        scoped_ptr<net::URLRequest> url_request)
  91       : TestRequest(throttle.Pass(), url_request.Pass()) {}
  92
  93   void set_request_to_cancel(scoped_ptr<TestRequest> request_to_cancel) {
  94     request_to_cancel_ = request_to_cancel.Pass();
  95   }
  96
  97  private:
  98   virtual void Resume() OVERRIDE {
  99     TestRequest::Resume();
 100     request_to_cancel_.reset();
 101   }
 102
 103   scoped_ptr<TestRequest> request_to_cancel_;
 104 };
 105
 106 class FakeResourceContext : public ResourceContext {
 107  private:
 108   virtual net::HostResolver* GetHostResolver() OVERRIDE { return NULL; }
 109   virtual net::URLRequestContext* GetRequestContext() OVERRIDE { return NULL; }
 110 };
 111
 112 class FakeResourceMessageFilter : public ResourceMessageFilter {
 113  public:
 114   FakeResourceMessageFilter(int child_id)
 115       : ResourceMessageFilter(
 116           child_id,
 117           PROCESS_TYPE_RENDERER,
 118           NULL  /* appcache_service */,
 119           NULL  /* blob_storage_context */,
 120           NULL  /* file_system_context */,
 121           NULL  /* service_worker_context */,
 122           base::Bind(&FakeResourceMessageFilter::GetContexts,
 123                      base::Unretained(this))) {
 124   }
 125
 126  private:
 127   virtual ~FakeResourceMessageFilter() {}
 128
 129   void GetContexts(const ResourceHostMsg_Request& request,
 130                    ResourceContext** resource_context,
 131                    net::URLRequestContext** request_context) {
 132     *resource_context = &context_;
 133     *request_context = NULL;
 134   }
 135
 136   FakeResourceContext context_;
 137 };
 138
 139 class ResourceSchedulerTest : public testing::Test {
 140  protected:
 141   ResourceSchedulerTest()
 142       : next_request_id_(0),
 143         ui_thread_(BrowserThread::UI, &message_loop_),
 144         io_thread_(BrowserThread::IO, &message_loop_),
 145         mock_timer_(new base::MockTimer(true, true)) {
 146     scheduler_.set_timer_for_testing(scoped_ptr<base::Timer>(mock_timer_));
 147
 148     // TODO(aiolos): Remove when throttling and coalescing have both landed.
 149     scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 150                                             false /* should_coalesce */);
 151
 152     scheduler_.OnClientCreated(kChildId, kRouteId, true);
 153     scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId, false);
 154     context_.set_http_server_properties(http_server_properties_.GetWeakPtr());
 155   }
 156
 157   virtual ~ResourceSchedulerTest() {
 158     scheduler_.OnClientDeleted(kChildId, kRouteId);
 159     scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
 160   }
 161
 162   scoped_ptr<net::URLRequest> NewURLRequestWithChildAndRoute(
 163       const char* url,
 164       net::RequestPriority priority,
 165       int child_id,
 166       int route_id,
 167       bool is_async) {
 168     scoped_ptr<net::URLRequest> url_request(
 169         context_.CreateRequest(GURL(url), priority, NULL, NULL));
 170     ResourceRequestInfoImpl* info = new ResourceRequestInfoImpl(
 171         PROCESS_TYPE_RENDERER,                   // process_type
 172         child_id,                                // child_id
 173         route_id,                                // route_id
 174         0,                                       // origin_pid
 175         ++next_request_id_,                      // request_id
 176         MSG_ROUTING_NONE,                        // render_frame_id
 177         false,                                   // is_main_frame
 178         false,                                   // parent_is_main_frame
 179         0,                                       // parent_render_frame_id
 180         RESOURCE_TYPE_SUB_RESOURCE,              // resource_type
 181         ui::PAGE_TRANSITION_LINK,                // transition_type
 182         false,                                   // should_replace_current_entry
 183         false,                                   // is_download
 184         false,                                   // is_stream
 185         true,                                    // allow_download
 186         false,                                   // has_user_gesture
 187         false,                                   // enable_load_timing
 188         blink::WebReferrerPolicyDefault,         // referrer_policy
 189         blink::WebPageVisibilityStateVisible,    // visibility_state
 190         NULL,                                    // context
 191         base::WeakPtr<ResourceMessageFilter>(),  // filter
 192         is_async);                               // is_async
 193     info->AssociateWithRequest(url_request.get());
 194     return url_request.Pass();
 195   }
 196
 197   scoped_ptr<net::URLRequest> NewURLRequest(const char* url,
 198                                             net::RequestPriority priority) {
 199     return NewURLRequestWithChildAndRoute(
 200         url, priority, kChildId, kRouteId, true);
 201   }
 202
 203   TestRequest* NewRequestWithRoute(const char* url,
 204                                    net::RequestPriority priority,
 205                                    int route_id) {
 206     return NewRequestWithChildAndRoute(url, priority, route_id, kChildId);
 207   }
 208
 209   TestRequest* NewRequestWithChildAndRoute(const char* url,
 210                                            net::RequestPriority priority,
 211                                            int child_id,
 212                                            int route_id) {
 213     return GetNewTestRequest(url, priority, child_id, route_id, true);
 214   }
 215
 216   TestRequest* NewRequest(const char* url, net::RequestPriority priority) {
 217     return NewRequestWithChildAndRoute(url, priority, kChildId, kRouteId);
 218   }
 219
 220   TestRequest* NewBackgroundRequest(const char* url,
 221                                     net::RequestPriority priority) {
 222     return NewRequestWithChildAndRoute(
 223         url, priority, kBackgroundChildId, kBackgroundRouteId);
 224   }
 225
 226   TestRequest* NewSyncRequest(const char* url, net::RequestPriority priority) {
 227     return NewSyncRequestWithChildAndRoute(url, priority, kChildId, kRouteId);
 228   }
 229
 230   TestRequest* NewBackgroundSyncRequest(const char* url,
 231                                         net::RequestPriority priority) {
 232     return NewSyncRequestWithChildAndRoute(
 233         url, priority, kBackgroundChildId, kBackgroundRouteId);
 234   }
 235
 236   TestRequest* NewSyncRequestWithChildAndRoute(const char* url,
 237                                                net::RequestPriority priority,
 238                                                int child_id,
 239                                                int route_id) {
 240     return GetNewTestRequest(url, priority, child_id, route_id, false);
 241   }
 242
 243   TestRequest* GetNewTestRequest(const char* url,
 244                                  net::RequestPriority priority,
 245                                  int child_id,
 246                                  int route_id,
 247                                  bool is_async) {
 248     scoped_ptr<net::URLRequest> url_request(NewURLRequestWithChildAndRoute(
 249         url, priority, child_id, route_id, is_async));
 250     scoped_ptr<ResourceThrottle> throttle(
 251         scheduler_.ScheduleRequest(child_id, route_id, url_request.get()));
 252     TestRequest* request = new TestRequest(throttle.Pass(), url_request.Pass());
 253     request->Start();
 254     return request;
 255   }
 256
 257
 258   void ChangeRequestPriority(TestRequest* request,
 259                              net::RequestPriority new_priority,
 260                              int intra_priority = 0) {
 261     scoped_refptr<FakeResourceMessageFilter> filter(
 262         new FakeResourceMessageFilter(kChildId));
 263     const ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
 264         request->url_request());
 265     const GlobalRequestID& id = info->GetGlobalRequestID();
 266     ResourceHostMsg_DidChangePriority msg(id.request_id, new_priority,
 267                                           intra_priority);
 268     rdh_.OnMessageReceived(msg, filter.get());
 269   }
 270
 271   void FireCoalescingTimer() {
 272     EXPECT_TRUE(mock_timer_->IsRunning());
 273     mock_timer_->Fire();
 274   }
 275
 276   int next_request_id_;
 277   base::MessageLoopForIO message_loop_;
 278   BrowserThreadImpl ui_thread_;
 279   BrowserThreadImpl io_thread_;
 280   ResourceDispatcherHostImpl rdh_;
 281   ResourceScheduler scheduler_;
 282   base::MockTimer* mock_timer_;
 283   net::HttpServerPropertiesImpl http_server_properties_;
 284   net::TestURLRequestContext context_;
 285 };
 286
 287 TEST_F(ResourceSchedulerTest, OneIsolatedLowRequest) {
 288   scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOWEST));
 289   EXPECT_TRUE(request->started());
 290 }
 291
 292 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilIdle) {
 293   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 294   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 295   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 296   EXPECT_TRUE(high->started());
 297   EXPECT_TRUE(low->started());
 298   EXPECT_FALSE(low2->started());
 299   high.reset();
 300   EXPECT_TRUE(low2->started());
 301 }
 302
 303 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInserted) {
 304   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 305   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 306   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 307   EXPECT_TRUE(high->started());
 308   EXPECT_TRUE(low->started());
 309   EXPECT_FALSE(low2->started());
 310   high.reset();
 311   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 312   EXPECT_TRUE(low2->started());
 313 }
 314
 315 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilCriticalComplete) {
 316   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 317   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 318   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 319   EXPECT_TRUE(high->started());
 320   EXPECT_TRUE(low->started());
 321   EXPECT_FALSE(low2->started());
 322   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 323   EXPECT_FALSE(low2->started());
 324   high.reset();
 325   EXPECT_TRUE(low2->started());
 326 }
 327
 328 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInsertedExceptSpdy) {
 329   http_server_properties_.SetSupportsSpdy(
 330       net::HostPortPair("spdyhost", 443), true);
 331   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 332   scoped_ptr<TestRequest> low_spdy(
 333       NewRequest("https://spdyhost/low", net::LOWEST));
 334   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 335   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 336   EXPECT_TRUE(high->started());
 337   EXPECT_TRUE(low_spdy->started());
 338   EXPECT_TRUE(low->started());
 339   EXPECT_FALSE(low2->started());
 340   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 341   high.reset();
 342   EXPECT_TRUE(low2->started());
 343 }
 344
 345 TEST_F(ResourceSchedulerTest, NavigationResetsState) {
 346   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 347   scheduler_.OnNavigate(kChildId, kRouteId);
 348   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 349   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 350   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 351   EXPECT_TRUE(high->started());
 352   EXPECT_TRUE(low->started());
 353   EXPECT_FALSE(low2->started());
 354 }
 355
 356 TEST_F(ResourceSchedulerTest, BackgroundRequestStartsImmediately) {
 357   const int route_id = 0;  // Indicates a background request.
 358   scoped_ptr<TestRequest> request(NewRequestWithRoute("http://host/1",
 359                                                       net::LOWEST, route_id));
 360   EXPECT_TRUE(request->started());
 361 }
 362
 363 TEST_F(ResourceSchedulerTest, StartMultipleLowRequestsWhenIdle) {
 364   scoped_ptr<TestRequest> high1(NewRequest("http://host/high1", net::HIGHEST));
 365   scoped_ptr<TestRequest> high2(NewRequest("http://host/high2", net::HIGHEST));
 366   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 367   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 368   EXPECT_TRUE(high1->started());
 369   EXPECT_TRUE(high2->started());
 370   EXPECT_TRUE(low->started());
 371   EXPECT_FALSE(low2->started());
 372   high1.reset();
 373   EXPECT_FALSE(low2->started());
 374   high2.reset();
 375   EXPECT_TRUE(low2->started());
 376 }
 377
 378 TEST_F(ResourceSchedulerTest, CancelOtherRequestsWhileResuming) {
 379   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 380   scoped_ptr<TestRequest> low1(NewRequest("http://host/low1", net::LOWEST));
 381
 382   scoped_ptr<net::URLRequest> url_request(
 383       NewURLRequest("http://host/low2", net::LOWEST));
 384   scoped_ptr<ResourceThrottle> throttle(
 385       scheduler_.ScheduleRequest(kChildId, kRouteId, url_request.get()));
 386   scoped_ptr<CancelingTestRequest> low2(new CancelingTestRequest(
 387       throttle.Pass(), url_request.Pass()));
 388   low2->Start();
 389
 390   scoped_ptr<TestRequest> low3(NewRequest("http://host/low3", net::LOWEST));
 391   low2->set_request_to_cancel(low3.Pass());
 392   scoped_ptr<TestRequest> low4(NewRequest("http://host/low4", net::LOWEST));
 393
 394   EXPECT_TRUE(high->started());
 395   EXPECT_FALSE(low2->started());
 396   high.reset();
 397   EXPECT_TRUE(low1->started());
 398   EXPECT_TRUE(low2->started());
 399   EXPECT_TRUE(low4->started());
 400 }
 401
 402 TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
 403   // We only load low priority resources if there's a body.
 404   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 405
 406   // Throw in one high priority request to make sure that's not a factor.
 407   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 408   EXPECT_TRUE(high->started());
 409
 410   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 411   const int kMaxNumDelayableRequestsPerHost = 6;
 412   ScopedVector<TestRequest> lows_singlehost;
 413   // Queue up to the per-host limit (we subtract the current high-pri request).
 414   for (int i = 0; i < kMaxNumDelayableRequestsPerHost - 1; ++i) {
 415     string url = "http://host/low" + base::IntToString(i);
 416     lows_singlehost.push_back(NewRequest(url.c_str(), net::LOWEST));
 417     EXPECT_TRUE(lows_singlehost[i]->started());
 418   }
 419
 420   scoped_ptr<TestRequest> second_last_singlehost(NewRequest("http://host/last",
 421                                                             net::LOWEST));
 422   scoped_ptr<TestRequest> last_singlehost(NewRequest("http://host/s_last",
 423                                                      net::LOWEST));
 424
 425   EXPECT_FALSE(second_last_singlehost->started());
 426   high.reset();
 427   EXPECT_TRUE(second_last_singlehost->started());
 428   EXPECT_FALSE(last_singlehost->started());
 429   lows_singlehost.erase(lows_singlehost.begin());
 430   EXPECT_TRUE(last_singlehost->started());
 431
 432   // Queue more requests from different hosts until we reach the total limit.
 433   int expected_slots_left =
 434       kMaxNumDelayableRequestsPerClient - kMaxNumDelayableRequestsPerHost;
 435   EXPECT_GT(expected_slots_left, 0);
 436   ScopedVector<TestRequest> lows_differenthosts;
 437   for (int i = 0; i < expected_slots_left; ++i) {
 438     string url = "http://host" + base::IntToString(i) + "/low";
 439     lows_differenthosts.push_back(NewRequest(url.c_str(), net::LOWEST));
 440     EXPECT_TRUE(lows_differenthosts[i]->started());
 441   }
 442
 443   scoped_ptr<TestRequest> last_differenthost(NewRequest("http://host_new/last",
 444                                                         net::LOWEST));
 445   EXPECT_FALSE(last_differenthost->started());
 446 }
 447
 448 TEST_F(ResourceSchedulerTest, RaisePriorityAndStart) {
 449   // Dummies to enforce scheduling.
 450   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 451   scoped_ptr<TestRequest> low(NewRequest("http://host/req", net::LOWEST));
 452
 453   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
 454   EXPECT_FALSE(request->started());
 455
 456   ChangeRequestPriority(request.get(), net::HIGHEST);
 457   EXPECT_TRUE(request->started());
 458 }
 459
 460 TEST_F(ResourceSchedulerTest, RaisePriorityInQueue) {
 461   // Dummies to enforce scheduling.
 462   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 463   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 464
 465   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
 466   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
 467   EXPECT_FALSE(request->started());
 468   EXPECT_FALSE(idle->started());
 469
 470   ChangeRequestPriority(request.get(), net::LOWEST);
 471   EXPECT_FALSE(request->started());
 472   EXPECT_FALSE(idle->started());
 473
 474   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 475   ScopedVector<TestRequest> lows;
 476   for (int i = 0; i < kMaxNumDelayableRequestsPerClient - 1; ++i) {
 477     string url = "http://host/low" + base::IntToString(i);
 478     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
 479   }
 480
 481   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 482   high.reset();
 483
 484   EXPECT_TRUE(request->started());
 485   EXPECT_FALSE(idle->started());
 486 }
 487
 488 TEST_F(ResourceSchedulerTest, LowerPriority) {
 489   // Dummies to enforce scheduling.
 490   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 491   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 492
 493   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
 494   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
 495   EXPECT_FALSE(request->started());
 496   EXPECT_FALSE(idle->started());
 497
 498   ChangeRequestPriority(request.get(), net::IDLE);
 499   EXPECT_FALSE(request->started());
 500   EXPECT_FALSE(idle->started());
 501
 502   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 503   // 2 fewer filler requests: 1 for the "low" dummy at the start, and 1 for the
 504   // one at the end, which will be tested.
 505   const int kNumFillerRequests = kMaxNumDelayableRequestsPerClient - 2;
 506   ScopedVector<TestRequest> lows;
 507   for (int i = 0; i < kNumFillerRequests; ++i) {
 508     string url = "http://host" + base::IntToString(i) + "/low";
 509     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
 510   }
 511
 512   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 513   high.reset();
 514
 515   EXPECT_FALSE(request->started());
 516   EXPECT_TRUE(idle->started());
 517 }
 518
 519 TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
 520   // Dummies to enforce scheduling.
 521   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 522   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 523
 524   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
 525   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
 526   EXPECT_FALSE(request->started());
 527   EXPECT_FALSE(idle->started());
 528
 529   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 530   ScopedVector<TestRequest> lows;
 531   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
 532     string url = "http://host/low" + base::IntToString(i);
 533     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
 534   }
 535
 536   ChangeRequestPriority(request.get(), net::IDLE);
 537   EXPECT_FALSE(request->started());
 538   EXPECT_FALSE(idle->started());
 539
 540   ChangeRequestPriority(request.get(), net::LOWEST);
 541   EXPECT_FALSE(request->started());
 542   EXPECT_FALSE(idle->started());
 543
 544   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 545   EXPECT_FALSE(request->started());
 546   EXPECT_FALSE(idle->started());
 547 }
 548
 549 TEST_F(ResourceSchedulerTest, HigherIntraPriorityGoesToFrontOfQueue) {
 550   // Dummies to enforce scheduling.
 551   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 552   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 553
 554   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 555   ScopedVector<TestRequest> lows;
 556   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
 557     string url = "http://host/low" + base::IntToString(i);
 558     lows.push_back(NewRequest(url.c_str(), net::IDLE));
 559   }
 560
 561   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
 562   EXPECT_FALSE(request->started());
 563
 564   ChangeRequestPriority(request.get(), net::IDLE, 1);
 565   EXPECT_FALSE(request->started());
 566
 567   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 568   high.reset();
 569   EXPECT_TRUE(request->started());
 570 }
 571
 572 TEST_F(ResourceSchedulerTest, NonHTTPSchedulesImmediately) {
 573   // Dummies to enforce scheduling.
 574   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 575   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 576
 577   scoped_ptr<TestRequest> request(
 578       NewRequest("chrome-extension://req", net::LOWEST));
 579   EXPECT_TRUE(request->started());
 580 }
 581
 582 TEST_F(ResourceSchedulerTest, ActiveLoadingSyncSchedulesImmediately) {
 583   // TODO(aiolos): remove when throttling and coalescing have both landed
 584   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 585                                           false /* should_coalesce */);
 586   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 587             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 588   // Dummies to enforce scheduling.
 589   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 590   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 591
 592   scoped_ptr<TestRequest> request(
 593       NewSyncRequest("http://host/req", net::LOWEST));
 594   EXPECT_TRUE(request->started());
 595 }
 596
 597 TEST_F(ResourceSchedulerTest, UnthrottledSyncSchedulesImmediately) {
 598   // TODO(aiolos): remove when throttling and coalescing have both landed
 599   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 600                                           false /* should_coalesce */);
 601   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 602   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
 603             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 604                                                 kBackgroundRouteId));
 605   // Dummies to enforce scheduling.
 606   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 607   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 608
 609   scoped_ptr<TestRequest> request(
 610       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
 611   EXPECT_TRUE(request->started());
 612 }
 613
 614 TEST_F(ResourceSchedulerTest, SpdyProxySchedulesImmediately) {
 615   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
 616   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 617
 618   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
 619   EXPECT_FALSE(request->started());
 620
 621   scheduler_.OnReceivedSpdyProxiedHttpResponse(kChildId, kRouteId);
 622   EXPECT_TRUE(request->started());
 623
 624   scoped_ptr<TestRequest> after(NewRequest("http://host/after", net::IDLE));
 625   EXPECT_TRUE(after->started());
 626 }
 627
 628 TEST_F(ResourceSchedulerTest, NewSpdyHostInDelayableRequests) {
 629   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 630   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 631
 632   scoped_ptr<TestRequest> low1_spdy(
 633       NewRequest("http://spdyhost1:8080/low", net::LOWEST));
 634   // Cancel a request after we learn the server supports SPDY.
 635   ScopedVector<TestRequest> lows;
 636   for (int i = 0; i < kMaxNumDelayableRequestsPerClient - 1; ++i) {
 637     string url = "http://host" + base::IntToString(i) + "/low";
 638     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
 639   }
 640   scoped_ptr<TestRequest> low1(NewRequest("http://host/low", net::LOWEST));
 641   EXPECT_FALSE(low1->started());
 642   http_server_properties_.SetSupportsSpdy(
 643       net::HostPortPair("spdyhost1", 8080), true);
 644   low1_spdy.reset();
 645   EXPECT_TRUE(low1->started());
 646
 647   low1.reset();
 648   scoped_ptr<TestRequest> low2_spdy(
 649       NewRequest("http://spdyhost2:8080/low", net::IDLE));
 650   // Reprioritize a request after we learn the server supports SPDY.
 651   EXPECT_TRUE(low2_spdy->started());
 652   http_server_properties_.SetSupportsSpdy(
 653       net::HostPortPair("spdyhost2", 8080), true);
 654   ChangeRequestPriority(low2_spdy.get(), net::LOWEST);
 655   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
 656   EXPECT_TRUE(low2->started());
 657 }
 658
 659 TEST_F(ResourceSchedulerTest, ThrottledClientCreation) {
 660   // TODO(aiolos): remove when throttling and coalescing have both landed
 661   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 662                                           false /* should_coalesce */);
 663   EXPECT_TRUE(scheduler_.should_throttle());
 664   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
 665
 666   EXPECT_EQ(ResourceScheduler::THROTTLED,
 667             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
 668                                                 kBackgroundRouteId2));
 669   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 670 }
 671
 672 TEST_F(ResourceSchedulerTest, ActiveClientThrottleUpdateOnLoadingChange) {
 673   // TODO(aiolos): remove when throttling and coalescing have both landed
 674   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 675                                           false /* should_coalesce */);
 676   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 677             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 678   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 679   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
 680             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 681   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
 682   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 683             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 684 }
 685
 686 TEST_F(ResourceSchedulerTest, CoalesceBackgroundClientOnLoadCompletion) {
 687   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 688                                           true /* should_coalesce */);
 689   EXPECT_EQ(ResourceScheduler::THROTTLED,
 690             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 691                                                 kBackgroundRouteId));
 692   scheduler_.OnLoadingStateChanged(
 693       kBackgroundChildId, kBackgroundRouteId, true);
 694   EXPECT_EQ(ResourceScheduler::THROTTLED,
 695             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 696                                                 kBackgroundRouteId));
 697   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 698   EXPECT_EQ(ResourceScheduler::COALESCED,
 699             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 700                                                 kBackgroundRouteId));
 701 }
 702
 703 TEST_F(ResourceSchedulerTest, UnthrottleBackgroundClientOnLoadingStarted) {
 704   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 705                                           true /* should_coalesce */);
 706   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 707   scheduler_.OnLoadingStateChanged(
 708       kBackgroundChildId, kBackgroundRouteId, true);
 709   EXPECT_EQ(ResourceScheduler::COALESCED,
 710             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 711                                                 kBackgroundRouteId));
 712
 713   scheduler_.OnLoadingStateChanged(
 714       kBackgroundChildId, kBackgroundRouteId, false);
 715   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
 716             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 717                                                 kBackgroundRouteId));
 718 }
 719
 720 TEST_F(ResourceSchedulerTest, OneRequestPerThrottledClient) {
 721   // TODO(aiolos): remove when throttling and coalescing have both landed
 722   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 723                                           false /* should_coalesce */);
 724   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 725             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 726   EXPECT_EQ(ResourceScheduler::THROTTLED,
 727             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 728                                                 kBackgroundRouteId));
 729   scoped_ptr<TestRequest> high(
 730       NewBackgroundRequest("http://host/high", net::HIGHEST));
 731   scoped_ptr<TestRequest> request(
 732       NewBackgroundRequest("http://host/req", net::IDLE));
 733
 734   EXPECT_TRUE(high->started());
 735   EXPECT_FALSE(request->started());
 736 }
 737
 738 TEST_F(ResourceSchedulerTest, UnthrottleNewlyVisibleClient) {
 739   // TODO(aiolos): remove when throttling and coalescing have both landed
 740   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 741                                           false /* should_coalesce */);
 742   EXPECT_EQ(ResourceScheduler::THROTTLED,
 743             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 744                                                 kBackgroundRouteId));
 745   scoped_ptr<TestRequest> high(
 746       NewBackgroundRequest("http://host/high", net::HIGHEST));
 747   scoped_ptr<TestRequest> request(
 748       NewBackgroundRequest("http://host/req", net::IDLE));
 749   EXPECT_FALSE(request->started());
 750
 751   scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
 752   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 753             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 754                                                 kBackgroundRouteId));
 755   EXPECT_TRUE(request->started());
 756 }
 757
 758 TEST_F(ResourceSchedulerTest, UnthrottleNewlyAudibleClient) {
 759   // TODO(aiolos): remove when throttling and coalescing have both landed
 760   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 761                                           false /* should_coalesce */);
 762   EXPECT_EQ(ResourceScheduler::THROTTLED,
 763             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 764                                                 kBackgroundRouteId));
 765   scoped_ptr<TestRequest> high(
 766       NewBackgroundRequest("http://host/high", net::HIGHEST));
 767   scoped_ptr<TestRequest> request(
 768       NewBackgroundRequest("http://host/req", net::IDLE));
 769   EXPECT_FALSE(request->started());
 770
 771   scheduler_.OnAudibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
 772   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 773             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 774                                                 kBackgroundRouteId));
 775   EXPECT_TRUE(request->started());
 776 }
 777
 778 TEST_F(ResourceSchedulerTest, VisibleClientStillUnthrottledOnAudabilityChange) {
 779   // TODO(aiolos): remove when throttling and coalescing have both landed
 780   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 781                                           false /* should_coalesce */);
 782   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 783             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 784   EXPECT_EQ(ResourceScheduler::THROTTLED,
 785             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 786                                                 kBackgroundRouteId));
 787
 788   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
 789   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 790             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 791   EXPECT_EQ(ResourceScheduler::THROTTLED,
 792             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 793                                                 kBackgroundRouteId));
 794
 795   scheduler_.OnAudibilityChanged(kChildId, kRouteId, false);
 796   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 797             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 798   EXPECT_EQ(ResourceScheduler::THROTTLED,
 799             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 800                                                 kBackgroundRouteId));
 801 }
 802
 803 TEST_F(ResourceSchedulerTest, AudibleClientStillUnthrottledOnVisabilityChange) {
 804   // TODO(aiolos): remove when throttling and coalescing have both landed
 805   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 806                                           false /* should_coalesce */);
 807   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
 808   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
 809   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 810             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 811   EXPECT_EQ(ResourceScheduler::THROTTLED,
 812             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 813                                                 kBackgroundRouteId));
 814
 815   scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
 816   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 817             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 818   EXPECT_EQ(ResourceScheduler::THROTTLED,
 819             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 820                                                 kBackgroundRouteId));
 821
 822   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
 823   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
 824             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 825   EXPECT_EQ(ResourceScheduler::THROTTLED,
 826             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 827                                                 kBackgroundRouteId));
 828 }
 829
 830 TEST_F(ResourceSchedulerTest, ThrottledClientStartsNextHighestPriorityRequest) {
 831   // TODO(aiolos): remove when throttling and coalescing have both landed
 832   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 833                                           false /* should_coalesce */);
 834   scoped_ptr<TestRequest> request(
 835       NewBackgroundRequest("http://host/req", net::IDLE));
 836   // Lower priority request started first to test request prioritizaton.
 837   scoped_ptr<TestRequest> low(
 838       NewBackgroundRequest("http://host/high", net::IDLE));
 839   scoped_ptr<TestRequest> high(
 840       NewBackgroundRequest("http://host/high", net::HIGHEST));
 841
 842   EXPECT_FALSE(low->started());
 843   EXPECT_FALSE(high->started());
 844
 845   // request->CancelRequest();
 846   request->Cancel();
 847   EXPECT_TRUE(high->started());
 848   EXPECT_FALSE(low->started());
 849 }
 850
 851 TEST_F(ResourceSchedulerTest, ThrottledSpdyProxySchedulesImmediately) {
 852   // TODO(aiolos): remove when throttling and coalescing have both landed
 853   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 854                                           false /* should_coalesce */);
 855   EXPECT_EQ(ResourceScheduler::THROTTLED,
 856             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 857                                                 kBackgroundRouteId));
 858   scoped_ptr<TestRequest> high(
 859       NewBackgroundRequest("http://host/high", net::HIGHEST));
 860   scoped_ptr<TestRequest> request(
 861       NewBackgroundRequest("http://host/req", net::IDLE));
 862
 863   EXPECT_FALSE(request->started());
 864
 865   scheduler_.OnReceivedSpdyProxiedHttpResponse(kBackgroundChildId,
 866                                                kBackgroundRouteId);
 867   EXPECT_TRUE(request->started());
 868
 869   scoped_ptr<TestRequest> after(
 870       NewBackgroundRequest("http://host/after", net::IDLE));
 871   EXPECT_TRUE(after->started());
 872 }
 873
 874 TEST_F(ResourceSchedulerTest, CoalescedClientIssuesNoRequests) {
 875   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 876                                           true /* should_coalesce */);
 877   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 878   scheduler_.OnLoadingStateChanged(
 879       kBackgroundChildId, kBackgroundRouteId, true);
 880   EXPECT_EQ(ResourceScheduler::COALESCED,
 881             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 882                                                 kBackgroundRouteId));
 883   scoped_ptr<TestRequest> high(
 884       NewBackgroundRequest("http://host/high", net::HIGHEST));
 885   scoped_ptr<TestRequest> request(
 886       NewBackgroundRequest("http://host/req", net::IDLE));
 887
 888   EXPECT_FALSE(high->started());
 889   EXPECT_FALSE(request->started());
 890
 891   scheduler_.OnReceivedSpdyProxiedHttpResponse(kBackgroundChildId,
 892                                                kBackgroundRouteId);
 893   EXPECT_FALSE(high->started());
 894
 895   scoped_ptr<TestRequest> after(
 896       NewBackgroundRequest("http://host/after", net::HIGHEST));
 897   EXPECT_FALSE(after->started());
 898 }
 899
 900 TEST_F(ResourceSchedulerTest, CoalescedSpdyProxyWaits) {
 901   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 902                                           true /* should_coalesce */);
 903   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 904   scheduler_.OnLoadingStateChanged(
 905       kBackgroundChildId, kBackgroundRouteId, true);
 906   EXPECT_EQ(ResourceScheduler::COALESCED,
 907             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 908                                                 kBackgroundRouteId));
 909   scoped_ptr<TestRequest> high(
 910       NewBackgroundRequest("http://host/high", net::HIGHEST));
 911   scoped_ptr<TestRequest> request(
 912       NewBackgroundRequest("http://host/req", net::IDLE));
 913
 914   EXPECT_FALSE(request->started());
 915
 916   scheduler_.OnReceivedSpdyProxiedHttpResponse(kBackgroundChildId,
 917                                                kBackgroundRouteId);
 918   EXPECT_FALSE(request->started());
 919
 920   scoped_ptr<TestRequest> after(
 921       NewBackgroundRequest("http://host/after", net::IDLE));
 922   EXPECT_FALSE(after->started());
 923 }
 924
 925 TEST_F(ResourceSchedulerTest, ThrottledNonHTTPSchedulesImmediately) {
 926   // TODO(aiolos): remove when throttling and coalescing have both landed
 927   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 928                                           false /* should_coalesce */);
 929   // Dummies to enforce scheduling.
 930   scoped_ptr<TestRequest> high(
 931       NewBackgroundRequest("http://host/high", net::HIGHEST));
 932   scoped_ptr<TestRequest> low(
 933       NewBackgroundRequest("http://host/low", net::LOWEST));
 934
 935   scoped_ptr<TestRequest> request(
 936       NewBackgroundRequest("chrome-extension://req", net::LOWEST));
 937   EXPECT_TRUE(request->started());
 938   EXPECT_FALSE(low->started());
 939 }
 940
 941 TEST_F(ResourceSchedulerTest, CoalescedNonHTTPSchedulesImmediately) {
 942   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 943                                           true /* should_coalesce */);
 944   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 945   scheduler_.OnLoadingStateChanged(
 946       kBackgroundChildId, kBackgroundRouteId, true);
 947   EXPECT_EQ(ResourceScheduler::COALESCED,
 948             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 949                                                 kBackgroundRouteId));
 950   // Dummies to enforce scheduling.
 951   scoped_ptr<TestRequest> high(
 952       NewBackgroundRequest("http://host/high", net::HIGHEST));
 953   scoped_ptr<TestRequest> low(
 954       NewBackgroundRequest("http://host/low", net::LOWEST));
 955
 956   scoped_ptr<TestRequest> request(
 957       NewBackgroundRequest("chrome-extension://req", net::LOWEST));
 958   EXPECT_TRUE(request->started());
 959   EXPECT_FALSE(low->started());
 960 }
 961
 962 TEST_F(ResourceSchedulerTest, ThrottledSyncSchedulesImmediately) {
 963   // TODO(aiolos): remove when throttling and coalescing have both landed
 964   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 965                                           false /* should_coalesce */);
 966   // Dummies to enforce scheduling.
 967   scoped_ptr<TestRequest> high(
 968       NewBackgroundRequest("http://host/high", net::HIGHEST));
 969   scoped_ptr<TestRequest> low(
 970       NewBackgroundRequest("http://host/low", net::LOWEST));
 971
 972   scoped_ptr<TestRequest> request(
 973       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
 974   EXPECT_TRUE(request->started());
 975   EXPECT_FALSE(low->started());
 976 }
 977
 978 TEST_F(ResourceSchedulerTest, CoalescedSyncSchedulesImmediately) {
 979   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
 980                                           true /* should_coalesce */);
 981   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
 982   scheduler_.OnLoadingStateChanged(
 983       kBackgroundChildId, kBackgroundRouteId, true);
 984   EXPECT_EQ(ResourceScheduler::COALESCED,
 985             scheduler_.GetClientStateForTesting(kBackgroundChildId,
 986                                                 kBackgroundRouteId));
 987   // Dummies to enforce scheduling.
 988   scoped_ptr<TestRequest> high(
 989       NewBackgroundRequest("http://host/high", net::HIGHEST));
 990   scoped_ptr<TestRequest> low(
 991       NewBackgroundRequest("http://host/low", net::LOWEST));
 992
 993   scoped_ptr<TestRequest> request(
 994       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
 995   EXPECT_TRUE(request->started());
 996   EXPECT_FALSE(low->started());
 997   EXPECT_FALSE(high->started());
 998 }
 999
1000 TEST_F(ResourceSchedulerTest, AllBackgroundClientsUnthrottle) {
1001   // TODO(aiolos): remove when throttling and coalescing have both landed
1002   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1003                                           false /* should_coalesce */);
1004   EXPECT_EQ(ResourceScheduler::THROTTLED,
1005             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1006                                                 kBackgroundRouteId));
1007   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1008             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1009   EXPECT_FALSE(scheduler_.active_clients_loaded());
1010
1011   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1012   EXPECT_TRUE(scheduler_.active_clients_loaded());
1013   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1014             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1015   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1016             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1017                                                 kBackgroundRouteId));
1018
1019   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1020   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1021             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1022   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1023             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1024                                                 kBackgroundRouteId));
1025
1026   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
1027   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1028             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1029   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1030             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1031                                                 kBackgroundRouteId));
1032
1033   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1034   scheduler_.OnLoadingStateChanged(
1035       kBackgroundChildId, kBackgroundRouteId, true);
1036   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1037             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1038   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1039             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1040                                                 kBackgroundRouteId));
1041 }
1042
1043 TEST_F(ResourceSchedulerTest,
1044        UnloadedClientVisibilityChangedCorrectlyUnthrottles) {
1045   // TODO(aiolos): remove when throttling and coalescing have both landed
1046   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1047                                           false /* should_coalesce */);
1048   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1049   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1050   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1051   scheduler_.OnLoadingStateChanged(
1052       kBackgroundChildId2, kBackgroundRouteId2, true);
1053
1054   // 1 visible, 3 hidden
1055   EXPECT_FALSE(scheduler_.active_clients_loaded());
1056   EXPECT_EQ(ResourceScheduler::THROTTLED,
1057             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1058                                                 kBackgroundRouteId));
1059   EXPECT_EQ(ResourceScheduler::THROTTLED,
1060             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1061                                                 kBackgroundRouteId2));
1062   EXPECT_EQ(ResourceScheduler::THROTTLED,
1063             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1064   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1065             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1066
1067   // 2 visible, 2 hidden
1068   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
1069   EXPECT_FALSE(scheduler_.active_clients_loaded());
1070   EXPECT_EQ(ResourceScheduler::THROTTLED,
1071             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1072                                                 kBackgroundRouteId));
1073   EXPECT_EQ(ResourceScheduler::THROTTLED,
1074             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1075                                                 kBackgroundRouteId2));
1076   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1077             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1078   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1079             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1080
1081   // 1 visible, 3 hidden
1082   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
1083   EXPECT_FALSE(scheduler_.active_clients_loaded());
1084   EXPECT_EQ(ResourceScheduler::THROTTLED,
1085             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1086                                                 kBackgroundRouteId));
1087   EXPECT_EQ(ResourceScheduler::THROTTLED,
1088             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1089                                                 kBackgroundRouteId2));
1090   EXPECT_EQ(ResourceScheduler::THROTTLED,
1091             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1092   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1093             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1094
1095   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1096   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1097 }
1098
1099 TEST_F(ResourceSchedulerTest,
1100        UnloadedClientAudibilityChangedCorrectlyUnthrottles) {
1101   // TODO(aiolos): remove when throttling and coalescing have both landed
1102   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1103                                           false /* should_coalesce */);
1104   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1105   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1106   scheduler_.OnLoadingStateChanged(
1107       kBackgroundChildId2, kBackgroundRouteId2, true);
1108   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1109   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
1110
1111   // 1 audible, 3 hidden
1112   EXPECT_FALSE(scheduler_.active_clients_loaded());
1113   EXPECT_EQ(ResourceScheduler::THROTTLED,
1114             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1115                                                 kBackgroundRouteId));
1116   EXPECT_EQ(ResourceScheduler::THROTTLED,
1117             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1118                                                 kBackgroundRouteId2));
1119   EXPECT_EQ(ResourceScheduler::THROTTLED,
1120             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1121   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1122             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1123
1124   // 2 audible, 2 hidden
1125   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
1126   EXPECT_FALSE(scheduler_.active_clients_loaded());
1127   EXPECT_EQ(ResourceScheduler::THROTTLED,
1128             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1129                                                 kBackgroundRouteId));
1130   EXPECT_EQ(ResourceScheduler::THROTTLED,
1131             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1132                                                 kBackgroundRouteId2));
1133   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1134             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1135   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1136             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1137
1138   // 1 audible, 3 hidden
1139   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, false);
1140   EXPECT_FALSE(scheduler_.active_clients_loaded());
1141   EXPECT_EQ(ResourceScheduler::THROTTLED,
1142             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1143                                                 kBackgroundRouteId));
1144   EXPECT_EQ(ResourceScheduler::THROTTLED,
1145             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1146                                                 kBackgroundRouteId2));
1147   EXPECT_EQ(ResourceScheduler::THROTTLED,
1148             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1149   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1150             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1151
1152   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1153   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1154 }
1155
1156 TEST_F(ResourceSchedulerTest,
1157        LoadedClientVisibilityChangedCorrectlyUnthrottles) {
1158   // TODO(aiolos): remove when throttling and coalescing have both landed
1159   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1160                                           false /* should_coalesce */);
1161   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1162   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1163   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1164   scheduler_.OnLoadingStateChanged(
1165       kBackgroundChildId2, kBackgroundRouteId2, true);
1166   // 1 visible, 3 hidden
1167   EXPECT_FALSE(scheduler_.active_clients_loaded());
1168   EXPECT_EQ(ResourceScheduler::THROTTLED,
1169             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1170                                                 kBackgroundRouteId));
1171   EXPECT_EQ(ResourceScheduler::THROTTLED,
1172             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1173                                                 kBackgroundRouteId2));
1174   EXPECT_EQ(ResourceScheduler::THROTTLED,
1175             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1176   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1177             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1178
1179   // 2 visible, 2 hidden
1180   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
1181   EXPECT_FALSE(scheduler_.active_clients_loaded());
1182   EXPECT_EQ(ResourceScheduler::THROTTLED,
1183             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1184                                                 kBackgroundRouteId));
1185   EXPECT_EQ(ResourceScheduler::THROTTLED,
1186             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1187                                                 kBackgroundRouteId2));
1188   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1189             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1190   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1191             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1192
1193   // 1 visible, 3 hidden
1194   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
1195   EXPECT_FALSE(scheduler_.active_clients_loaded());
1196   EXPECT_EQ(ResourceScheduler::THROTTLED,
1197             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1198                                                 kBackgroundRouteId));
1199   EXPECT_EQ(ResourceScheduler::THROTTLED,
1200             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1201                                                 kBackgroundRouteId2));
1202   EXPECT_EQ(ResourceScheduler::THROTTLED,
1203             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1204   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1205             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1206
1207   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1208   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1209 }
1210
1211 TEST_F(ResourceSchedulerTest,
1212        LoadedClientAudibilityChangedCorrectlyUnthrottles) {
1213   // TODO(aiolos): remove when throttling and coalescing have both landed
1214   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1215                                           false /* should_coalesce */);
1216   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1217   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1218   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1219   scheduler_.OnLoadingStateChanged(
1220       kBackgroundChildId2, kBackgroundRouteId2, true);
1221   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1222   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
1223   // 1 audible, 3 hidden
1224   EXPECT_FALSE(scheduler_.active_clients_loaded());
1225   EXPECT_EQ(ResourceScheduler::THROTTLED,
1226             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1227                                                 kBackgroundRouteId));
1228   EXPECT_EQ(ResourceScheduler::THROTTLED,
1229             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1230                                                 kBackgroundRouteId2));
1231   EXPECT_EQ(ResourceScheduler::THROTTLED,
1232             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1233   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1234             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1235
1236   // 2 audible, 2 hidden
1237   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
1238   EXPECT_FALSE(scheduler_.active_clients_loaded());
1239   EXPECT_EQ(ResourceScheduler::THROTTLED,
1240             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1241                                                 kBackgroundRouteId));
1242   EXPECT_EQ(ResourceScheduler::THROTTLED,
1243             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1244                                                 kBackgroundRouteId2));
1245   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1246             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1247   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1248             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1249
1250   // 1 audible, 3 hidden
1251   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, false);
1252   EXPECT_FALSE(scheduler_.active_clients_loaded());
1253   EXPECT_EQ(ResourceScheduler::THROTTLED,
1254             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1255                                                 kBackgroundRouteId));
1256   EXPECT_EQ(ResourceScheduler::THROTTLED,
1257             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1258                                                 kBackgroundRouteId2));
1259   EXPECT_EQ(ResourceScheduler::THROTTLED,
1260             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1261   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1262             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1263
1264   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1265   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1266 }
1267
1268 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesHiddenCorrectlyUnthrottles) {
1269   // TODO(aiolos): remove when throttling and coalescing have both landed
1270   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1271                                           false /* should_coalesce */);
1272   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1273   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1274   scheduler_.OnLoadingStateChanged(
1275       kBackgroundChildId2, kBackgroundRouteId2, true);
1276
1277   // 2 visible, 2 hidden
1278   EXPECT_FALSE(scheduler_.active_clients_loaded());
1279   EXPECT_EQ(ResourceScheduler::THROTTLED,
1280             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1281                                                 kBackgroundRouteId));
1282   EXPECT_EQ(ResourceScheduler::THROTTLED,
1283             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1284                                                 kBackgroundRouteId2));
1285   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1286             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1287   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1288             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1289
1290   // 1 visible, 3 hidden
1291   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
1292   EXPECT_FALSE(scheduler_.active_clients_loaded());
1293   EXPECT_EQ(ResourceScheduler::THROTTLED,
1294             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1295                                                 kBackgroundRouteId));
1296   EXPECT_EQ(ResourceScheduler::THROTTLED,
1297             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1298                                                 kBackgroundRouteId2));
1299   EXPECT_EQ(ResourceScheduler::THROTTLED,
1300             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1301   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1302             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1303
1304   // 0 visible, 4 hidden
1305   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1306   EXPECT_TRUE(scheduler_.active_clients_loaded());
1307   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1308             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1309                                                 kBackgroundRouteId));
1310   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1311             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1312                                                 kBackgroundRouteId2));
1313   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1314             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1315   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1316             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1317
1318   // 1 visible, 3 hidden
1319   scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
1320   EXPECT_FALSE(scheduler_.active_clients_loaded());
1321   EXPECT_EQ(ResourceScheduler::THROTTLED,
1322             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1323                                                 kBackgroundRouteId));
1324   EXPECT_EQ(ResourceScheduler::THROTTLED,
1325             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1326                                                 kBackgroundRouteId2));
1327   EXPECT_EQ(ResourceScheduler::THROTTLED,
1328             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1329   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1330             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1331
1332   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1333   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1334 }
1335
1336 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesSilentCorrectlyUnthrottles) {
1337   // TODO(aiolos): remove when throttling and coalescing have both landed
1338   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1339                                           false /* should_coalesce */);
1340   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1341   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1342   scheduler_.OnLoadingStateChanged(
1343       kBackgroundChildId2, kBackgroundRouteId2, true);
1344   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
1345   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1346   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
1347   // 2 audible, 2 hidden
1348   EXPECT_FALSE(scheduler_.active_clients_loaded());
1349   EXPECT_EQ(ResourceScheduler::THROTTLED,
1350             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1351                                                 kBackgroundRouteId));
1352   EXPECT_EQ(ResourceScheduler::THROTTLED,
1353             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1354                                                 kBackgroundRouteId2));
1355   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1356             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1357   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1358             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1359
1360   // 1 audible, 3 hidden
1361   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, false);
1362   EXPECT_FALSE(scheduler_.active_clients_loaded());
1363   EXPECT_EQ(ResourceScheduler::THROTTLED,
1364             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1365                                                 kBackgroundRouteId));
1366   EXPECT_EQ(ResourceScheduler::THROTTLED,
1367             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1368                                                 kBackgroundRouteId2));
1369   EXPECT_EQ(ResourceScheduler::THROTTLED,
1370             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1371   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1372             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1373
1374   // 0 audible, 4 hidden
1375   scheduler_.OnAudibilityChanged(kChildId, kRouteId, false);
1376   EXPECT_TRUE(scheduler_.active_clients_loaded());
1377   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1378             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1379                                                 kBackgroundRouteId));
1380   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1381             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1382                                                 kBackgroundRouteId2));
1383   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1384             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1385   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1386             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1387
1388   // 1 audible, 3 hidden
1389   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
1390   EXPECT_FALSE(scheduler_.active_clients_loaded());
1391   EXPECT_EQ(ResourceScheduler::THROTTLED,
1392             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1393                                                 kBackgroundRouteId));
1394   EXPECT_EQ(ResourceScheduler::THROTTLED,
1395             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1396                                                 kBackgroundRouteId2));
1397   EXPECT_EQ(ResourceScheduler::THROTTLED,
1398             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1399   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1400             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1401
1402   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1403   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1404 }
1405
1406 TEST_F(ResourceSchedulerTest, LoadedClientBecomesHiddenCorrectlyThrottles) {
1407   // TODO(aiolos): remove when throttling and coalescing have both landed
1408   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1409                                           false /* should_coalesce */);
1410   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1411   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1412   scheduler_.OnLoadingStateChanged(
1413       kBackgroundChildId2, kBackgroundRouteId2, true);
1414   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1415   // 2 visible, 2 hidden
1416   EXPECT_FALSE(scheduler_.active_clients_loaded());
1417   EXPECT_EQ(ResourceScheduler::THROTTLED,
1418             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1419                                                 kBackgroundRouteId));
1420   EXPECT_EQ(ResourceScheduler::THROTTLED,
1421             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1422                                                 kBackgroundRouteId2));
1423   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1424             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1425   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1426             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1427
1428   // 1 visible, 3 hidden
1429   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
1430   EXPECT_FALSE(scheduler_.active_clients_loaded());
1431   EXPECT_EQ(ResourceScheduler::THROTTLED,
1432             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1433                                                 kBackgroundRouteId));
1434   EXPECT_EQ(ResourceScheduler::THROTTLED,
1435             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1436                                                 kBackgroundRouteId2));
1437   EXPECT_EQ(ResourceScheduler::THROTTLED,
1438             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1439   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1440             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1441
1442   // 0 visible, 4 hidden
1443   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1444   EXPECT_TRUE(scheduler_.active_clients_loaded());
1445   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1446             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1447                                                 kBackgroundRouteId));
1448   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1449             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1450                                                 kBackgroundRouteId2));
1451   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1452             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1453   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1454             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1455
1456   // 1 visible, 3 hidden
1457   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
1458   EXPECT_TRUE(scheduler_.active_clients_loaded());
1459   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1460             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1461                                                 kBackgroundRouteId));
1462   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1463             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1464                                                 kBackgroundRouteId2));
1465   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1466             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1467   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1468             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1469
1470   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1471   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1472 }
1473
1474 TEST_F(ResourceSchedulerTest, LoadedClientBecomesSilentCorrectlyThrottles) {
1475   // TODO(aiolos): remove when throttling and coalescing have both landed
1476   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1477                                           false /* should_coalesce */);
1478   scheduler_.OnClientCreated(kChildId2, kRouteId2, false);
1479   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1480   scheduler_.OnLoadingStateChanged(
1481       kBackgroundChildId2, kBackgroundRouteId2, true);
1482   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1483   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1484   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
1485   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
1486   // 2 audible, 2 hidden
1487   EXPECT_FALSE(scheduler_.active_clients_loaded());
1488   EXPECT_EQ(ResourceScheduler::THROTTLED,
1489             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1490                                                 kBackgroundRouteId));
1491   EXPECT_EQ(ResourceScheduler::THROTTLED,
1492             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1493                                                 kBackgroundRouteId2));
1494   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1495             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1496   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1497             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1498
1499   // 1 audible, 3 hidden
1500   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, false);
1501   EXPECT_FALSE(scheduler_.active_clients_loaded());
1502   EXPECT_EQ(ResourceScheduler::THROTTLED,
1503             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1504                                                 kBackgroundRouteId));
1505   EXPECT_EQ(ResourceScheduler::THROTTLED,
1506             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1507                                                 kBackgroundRouteId2));
1508   EXPECT_EQ(ResourceScheduler::THROTTLED,
1509             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1510   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1511             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1512
1513   // 0 audible, 4 hidden
1514   scheduler_.OnAudibilityChanged(kChildId, kRouteId, false);
1515   EXPECT_TRUE(scheduler_.active_clients_loaded());
1516   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1517             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1518                                                 kBackgroundRouteId));
1519   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1520             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1521                                                 kBackgroundRouteId2));
1522   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1523             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1524   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1525             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1526
1527   // 1 audible, 3 hidden
1528   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
1529   EXPECT_TRUE(scheduler_.active_clients_loaded());
1530   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1531             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1532                                                 kBackgroundRouteId));
1533   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1534             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1535                                                 kBackgroundRouteId2));
1536   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1537             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1538   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1539             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1540
1541   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1542   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1543 }
1544
1545 TEST_F(ResourceSchedulerTest, HiddenLoadedChangesCorrectlyStayThrottled) {
1546   // TODO(aiolos): remove when throttling and coalescing have both landed
1547   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1548                                           false /* should_coalesce */);
1549   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1550   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1551
1552   // 1 visible and 2 hidden loading, 1 visible loaded
1553   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1554   EXPECT_FALSE(scheduler_.active_clients_loaded());
1555   EXPECT_EQ(ResourceScheduler::THROTTLED,
1556             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1557                                                 kBackgroundRouteId));
1558   EXPECT_EQ(ResourceScheduler::THROTTLED,
1559             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1560                                                 kBackgroundRouteId2));
1561   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1562             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1563   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1564             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1565
1566   // 1 visible and 1 hidden loading, 1 visible and 1 hidden loaded
1567   scheduler_.OnLoadingStateChanged(
1568       kBackgroundChildId2, kBackgroundRouteId2, true);
1569   EXPECT_FALSE(scheduler_.active_clients_loaded());
1570   EXPECT_EQ(ResourceScheduler::THROTTLED,
1571             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1572                                                 kBackgroundRouteId));
1573   EXPECT_EQ(ResourceScheduler::THROTTLED,
1574             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1575                                                 kBackgroundRouteId2));
1576   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1577             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1578   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1579             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1580
1581   // 1 visible loading, 1 visible and 2 hidden loaded
1582   scheduler_.OnLoadingStateChanged(
1583       kBackgroundChildId, kBackgroundRouteId, true);
1584   EXPECT_FALSE(scheduler_.active_clients_loaded());
1585   EXPECT_EQ(ResourceScheduler::THROTTLED,
1586             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1587                                                 kBackgroundRouteId));
1588   EXPECT_EQ(ResourceScheduler::THROTTLED,
1589             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1590                                                 kBackgroundRouteId2));
1591   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1592             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1593   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1594             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1595
1596   // 1 visible and 1 hidden loading, 1 visible and 1 hidden loaded
1597   scheduler_.OnLoadingStateChanged(
1598       kBackgroundChildId2, kBackgroundRouteId2, true);
1599   EXPECT_FALSE(scheduler_.active_clients_loaded());
1600   EXPECT_EQ(ResourceScheduler::THROTTLED,
1601             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1602                                                 kBackgroundRouteId));
1603   EXPECT_EQ(ResourceScheduler::THROTTLED,
1604             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1605                                                 kBackgroundRouteId2));
1606   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1607             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1608   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1609             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1610
1611   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1612   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1613 }
1614
1615 TEST_F(ResourceSchedulerTest, PartialVisibleClientLoadedDoesNotUnthrottle) {
1616   // TODO(aiolos): remove when throttling and coalescing have both landed
1617   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1618                                           false /* should_coalesce */);
1619   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1620   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1621
1622   // 2 visible loading, 1 hidden loading, 1 hidden loaded
1623   scheduler_.OnLoadingStateChanged(
1624       kBackgroundChildId2, kBackgroundRouteId2, true);
1625   EXPECT_FALSE(scheduler_.active_clients_loaded());
1626   EXPECT_EQ(ResourceScheduler::THROTTLED,
1627             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1628                                                 kBackgroundRouteId));
1629   EXPECT_EQ(ResourceScheduler::THROTTLED,
1630             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1631                                                 kBackgroundRouteId2));
1632   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1633             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1634   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1635             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1636
1637   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
1638   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1639   EXPECT_FALSE(scheduler_.active_clients_loaded());
1640   EXPECT_EQ(ResourceScheduler::THROTTLED,
1641             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1642                                                 kBackgroundRouteId));
1643   EXPECT_EQ(ResourceScheduler::THROTTLED,
1644             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1645                                                 kBackgroundRouteId2));
1646   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1647             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1648   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1649             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1650
1651   // 2 visible loading, 1 hidden loading, 1 hidden loaded
1652   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
1653   EXPECT_FALSE(scheduler_.active_clients_loaded());
1654   EXPECT_EQ(ResourceScheduler::THROTTLED,
1655             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1656                                                 kBackgroundRouteId));
1657   EXPECT_EQ(ResourceScheduler::THROTTLED,
1658             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1659                                                 kBackgroundRouteId2));
1660   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1661             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1662   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1663             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1664
1665   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1666   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1667 }
1668
1669 TEST_F(ResourceSchedulerTest, FullVisibleLoadedCorrectlyUnthrottle) {
1670   // TODO(aiolos): remove when throttling and coalescing have both landed
1671   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1672                                           false /* should_coalesce */);
1673   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1674   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1675
1676   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
1677   scheduler_.OnLoadingStateChanged(
1678       kBackgroundChildId2, kBackgroundRouteId2, true);
1679   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
1680   EXPECT_FALSE(scheduler_.active_clients_loaded());
1681   EXPECT_EQ(ResourceScheduler::THROTTLED,
1682             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1683                                                 kBackgroundRouteId));
1684   EXPECT_EQ(ResourceScheduler::THROTTLED,
1685             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1686                                                 kBackgroundRouteId2));
1687   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1688             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1689   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1690             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1691
1692   scoped_ptr<TestRequest> high(
1693       NewBackgroundRequest("http://host/high", net::HIGHEST));
1694   scoped_ptr<TestRequest> low(
1695       NewBackgroundRequest("http://host/low", net::LOWEST));
1696
1697   EXPECT_TRUE(high->started());
1698   EXPECT_FALSE(low->started());
1699
1700   // 2 visible loaded, 1 hidden loading, 1 hidden loaded
1701   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1702   EXPECT_TRUE(scheduler_.active_clients_loaded());
1703   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1704             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1705                                                 kBackgroundRouteId));
1706   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1707             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1708                                                 kBackgroundRouteId2));
1709   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1710             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1711   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1712             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1713   // kBackgroundClientId unthrottling should unthrottle it's request.
1714   EXPECT_TRUE(low->started());
1715
1716   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
1717   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
1718   EXPECT_FALSE(scheduler_.active_clients_loaded());
1719   EXPECT_EQ(ResourceScheduler::THROTTLED,
1720             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1721                                                 kBackgroundRouteId));
1722   EXPECT_EQ(ResourceScheduler::THROTTLED,
1723             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1724                                                 kBackgroundRouteId2));
1725   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1726             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1727   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1728             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1729
1730   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1731   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1732 }
1733
1734 TEST_F(ResourceSchedulerTest,
1735        ActiveAndLoadingClientDeletedCorrectlyUnthrottle) {
1736   // TODO(aiolos): remove when throttling and coalescing have both landed
1737   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1738                                           false /* should_coalesce */);
1739   scheduler_.OnClientCreated(kChildId2, kRouteId2, true);
1740   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1741
1742   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
1743   scheduler_.OnLoadingStateChanged(
1744       kBackgroundChildId2, kBackgroundRouteId2, true);
1745   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1746   EXPECT_FALSE(scheduler_.active_clients_loaded());
1747   EXPECT_EQ(ResourceScheduler::THROTTLED,
1748             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1749                                                 kBackgroundRouteId));
1750   EXPECT_EQ(ResourceScheduler::THROTTLED,
1751             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1752                                                 kBackgroundRouteId2));
1753   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1754             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1755   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1756             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
1757
1758   // 1 visible loaded, 1 hidden loading, 1 hidden loaded
1759   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
1760   EXPECT_TRUE(scheduler_.active_clients_loaded());
1761   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1762             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1763                                                 kBackgroundRouteId));
1764   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1765             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1766                                                 kBackgroundRouteId2));
1767   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1768             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1769
1770   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
1771   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
1772   EXPECT_FALSE(scheduler_.active_clients_loaded());
1773   EXPECT_EQ(ResourceScheduler::THROTTLED,
1774             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1775                                                 kBackgroundRouteId));
1776   EXPECT_EQ(ResourceScheduler::THROTTLED,
1777             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1778                                                 kBackgroundRouteId2));
1779   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1780             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1781
1782   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1783 }
1784
1785 TEST_F(ResourceSchedulerTest, CoalescedClientCreationStartsTimer) {
1786   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1787                                           true /* should_coalesce */);
1788   EXPECT_FALSE(mock_timer_->IsRunning());
1789   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1790   EXPECT_FALSE(mock_timer_->IsRunning());
1791   scheduler_.OnLoadingStateChanged(
1792       kBackgroundChildId, kBackgroundRouteId, true);
1793   EXPECT_EQ(ResourceScheduler::COALESCED,
1794             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1795                                                 kBackgroundRouteId));
1796   EXPECT_TRUE(mock_timer_->IsRunning());
1797 }
1798
1799 TEST_F(ResourceSchedulerTest, ActiveLoadingClientLoadedAndHiddenStartsTimer) {
1800   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1801                                           true /* should_coalesce */);
1802   EXPECT_FALSE(mock_timer_->IsRunning());
1803   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1804             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1805   EXPECT_EQ(ResourceScheduler::THROTTLED,
1806             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1807                                                 kBackgroundRouteId));
1808   EXPECT_FALSE(mock_timer_->IsRunning());
1809
1810   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1811   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1812             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1813   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1814             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1815                                                 kBackgroundRouteId));
1816   EXPECT_FALSE(mock_timer_->IsRunning());
1817
1818   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1819   EXPECT_EQ(ResourceScheduler::COALESCED,
1820             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1821   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1822             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1823                                                 kBackgroundRouteId));
1824   EXPECT_TRUE(mock_timer_->IsRunning());
1825 }
1826
1827 TEST_F(ResourceSchedulerTest, ActiveLoadingClientHiddenAndLoadedStartsTimer) {
1828   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1829                                           true /* should_coalesce */);
1830   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1831             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1832   EXPECT_EQ(ResourceScheduler::THROTTLED,
1833             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1834                                                 kBackgroundRouteId));
1835   EXPECT_FALSE(mock_timer_->IsRunning());
1836
1837   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
1838   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1839             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1840   EXPECT_FALSE(mock_timer_->IsRunning());
1841
1842   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1843   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1844             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1845                                                 kBackgroundRouteId));
1846   EXPECT_EQ(ResourceScheduler::COALESCED,
1847             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
1848   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1849             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1850                                                 kBackgroundRouteId));
1851   EXPECT_TRUE(mock_timer_->IsRunning());
1852 }
1853
1854 TEST_F(ResourceSchedulerTest, CoalescedClientBecomesAudibleStopsTimer) {
1855   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1856                                           true /* should_coalesce */);
1857   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1858   EXPECT_FALSE(mock_timer_->IsRunning());
1859   scheduler_.OnLoadingStateChanged(
1860       kBackgroundChildId, kBackgroundRouteId, true);
1861   EXPECT_EQ(ResourceScheduler::COALESCED,
1862             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1863                                                 kBackgroundRouteId));
1864   EXPECT_TRUE(mock_timer_->IsRunning());
1865
1866   scheduler_.OnAudibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
1867   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1868             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1869                                                 kBackgroundRouteId));
1870   EXPECT_FALSE(mock_timer_->IsRunning());
1871 }
1872
1873 TEST_F(ResourceSchedulerTest, LastCoalescedClientDeletionStopsTimer) {
1874   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1875                                           true /* should_coalesce */);
1876   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1877   EXPECT_FALSE(mock_timer_->IsRunning());
1878   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1879   EXPECT_FALSE(mock_timer_->IsRunning());
1880   scheduler_.OnLoadingStateChanged(
1881       kBackgroundChildId, kBackgroundRouteId, true);
1882   EXPECT_EQ(ResourceScheduler::COALESCED,
1883             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1884                                                 kBackgroundRouteId));
1885   scheduler_.OnLoadingStateChanged(
1886       kBackgroundChildId2, kBackgroundRouteId2, true);
1887   EXPECT_EQ(ResourceScheduler::COALESCED,
1888             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1889                                                 kBackgroundRouteId2));
1890   EXPECT_TRUE(mock_timer_->IsRunning());
1891
1892   scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
1893   EXPECT_TRUE(mock_timer_->IsRunning());
1894
1895   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1896   EXPECT_FALSE(mock_timer_->IsRunning());
1897
1898   // To avoid errors on test tear down.
1899   scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId, false);
1900 }
1901
1902 TEST_F(ResourceSchedulerTest, LastCoalescedClientStartsLoadingStopsTimer) {
1903   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1904                                           true /* should_coalesce */);
1905   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1906   EXPECT_FALSE(mock_timer_->IsRunning());
1907   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1908   EXPECT_FALSE(mock_timer_->IsRunning());
1909   scheduler_.OnLoadingStateChanged(
1910       kBackgroundChildId, kBackgroundRouteId, true);
1911   EXPECT_EQ(ResourceScheduler::COALESCED,
1912             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1913                                                 kBackgroundRouteId));
1914   scheduler_.OnLoadingStateChanged(
1915       kBackgroundChildId2, kBackgroundRouteId2, true);
1916   EXPECT_EQ(ResourceScheduler::COALESCED,
1917             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1918                                                 kBackgroundRouteId2));
1919   EXPECT_TRUE(mock_timer_->IsRunning());
1920
1921   scheduler_.OnLoadingStateChanged(
1922       kBackgroundChildId, kBackgroundRouteId, false);
1923   EXPECT_TRUE(mock_timer_->IsRunning());
1924
1925   scheduler_.OnLoadingStateChanged(
1926       kBackgroundChildId2, kBackgroundRouteId2, false);
1927   EXPECT_FALSE(mock_timer_->IsRunning());
1928
1929   // This is needed to avoid errors on test tear down.
1930   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1931 }
1932
1933 TEST_F(ResourceSchedulerTest, LastCoalescedClientBecomesVisibleStopsTimer) {
1934   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1935                                           true /* should_coalesce */);
1936   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
1937   EXPECT_FALSE(mock_timer_->IsRunning());
1938   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1939   EXPECT_FALSE(mock_timer_->IsRunning());
1940   scheduler_.OnLoadingStateChanged(
1941       kBackgroundChildId, kBackgroundRouteId, true);
1942   EXPECT_EQ(ResourceScheduler::COALESCED,
1943             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1944                                                 kBackgroundRouteId));
1945   scheduler_.OnLoadingStateChanged(
1946       kBackgroundChildId2, kBackgroundRouteId2, true);
1947   EXPECT_EQ(ResourceScheduler::COALESCED,
1948             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
1949                                                 kBackgroundRouteId2));
1950   EXPECT_TRUE(mock_timer_->IsRunning());
1951
1952   scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
1953   EXPECT_TRUE(mock_timer_->IsRunning());
1954
1955   scheduler_.OnVisibilityChanged(
1956       kBackgroundChildId2, kBackgroundRouteId2, true);
1957   EXPECT_FALSE(mock_timer_->IsRunning());
1958
1959   // To avoid errors on test tear down.
1960   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
1961 }
1962
1963 TEST_F(ResourceSchedulerTest,
1964        CoalescedClientBecomesLoadingAndVisibleStopsTimer) {
1965   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1966                                           true /* should_coalesce */);
1967   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1968   EXPECT_FALSE(mock_timer_->IsRunning());
1969   scheduler_.OnLoadingStateChanged(
1970       kBackgroundChildId, kBackgroundRouteId, true);
1971   EXPECT_EQ(ResourceScheduler::COALESCED,
1972             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1973                                                 kBackgroundRouteId));
1974   EXPECT_TRUE(mock_timer_->IsRunning());
1975
1976   scheduler_.OnLoadingStateChanged(
1977       kBackgroundChildId, kBackgroundRouteId, false);
1978   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
1979             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1980                                                 kBackgroundRouteId));
1981   EXPECT_FALSE(mock_timer_->IsRunning());
1982
1983   scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
1984   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
1985             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1986                                                 kBackgroundRouteId));
1987   EXPECT_FALSE(mock_timer_->IsRunning());
1988 }
1989
1990 TEST_F(ResourceSchedulerTest, CoalescedRequestsIssueOnTimer) {
1991   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
1992                                           true /* should_coalesce */);
1993   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
1994   scheduler_.OnLoadingStateChanged(
1995       kBackgroundChildId, kBackgroundRouteId, true);
1996   EXPECT_EQ(ResourceScheduler::COALESCED,
1997             scheduler_.GetClientStateForTesting(kBackgroundChildId,
1998                                                 kBackgroundRouteId));
1999   EXPECT_TRUE(scheduler_.active_clients_loaded());
2000
2001   scoped_ptr<TestRequest> high(
2002       NewBackgroundRequest("http://host/high", net::HIGHEST));
2003   scoped_ptr<TestRequest> low(
2004       NewBackgroundRequest("http://host/low", net::LOWEST));
2005   EXPECT_FALSE(high->started());
2006   EXPECT_FALSE(low->started());
2007
2008   FireCoalescingTimer();
2009
2010   EXPECT_TRUE(high->started());
2011   EXPECT_TRUE(low->started());
2012 }
2013
2014 TEST_F(ResourceSchedulerTest, CoalescedRequestsUnthrottleCorrectlyOnTimer) {
2015   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
2016                                           true /* should_coalesce */);
2017   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
2018   scheduler_.OnLoadingStateChanged(
2019       kBackgroundChildId, kBackgroundRouteId, true);
2020   EXPECT_EQ(ResourceScheduler::COALESCED,
2021             scheduler_.GetClientStateForTesting(kBackgroundChildId,
2022                                                 kBackgroundRouteId));
2023   EXPECT_TRUE(scheduler_.active_clients_loaded());
2024
2025   scoped_ptr<TestRequest> high(
2026       NewBackgroundRequest("http://host/high", net::HIGHEST));
2027   scoped_ptr<TestRequest> high2(
2028       NewBackgroundRequest("http://host/high", net::HIGHEST));
2029   scoped_ptr<TestRequest> high3(
2030       NewBackgroundRequest("http://host/high", net::HIGHEST));
2031   scoped_ptr<TestRequest> high4(
2032       NewBackgroundRequest("http://host/high", net::HIGHEST));
2033   scoped_ptr<TestRequest> low(
2034       NewBackgroundRequest("http://host/low", net::LOWEST));
2035   scoped_ptr<TestRequest> low2(
2036       NewBackgroundRequest("http://host/low", net::LOWEST));
2037   scoped_ptr<TestRequest> low3(
2038       NewBackgroundRequest("http://host/low", net::LOWEST));
2039   scoped_ptr<TestRequest> low4(
2040       NewBackgroundRequest("http://host/low", net::LOWEST));
2041
2042   http_server_properties_.SetSupportsSpdy(net::HostPortPair("spdyhost", 443),
2043                                           true);
2044   scoped_ptr<TestRequest> low_spdy(
2045       NewBackgroundRequest("https://spdyhost/low", net::LOW));
2046   scoped_ptr<TestRequest> sync_request(
2047       NewBackgroundSyncRequest("http://host/req", net::LOW));
2048   scoped_ptr<TestRequest> non_http_request(
2049       NewBackgroundRequest("chrome-extension://req", net::LOW));
2050
2051   // Sync requests should issue immediately.
2052   EXPECT_TRUE(sync_request->started());
2053   // Non-http(s) requests should issue immediately.
2054   EXPECT_TRUE(non_http_request->started());
2055   // Nothing else should issue without a timer fire.
2056   EXPECT_FALSE(high->started());
2057   EXPECT_FALSE(high2->started());
2058   EXPECT_FALSE(high3->started());
2059   EXPECT_FALSE(high4->started());
2060   EXPECT_FALSE(low->started());
2061   EXPECT_FALSE(low2->started());
2062   EXPECT_FALSE(low3->started());
2063   EXPECT_FALSE(low4->started());
2064   EXPECT_FALSE(low_spdy->started());
2065
2066   FireCoalescingTimer();
2067
2068   // All high priority requests should issue.
2069   EXPECT_TRUE(high->started());
2070   EXPECT_TRUE(high2->started());
2071   EXPECT_TRUE(high3->started());
2072   EXPECT_TRUE(high4->started());
2073   // There should only be one net::LOWEST priority request issued with
2074   // non-delayable requests in flight.
2075   EXPECT_TRUE(low->started());
2076   EXPECT_FALSE(low2->started());
2077   EXPECT_FALSE(low3->started());
2078   EXPECT_FALSE(low4->started());
2079   // Spdy-Enable requests should issue regardless of priority.
2080   EXPECT_TRUE(low_spdy->started());
2081 }
2082
2083 TEST_F(ResourceSchedulerTest, CoalescedRequestsWaitForNextTimer) {
2084   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
2085                                           true /* should_coalesce */);
2086   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
2087   scheduler_.OnLoadingStateChanged(
2088       kBackgroundChildId, kBackgroundRouteId, true);
2089
2090   EXPECT_EQ(ResourceScheduler::COALESCED,
2091             scheduler_.GetClientStateForTesting(kBackgroundChildId,
2092                                                 kBackgroundRouteId));
2093   EXPECT_TRUE(scheduler_.active_clients_loaded());
2094
2095   scoped_ptr<TestRequest> high(
2096       NewBackgroundRequest("http://host/high", net::HIGHEST));
2097   EXPECT_FALSE(high->started());
2098
2099   FireCoalescingTimer();
2100
2101   scoped_ptr<TestRequest> high2(
2102       NewBackgroundRequest("http://host/high2", net::HIGHEST));
2103   scoped_ptr<TestRequest> low(
2104       NewBackgroundRequest("http://host/low", net::LOWEST));
2105
2106   EXPECT_TRUE(high->started());
2107   EXPECT_FALSE(high2->started());
2108   EXPECT_FALSE(low->started());
2109
2110   FireCoalescingTimer();
2111
2112   EXPECT_TRUE(high->started());
2113   EXPECT_TRUE(high2->started());
2114   EXPECT_TRUE(low->started());
2115 }
2116
2117 TEST_F(ResourceSchedulerTest, GetVisualSignalFromRenderViewHost) {
2118   scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory;
2119   scoped_ptr<TestBrowserContext> browser_context;
2120   scoped_ptr<TestWebContents> web_contents_1;
2121   scoped_ptr<TestWebContents> web_contents_2;
2122
2123   render_process_host_factory.reset(new MockRenderProcessHostFactory());
2124   browser_context.reset(new TestBrowserContext());
2125   scoped_refptr<SiteInstance> site_instance_1 =
2126       SiteInstance::Create(browser_context.get());
2127   scoped_refptr<SiteInstance> site_instance_2 =
2128       SiteInstance::Create(browser_context.get());
2129   SiteInstanceImpl::set_render_process_host_factory(
2130           render_process_host_factory.get());
2131
2132   web_contents_1.reset(
2133       TestWebContents::Create(browser_context.get(), site_instance_1.get()));
2134   web_contents_2.reset(
2135       TestWebContents::Create(browser_context.get(), site_instance_2.get()));
2136   base::RunLoop().RunUntilIdle();
2137
2138   RenderViewHostImpl* rvh1 = web_contents_1->GetRenderViewHost();
2139   RenderViewHostImpl* rvh2 = web_contents_2->GetRenderViewHost();
2140   ResourceScheduler* scheduler = ResourceDispatcherHostImpl::Get()->scheduler();
2141
2142   // Check initial visibility is set correctly.
2143   EXPECT_EQ(scheduler->IsClientVisibleForTesting(rvh1->GetProcess()->GetID(),
2144                                                  rvh1->GetRoutingID()),
2145             !rvh1->is_hidden());
2146   EXPECT_EQ(scheduler->IsClientVisibleForTesting(rvh2->GetProcess()->GetID(),
2147                                                  rvh1->GetRoutingID()),
2148             !rvh2->is_hidden());
2149
2150   // 1 visible, 1 hidden
2151   rvh1->WasShown(ui::LatencyInfo());
2152   rvh2->WasHidden();
2153   base::RunLoop().RunUntilIdle();
2154
2155   EXPECT_TRUE(scheduler->IsClientVisibleForTesting(rvh1->GetProcess()->GetID(),
2156                                                    rvh1->GetRoutingID()));
2157   EXPECT_FALSE(scheduler->IsClientVisibleForTesting(rvh2->GetProcess()->GetID(),
2158                                                     rvh2->GetRoutingID()));
2159
2160   // Flip the visibility and check again.
2161   rvh1->WasHidden();
2162   rvh2->WasShown(ui::LatencyInfo());
2163   base::RunLoop().RunUntilIdle();
2164
2165   EXPECT_FALSE(scheduler->IsClientVisibleForTesting(rvh1->GetProcess()->GetID(),
2166                                                     rvh1->GetRoutingID()));
2167   EXPECT_TRUE(scheduler->IsClientVisibleForTesting(rvh2->GetProcess()->GetID(),
2168                                                    rvh2->GetRoutingID()));
2169   // Clean up.
2170   web_contents_1.reset();
2171   web_contents_2.reset();
2172   base::RunLoop().RunUntilIdle();
2173
2174   browser_context.reset();
2175   render_process_host_factory.reset();
2176 }
2177
2178 }  // unnamed namespace
2179
2180 }  // namespace content