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