Move responsiblity of tab suspending from renderer to TabManager

components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

 // Copyright 2014 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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 513 matching lines @@
   static base::TimeDelta end_idle_when_hidden_delay() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kEndIdleWhenHiddenDelayMillis);
   }
 
   static base::TimeDelta idle_period_starvation_threshold() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kIdlePeriodStarvationThresholdMillis);
   }
 
-  static base::TimeDelta suspend_timers_when_backgrounded_delay() {
-    return base::TimeDelta::FromMilliseconds(
-        RendererSchedulerImpl::kSuspendTimersWhenBackgroundedDelayMillis);
-  }
-
   static base::TimeDelta rails_response_time() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kRailsResponseTimeMillis);
   }
 
   template <typename E>
   static void CallForEachEnumValue(E first,
                                    E last,
                                    const char* (*function)(E)) {
     for (E val = first; val < last;
@@ skipping 1534 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplTest, ShutdownPreventsPostingOfNewTasks) {
   scheduler_->Shutdown();
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 C1");
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 }
 
-TEST_F(RendererSchedulerImplTest, TestRendererBackgroundedTimerSuspension) {
-  scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled(true);
-
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "T1 T2");
-
-  // The background signal will not immediately suspend the timer queue.
-  scheduler_->OnRendererBackgrounded();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("T1"), std::string("T2")));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "T3");
-  RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T3")));
-
-  // Advance the time until after the scheduled timer queue suspension.
-  run_order.clear();
-  clock_->Advance(suspend_timers_when_backgrounded_delay() +
-                  base::TimeDelta::FromMilliseconds(10));
-  RunUntilIdle();
-  ASSERT_TRUE(run_order.empty());
-
-  // Timer tasks should be suspended until the foregrounded signal.
-  PostTestTasks(&run_order, "T4 T5");
-  RunUntilIdle();
-  EXPECT_TRUE(run_order.empty());
-
-  scheduler_->OnRendererForegrounded();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("T4"), std::string("T5")));
-
-  // Subsequent timer tasks should fire as usual.
-  run_order.clear();
-  PostTestTasks(&run_order, "T6");
-  RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T6")));
-}
-
 TEST_F(RendererSchedulerImplTest,
        ExpensiveLoadingTasksNotBlockedTillFirstBeginMainFrame) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
 
@@ skipping 656 matching lines @@
 
   // Make sure TouchStart causes a policy change.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   EXPECT_EQ(RendererScheduler::UseCase::TOUCHSTART,
             ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 }  // namespace scheduler