[scheduler] Throttle default timer queue when renderer is backgrounded.

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
index 9fd59734250fe178ee82fe3a7310573805246941..2e1985656a9f7e5f53c739783a75faede3cdb58b 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
@@ -176,6 +176,25 @@ void AnticipationTestTask(RendererSchedulerImpl* scheduler,
   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 }
 
+// RAII helper class to enable auto advancing of time inside mock task runner.
+// Automatically disables auto-advancement when destroyed.
+class AutoAdvanceNowEnabler {

[Sami, 2016/12/06 19:09:10]

bikeshed: ScopedAutoAdvanceNow is what I'd expect this to be called :)

[altimin, 2016/12/07 11:20:09]

Done.

+ public:
+  AutoAdvanceNowEnabler(scoped_refptr<cc::OrderedSimpleTaskRunner> task_runner)
+      : task_runner_(task_runner) {
+    task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  }
+
+  ~AutoAdvanceNowEnabler() {
+    task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+  }
+
+ private:
+  scoped_refptr<cc::OrderedSimpleTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutoAdvanceNowEnabler);
+};
+
 };  // namespace
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
@@ -319,7 +338,7 @@ class RendererSchedulerImplTest : public testing::Test {
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
     // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
     // tasks unless we set AutoAdvanceNow to true :/
-    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+    AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
 
     // Simulate a bunch of expensive tasks
     for (int i = 0; i < 10; i++) {
@@ -330,10 +349,6 @@ class RendererSchedulerImplTest : public testing::Test {
     }
 
     RunUntilIdle();
-
-    // Switch back to not auto-advancing because we want to be in control of
-    // when time advances.
-    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
   }
 
   enum class TouchEventPolicy {
@@ -719,7 +734,7 @@ TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
 }
 
 TEST_F(RendererSchedulerImplTest, TestIdleTaskExceedsDeadline) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
   int run_count = 0;
 
   // Post two UpdateClockToDeadlineIdleTestTask tasks.
@@ -1694,7 +1709,7 @@ TEST_F(RendererSchedulerImplWithMockSchedulerTest,
 
 TEST_F(RendererSchedulerImplWithMockSchedulerTest,
        OnePendingDelayedAndOneUrgentUpdatePolicy) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
 
   mock_scheduler_->ScheduleDelayedPolicyUpdate(
       clock_->NowTicks(), base::TimeDelta::FromMilliseconds(1));
@@ -1708,7 +1723,7 @@ TEST_F(RendererSchedulerImplWithMockSchedulerTest,
 
 TEST_F(RendererSchedulerImplWithMockSchedulerTest,
        OneUrgentAndOnePendingDelayedUpdatePolicy) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
 
   mock_scheduler_->EnsureUrgentPolicyUpdatePostedOnMainThread();
   mock_scheduler_->ScheduleDelayedPolicyUpdate(
@@ -1833,7 +1848,7 @@ TEST_F(RendererSchedulerImplWithMockSchedulerTest,
 
 TEST_F(RendererSchedulerImplWithMockSchedulerTest,
        EnsureUpdatePolicyNotTriggeredTooOften) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
 
   EXPECT_EQ(0, mock_scheduler_->update_policy_count_);
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
@@ -2010,7 +2025,7 @@ TEST_F(RendererSchedulerImplTest,
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodRepeating) {
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
@@ -2251,6 +2266,8 @@ TEST_F(RendererSchedulerImplTest, SuspendRenderer) {
 }
 
 TEST_F(RendererSchedulerImplTest, ResumeRenderer) {
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
+
   // Assume that the renderer is backgrounded.
   scheduler_->OnRendererBackgrounded();
 
@@ -2340,26 +2357,35 @@ TEST_F(RendererSchedulerImplTest, TestRendererBackgroundedTimerSuspension) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "T1 T2");
 
+  base::TimeTicks now;
+
   // The background signal will not immediately suspend the timer queue.
   scheduler_->OnRendererBackgrounded();
+  now += base::TimeDelta::FromMilliseconds(1100);
+  clock_->SetNowTicks(now);
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 
   run_order.clear();
   PostTestTasks(&run_order, "T3");
+
+  now += base::TimeDelta::FromSeconds(1);
+  clock_->SetNowTicks(now);
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T3")));
 
   // Advance the time until after the scheduled timer queue suspension.
+  now = base::TimeTicks() + suspend_timers_when_backgrounded_delay() +
+        base::TimeDelta::FromMilliseconds(10);
   run_order.clear();
-  clock_->Advance(suspend_timers_when_backgrounded_delay() +
-                  base::TimeDelta::FromMilliseconds(10));
+  clock_->SetNowTicks(now);
   RunUntilIdle();
   ASSERT_TRUE(run_order.empty());
 
   // Timer tasks should be suspended until the foregrounded signal.
   PostTestTasks(&run_order, "T4 T5");
+  now += base::TimeDelta::FromSeconds(10);
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
@@ -3518,5 +3544,46 @@ TEST_F(RendererSchedulerImplTest, EnableVirtualTime) {
             scheduler_->GetVirtualTimeDomain());
 }
 
+namespace {
+
+void RecordingTimeTestTask(std::vector<base::TimeTicks>* run_times,
+                           base::SimpleTestTickClock* clock) {
+  run_times->push_back(clock->NowTicks());
+}
+
+}  // namespace
+
+TEST_F(RendererSchedulerImplTest,
+       DefaultTimerTasksAreThrottledWhenBackgrounded) {
+  AutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
+
+  scheduler_->OnRendererBackgrounded();
+
+  std::vector<base::TimeTicks> run_times;
+
+  timer_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&RecordingTimeTestTask, &run_times, clock_.get()));
+
+  mock_task_runner_->RunUntilTime(base::TimeTicks() +
+                                  base::TimeDelta::FromMilliseconds(1100));
+
+  EXPECT_THAT(run_times, testing::ElementsAre(base::TimeTicks() +
+                                              base::TimeDelta::FromSeconds(1)));
+  run_times.clear();
+
+  timer_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&RecordingTimeTestTask, &run_times, clock_.get()),
+      base::TimeDelta::FromMilliseconds(200));
+
+  scheduler_->OnRendererForegrounded();
+
+  mock_task_runner_->RunUntilTime(base::TimeTicks() +
+                                  base::TimeDelta::FromMilliseconds(1500));
+
+  EXPECT_THAT(run_times,
+              testing::ElementsAre(base::TimeTicks() +
+                                   base::TimeDelta::FromMilliseconds(1300)));
+}
+
 }  // namespace scheduler
 }  // namespace blink