Experimental: Remove chromium shared timers

content/renderer/scheduler/renderer_scheduler_impl_unittest.cc

Index: content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc b/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
index 4a97a0454749f11708d1fdb98d7f81e2202a5354..888bdf57422650d42bebf1f83efc4d222eb9cac9 100644
--- a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
+++ b/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
@@ -51,7 +51,8 @@ class RendererSchedulerImplTest : public testing::Test {
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
-        idle_task_runner_(scheduler_->IdleTaskRunner()) {
+        idle_task_runner_(scheduler_->IdleTaskRunner()),
+        timer_task_runner_(scheduler_->TimerTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
   ~RendererSchedulerImplTest() override {}
@@ -76,6 +77,7 @@ class RendererSchedulerImplTest : public testing::Test {
   // - '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) {
     std::istringstream stream(task_descriptor);
@@ -100,6 +102,10 @@ class RendererSchedulerImplTest : public testing::Test {
               FROM_HERE,
               base::Bind(&AppendToVectorIdleTestTask, run_order, task));
           break;
+        case 'T':
+          timer_task_runner_->PostTask(
+              FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
+          break;
         default:
           NOTREACHED();
       }
@@ -120,6 +126,7 @@ class RendererSchedulerImplTest : public testing::Test {
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
@@ -445,9 +452,10 @@ TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_DidAnimateForInput) {
 
 TEST_F(RendererSchedulerImplTest, TestTouchstartPolicy) {
   std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "L1 D1 C1 D2 C2");
+  PostTestTasks(&run_order, "L1 D1 C1 D2 C2 T1 T2");
 
-  // Observation of touchstart should defer execution of idle and loading tasks.
+  // Observation of touchstart should defer execution of timer, idle and loading
+  // tasks.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   RunUntilIdle();
@@ -465,12 +473,16 @@ TEST_F(RendererSchedulerImplTest, TestTouchstartPolicy) {
   EXPECT_TRUE(run_order.empty());
 
   // Action events like ScrollBegin will kick us back into compositor priority,
-  // allowing servie of the loading and idle queues.
+  // allowing servie of the timer, loading and idle queues.
   run_order.clear();
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
   RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("L1")));
+  // Note that the Timer tasks run before the loading task because we are in
+  // COMPOSITOR_PRIORITY policy.
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("T1"), std::string("T2"),
+                                   std::string("L1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
@@ -847,4 +859,50 @@ TEST_F(RendererSchedulerImplTest, InputArrivesAfterBeginFrame) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
+TEST_F(RendererSchedulerImplTest, TimerQueueEnabledByDefault) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "T1 T2");
+  RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("T1"), std::string("T2")));
+}
+
+TEST_F(RendererSchedulerImplTest, SuspendAndResumeTimerQueue) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "T1 T2");
+
+  scheduler_->SuspendTimerQueue();
+  RunUntilIdle();
+  EXPECT_TRUE(run_order.empty());
+
+  scheduler_->ResumeTimerQueue();
+  RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("T1"), std::string("T2")));
+}
+
+TEST_F(RendererSchedulerImplTest, MultipleSuspendsNeedMultipleResumes) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "T1 T2");
+
+  scheduler_->SuspendTimerQueue();
+  scheduler_->SuspendTimerQueue();
+  scheduler_->SuspendTimerQueue();
+  RunUntilIdle();
+  EXPECT_TRUE(run_order.empty());
+
+  scheduler_->ResumeTimerQueue();
+  RunUntilIdle();
+  EXPECT_TRUE(run_order.empty());
+
+  scheduler_->ResumeTimerQueue();
+  RunUntilIdle();
+  EXPECT_TRUE(run_order.empty());
+
+  scheduler_->ResumeTimerQueue();
+  RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("T1"), std::string("T2")));
+}
+
 }  // namespace content