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