scheduler: Disable expensive timers during main thread user input

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 "base/callback.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
@@ skipping 120 matching lines @@
                           bool* is_anticipated_before,
                           bool* is_anticipated_after) {
   *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
   if (simulate_input) {
     scheduler->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   }
   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 }
+
 };  // namespace
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   using RendererSchedulerImpl::OnIdlePeriodEnded;
   using RendererSchedulerImpl::OnIdlePeriodStarted;
   using RendererSchedulerImpl::Policy;
   using RendererSchedulerImpl::PolicyToString;
 
   RendererSchedulerImplForTest(
@@ skipping 460 matching lines @@
 
   scheduler_->DidAnimateForInputOnCompositorThread();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2"),
                                    std::string("I1")));
 }
 
-TEST_F(RendererSchedulerImplTest,
-       TestCompositorPolicy_TimersOnlyRunWhenIdle_MainThreadOnCriticalPath) {
+TEST_F(
+    RendererSchedulerImplTest,
+    TestCompositorPolicy_ExpensiveTimersDontRunWhenMainThreadOnCriticalPath) {
   std::vector<std::string> run_order;
+
+  // Simulate a bunch of expensive timer tasks
+  for (int i = 0; i < 10; i++) {
+    timer_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
+                              base::Unretained(clock_.get()),
+                              base::TimeDelta::FromMilliseconds(500)));
+  }
+  RunUntilIdle();
+
+  // Timers should now be disabled during main thread user userinteractions.
   PostTestTasks(&run_order, "C1 T1");
 
   scheduler_->DidAnimateForInputOnCompositorThread();
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL));
-  scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
-  RunUntilIdle();
-
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("C1"), std::string("T1")));
-
-  // End the idle period.
-  clock_->Advance(base::TimeDelta::FromMilliseconds(500));
-  scheduler_->DidAnimateForInputOnCompositorThread();
-  scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "C1 T1");
   RunUntilIdle();
 
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
+
+  run_order.clear();
+  RunUntilIdle();
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_TimersAlwaysRunIfNoRecentIdlePeriod) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "C1 T1");
 
   // Simulate no recent idle period.
   clock_->Advance(idle_period_starvation_threshold() * 2);
 
@@ skipping 1120 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());
 }
 
 }  // namespace scheduler