A better idle time estimator

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 248 matching lines @@
         make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_->GetSchedulerHelperForTesting()
         ->GetTaskQueueManagerForTesting()
         ->SetTimeSourceForTesting(
             make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_->GetLoadingTaskCostEstimatorForTesting()
         ->SetTimeSourceForTesting(
             make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_->GetTimerTaskCostEstimatorForTesting()->SetTimeSourceForTesting(
         make_scoped_ptr(new TestTimeSource(clock_.get())));
+    scheduler_->GetIdleTimeEstimatorForTesting()->SetTimeSourceForTesting(
+        make_scoped_ptr(new TestTimeSource(clock_.get())));
   }
 
   void TearDown() override {
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     scheduler_->Shutdown();
     if (mock_task_runner_.get()) {
       // Check that all tests stop posting tasks.
       mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
       while (mock_task_runner_->RunUntilIdle()) {
       }
     } else {
       message_loop_->RunUntilIdle();
     }
     scheduler_.reset();
   }
 
   void RunUntilIdle() {
     // Only one of mock_task_runner_ or message_loop_ should be set.
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get())
       mock_task_runner_->RunUntilIdle();
     else
       message_loop_->RunUntilIdle();
   }
 
   void DoMainFrame() {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
+        base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void ForceMainThreadScrollingUseCase() {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
+        base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
   }
 
   void ForceTouchStartToBeExpectedSoon() {
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollEnd),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     clock_->Advance(priority_escalation_after_input_duration() * 2);
     scheduler_->ForceUpdatePolicy();
@@ skipping 13 matching lines @@
                                        base::TimeDelta::FromMilliseconds(500)));
     }
 
     RunUntilIdle();
 
     // Switch back to not auto-advancing because we want to be in control of
     // when time advances.
     mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
   }
 
+  void WillBeginMainThreadGestureFrame() {
+    scheduler_->DidAnimateForInputOnCompositorThread();
+    cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
+        base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
+    begin_frame_args.on_critical_path = true;
+    scheduler_->WillBeginFrame(begin_frame_args);
+  }
+
+  void SimulateMainThreadGestureCompositorTask(
+      base::TimeDelta begin_main_frame_duration) {
+    WillBeginMainThreadGestureFrame();
+    clock_->Advance(begin_main_frame_duration);
+    scheduler_->DidCommitFrameToCompositor();
+  }
+
+  void SimulateTimerTask(base::TimeDelta duration) {
+    clock_->Advance(duration);
+    simulate_timer_task_ran_ = true;
+  }
+
   void EnableIdleTasks() { DoMainFrame(); }
 
   UseCase CurrentUseCase() {
     return scheduler_->MainThreadOnly().current_use_case;
   }
 
   UseCase ForceUpdatePolicyAndGetCurrentUseCase() {
     scheduler_->ForceUpdatePolicy();
     return scheduler_->MainThreadOnly().current_use_case;
   }
 
   bool TouchStartExpectedSoon() {
     return scheduler_->MainThreadOnly().touchstart_expected_soon;
   }
 
   bool HaveSeenABeginMainframe() {
     return scheduler_->MainThreadOnly().have_seen_a_begin_main_frame;
   }
 
   bool LoadingTasksSeemExpensive() {
     return scheduler_->MainThreadOnly().loading_tasks_seem_expensive;
   }
 
   bool TimerTasksSeemExpensive() {
     return scheduler_->MainThreadOnly().timer_tasks_seem_expensive;
   }
 
+  base::TimeTicks EstimatedNextFrameBegin() {
+    return scheduler_->MainThreadOnly().estimated_next_frame_begin;
+  }
+
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'C': Compositor task
   // - 'L': Loading task
   // - 'I': Idle task
   // - 'T': Timer task
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
@@ skipping 82 matching lines @@
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_ptr<base::MessageLoop> message_loop_;
 
   scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner_;
   scoped_ptr<RendererSchedulerImplForTest> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner_;
+  bool simulate_timer_task_ran_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
 
 TEST_F(RendererSchedulerImplTest, TestPostDefaultTask) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 D2 D3 D4");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
@@ skipping 250 matching lines @@
   scheduler_->DidAnimateForInputOnCompositorThread();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
   EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 }
 
-// TODO(skyostil): Re-enable once timer blocking is re-enabled.
 TEST_F(
     RendererSchedulerImplTest,
-    DISABLED_TestCompositorPolicy_ExpensiveTimersDontRunWhenMainThreadOnCriticalPath) {
+    TestCompositorPolicy_ExpensiveTimersDontRunWhenMainThreadOnCriticalPath) {
   std::vector<std::string> run_order;
 
   SimulateExpensiveTasks(timer_task_runner_);
 
   // Timers should now be disabled during main thread user user interactions.
   PostTestTasks(&run_order, "C1 T1");
 
   // Trigger main_thread_gesture UseCase
-  scheduler_->DidAnimateForInputOnCompositorThread();
-  cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
-  begin_frame_args1.on_critical_path = true;
-  scheduler_->WillBeginFrame(begin_frame_args1);
+  WillBeginMainThreadGestureFrame();
   RunUntilIdle();
   EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
   clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
 
   run_order.clear();
   RunUntilIdle();
   EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest, Navigation_ResetsTaskCostEstimations) {
   std::vector<std::string> run_order;
 
   SimulateExpensiveTasks(timer_task_runner_);
   scheduler_->OnNavigationStarted();
   PostTestTasks(&run_order, "C1 T1");
 
-  scheduler_->DidAnimateForInputOnCompositorThread();
-  cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
-  begin_frame_args1.on_critical_path = true;
-  scheduler_->WillBeginFrame(begin_frame_args1);
+  WillBeginMainThreadGestureFrame();
   scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
   RunUntilIdle();
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_TimersAlwaysRun_MainThreadNotOnCriticalPath) {
   std::vector<std::string> run_order;
@@ skipping 1302 matching lines @@
   RunUntilIdle();
 
   EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_TRUE(HaveSeenABeginMainframe());
   EXPECT_TRUE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
   EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
 }
 
+TEST_F(RendererSchedulerImplTest, ModeratelyExpensiveTimer_NotBlocked) {
+  for (int i = 0; i < 20; i++) {
+    simulate_timer_task_ran_ = false;
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &RendererSchedulerImplTest::SimulateMainThreadGestureCompositorTask,
+            base::Unretained(this), base::TimeDelta::FromMilliseconds(4)));
+    timer_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
+                              base::Unretained(this),
+                              base::TimeDelta::FromMilliseconds(10)));
 
+    RunUntilIdle();
+    EXPECT_TRUE(simulate_timer_task_ran_);
+    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE,
+              CurrentUseCase());
+    EXPECT_FALSE(LoadingTasksSeemExpensive());
+    EXPECT_FALSE(TimerTasksSeemExpensive());
+
+    base::TimeDelta time_till_next_frame =
+        EstimatedNextFrameBegin() - clock_->NowTicks();
+    if (time_till_next_frame > base::TimeDelta())
+      clock_->Advance(time_till_next_frame);
+  }
+}
+
+TEST_F(RendererSchedulerImplTest, ExpensiveTimer_Blocked) {
+  for (int i = 0; i < 20; i++) {
+    simulate_timer_task_ran_ = false;
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &RendererSchedulerImplTest::SimulateMainThreadGestureCompositorTask,
+            base::Unretained(this), base::TimeDelta::FromMilliseconds(8)));
+    timer_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
+                              base::Unretained(this),
+                              base::TimeDelta::FromMilliseconds(10)));
+
+    RunUntilIdle();
+    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE,
+              CurrentUseCase());
+    EXPECT_FALSE(LoadingTasksSeemExpensive());
+    if (i == 0) {
+      EXPECT_FALSE(TimerTasksSeemExpensive());
+      EXPECT_TRUE(simulate_timer_task_ran_);
+    } else {
+      EXPECT_TRUE(TimerTasksSeemExpensive());
+      EXPECT_FALSE(simulate_timer_task_ran_);
+    }
+
+    base::TimeDelta time_till_next_frame =
+        EstimatedNextFrameBegin() - clock_->NowTicks();
+    if (time_till_next_frame > base::TimeDelta())
+      clock_->Advance(time_till_next_frame);
+  }
+}
 }  // namespace scheduler