Fix for uninitialized access.

content/browser/loader/resource_scheduler_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/loader/resource_scheduler.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 119 matching lines @@
 
   FakeResourceContext context_;
 };
 
 class ResourceSchedulerTest : public testing::Test {
  protected:
   ResourceSchedulerTest()
       : next_request_id_(0),
         ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {
-    // TODO(aiolos): remove when throttling and coalescing have both landed
-    scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
-                                            false /* should_coalesce */);
 
     scheduler_.OnClientCreated(kChildId, kRouteId);
     scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
     scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId);
     context_.set_http_server_properties(http_server_properties_.GetWeakPtr());
   }
 
   virtual ~ResourceSchedulerTest() {
     scheduler_.OnClientDeleted(kChildId, kRouteId);
     scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
@@ skipping 386 matching lines @@
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewRequest("chrome-extension://req", net::LOWEST));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, ActiveLoadingSyncSchedulesImmediately) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed

[mmenke, 2014/07/16 17:37:02]

nit:  Capitalize + add period (For all of these)

+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewSyncRequest("http://host/req", net::LOWEST));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, UnthrottledSyncSchedulesImmediately) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
@@ skipping 39 matching lines @@
   // Reprioritize a request after we learn the server supports SPDY.
   EXPECT_TRUE(low2_spdy->started());
   http_server_properties_.SetSupportsSpdy(
       net::HostPortPair("spdyhost2", 8080), true);
   ChangeRequestPriority(low2_spdy.get(), net::LOWEST);
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   EXPECT_TRUE(low2->started());
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledClientCreation) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_TRUE(scheduler_.should_throttle());
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
 
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, ActiveClientThrottleUpdateOnLoadingChange) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 }
 
@@ skipping 25 matching lines @@
                                                 kBackgroundRouteId));
 
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, false);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest, OneRequestPerThrottledClient) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
 
   EXPECT_TRUE(high->started());
   EXPECT_FALSE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, UnthrottleNewlyVisibleClient) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
   EXPECT_FALSE(request->started());
 
   scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, UnthrottleNewlyAudibleClient) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
   EXPECT_FALSE(request->started());
 
   scheduler_.OnAudibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, VisibleClientStillUnthrottledOnAudabilityChange) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, false);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest, AudibleClientStillUnthrottledOnVisabilityChange) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledClientStartsNextHighestPriorityRequest) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
   // Lower priority request started first to test request prioritizaton.
   scoped_ptr<TestRequest> low(
       NewBackgroundRequest("http://host/high", net::IDLE));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
 
   EXPECT_FALSE(low->started());
   EXPECT_FALSE(high->started());
 
   // request->CancelRequest();
   request->Cancel();
   EXPECT_TRUE(high->started());
   EXPECT_FALSE(low->started());
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledSpdyProxySchedulesImmediately) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
 
   EXPECT_FALSE(request->started());
 
@@ skipping 51 matching lines @@
   scheduler_.OnReceivedSpdyProxiedHttpResponse(kBackgroundChildId,
                                                kBackgroundRouteId);
   EXPECT_FALSE(request->started());
 
   scoped_ptr<TestRequest> after(
       NewBackgroundRequest("http://host/after", net::IDLE));
   EXPECT_FALSE(after->started());
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledNonHTTPSchedulesImmediately) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(
       NewBackgroundRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("chrome-extension://req", net::LOWEST));
   EXPECT_TRUE(request->started());
   EXPECT_FALSE(low->started());
@@ skipping 14 matching lines @@
   scoped_ptr<TestRequest> low(
       NewBackgroundRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("chrome-extension://req", net::LOWEST));
   EXPECT_TRUE(request->started());
   EXPECT_FALSE(low->started());
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledSyncSchedulesImmediately) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(
       NewBackgroundRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
   EXPECT_TRUE(request->started());
   EXPECT_FALSE(low->started());
@@ skipping 15 matching lines @@
       NewBackgroundRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewBackgroundSyncRequest("http://host/req", net::LOWEST));
   EXPECT_TRUE(request->started());
   EXPECT_FALSE(low->started());
   EXPECT_FALSE(high->started());
 }
 
 TEST_F(ResourceSchedulerTest, AllBackgroundClientsUnthrottle) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_FALSE(scheduler_.active_clients_loaded());
 
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
@@ skipping 21 matching lines @@
       kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest,
        UnloadedClientVisibilityChangedCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
 
   // 1 visible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
@@ skipping 33 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest,
        UnloadedClientAudibilityChangedCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
 
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 34 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest,
        LoadedClientVisibilityChangedCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   // 1 visible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
@@ skipping 32 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest,
        LoadedClientAudibilityChangedCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 33 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesHiddenCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
 
   // 2 visible, 2 hidden
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
@@ skipping 46 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesSilentCorrectlyUnthrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
   // 2 audible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 47 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, LoadedClientBecomesHiddenCorrectlyThrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
   // 2 visible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
@@ skipping 46 matching lines @@
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, LoadedClientBecomesSilentCorrectlyThrottles) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
   // 2 audible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
@@ skipping 48 matching lines @@
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, HiddenLoadedChangesCorrectlyStayThrottled) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
 
   // 1 visible and 2 hidden loading, 1 visible loaded
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
@@ skipping 48 matching lines @@
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, PartialVisibleClientLoadedDoesNotUnthrottle) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
 
   // 2 visible loading, 1 hidden loading, 1 hidden loaded
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
@@ skipping 32 matching lines @@
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, FullVisibleLoadedCorrectlyUnthrottle) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
 
   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 44 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest,
        ActiveAndLoadingClientDeletedCorrectlyUnthrottle) {
+  // TODO(aiolos): remove when throttling and coalescing have both landed
+  scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
+                                          false /* should_coalesce */);
   scheduler_.OnClientCreated(kChildId2, kRouteId2);
   scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
   scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
 
   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 30 matching lines @@
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 }  // unnamed namespace
 
 }  // namespace content