Experimental: Remove chromium shared timers

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 33 matching lines @@
  public:
   using Policy = RendererSchedulerImpl::Policy;
 
   RendererSchedulerImplTest()
       : clock_(cc::TestNowSource::Create(5000)),
         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
         scheduler_(new RendererSchedulerImpl(mock_task_runner_)),
         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 {}
 
   void RunUntilIdle() { mock_task_runner_->RunUntilIdle(); }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
   Policy CurrentPolicy() { return scheduler_->current_policy_; }
 
   // 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) {
     std::istringstream stream(task_descriptor);
     while (!stream.eof()) {
       std::string task;
       stream >> task;
       switch (task[0]) {
         case 'D':
           default_task_runner_->PostTask(
               FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
           break;
         case 'C':
           compositor_task_runner_->PostTask(
               FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
           break;
         case 'L':
           loading_task_runner_->PostTask(
               FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task));
           break;
         case 'I':
           idle_task_runner_->PostIdleTask(
               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();
       }
     }
   }
 
  protected:
   static base::TimeDelta priority_escalation_after_input_duration() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kPriorityEscalationAfterInputMillis);
   }
 
   scoped_refptr<cc::TestNowSource> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
 
   scoped_ptr<RendererSchedulerImpl> 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_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
 
 void NullTask() {
 }
 
 void AppendToVectorReentrantTask(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     std::vector<int>* vector,
@@ skipping 305 matching lines @@
   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, 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();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2")));
 
   // Meta events like TapDown/FlingCancel shouldn't affect the priority.
   run_order.clear();
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingCancel));
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureTapDown));
   RunUntilIdle();
   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,
        DidReceiveInputEventOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove));
   EnableIdleTasks();
@@ skipping 356 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Process the input event with a new BeginMainFrame.
   DoMainFrame();
   clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   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