Schedule bitmap animation timers on the compositor task runner.

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 550 matching lines @@
   }
 
   void GetQueueingTimeEstimatorLock() {
     scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteBegin();
   }
 
   void DropQueueingTimeEstimatorLock() {
     scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteEnd();
   }
 
+  void RunSlowCompositorTask() {
+    // Run a long compositor task so that compositor tasks appear to be running
+    // slow and thus compositor tasks will not be prioritized.
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(1000)));
+    RunUntilIdle();
+  }
+
   // 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 248 matching lines @@
   EXPECT_EQ(1, run_count);  // We should still be in the new idle period.
 }
 
 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                   std::string("L1"), std::string("D1"),
+                                   std::string("D2"), std::string("I1")));
+  EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+}
+
+TEST_F(RendererSchedulerImplTest, TestDefaultPolicyWithSlowCompositor) {
+  RunSlowCompositorTask();
+
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
+
+  EnableIdleTasks();
+  RunUntilIdle();
+  EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1"),
                                    std::string("C1"), std::string("D2"),
                                    std::string("C2"), std::string("I1")));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
@@ skipping 401 matching lines @@
   std::string default_order_expected[] = {
       std::string("D1"), std::string("C1"), std::string("T1"),
       std::string("L1"), std::string("D2"), std::string("C2"),
       std::string("T2"), std::string("L2"), std::string("I1")};
   EXPECT_THAT(run_order, testing::ElementsAreArray(default_order_expected));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
+  RunSlowCompositorTask();
+
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::kMouseMove),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) {
+  RunSlowCompositorTask();
+
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::kMouseMove),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
@@ skipping 200 matching lines @@
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("D2"),
                                    std::string("I1"), std::string("C1"),
                                    std::string("C2")));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
             CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresKeyboardEvents) {
+  RunSlowCompositorTask();
+
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::kKeyDown),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresKeyboardEvents) {
+  RunSlowCompositorTask();
+
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::kKeyDown),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(run_order,
@@ skipping 849 matching lines @@
   // Assume that the renderer is backgrounded.
   scheduler_->OnRendererBackgrounded();
 
   // Tasks in some queues don't fire when the renderer is suspended.
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
   scheduler_->SuspendRenderer();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
+              testing::ElementsAre(std::string("C1"), std::string("D1"),
                                    std::string("I1")));
 
   // The rest queued tasks fire when the tab goes foregrounded.
   run_order.clear();
   scheduler_->OnRendererForegrounded();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("T1")));
 
   run_order.clear();
@@ skipping 11 matching lines @@
   // Assume that the renderer is backgrounded.
   scheduler_->OnRendererBackgrounded();
 
   // Tasks in some queues don't fire when the renderer is suspended.
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
   scheduler_->SuspendRenderer();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
+              testing::ElementsAre(std::string("C1"), std::string("D1"),
                                    std::string("I1")));
 
   // The rest queued tasks fire when the renderer is resumed.
   run_order.clear();
   scheduler_->ResumeRenderer();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("T1")));
 
   run_order.clear();
   // No crash occurs when the renderer is suspended again, and
   // tasks in some queues don't fire because of suspended.
   PostTestTasks(&run_order, "D2 C2 L2 I2 T2");
   scheduler_->SuspendRenderer();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D2"), std::string("C2"),
+              testing::ElementsAre(std::string("C2"), std::string("D2"),
                                    std::string("I2")));
 
   // The rest queued tasks fire when the renderer is resumed.
   run_order.clear();
   scheduler_->ResumeRenderer();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L2"), std::string("T2")));
 
   run_order.clear();
@@ skipping 1434 matching lines @@
   EXPECT_TRUE(
       scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold()));
   // Once we've dropped the lock, we realize the main thread is responsive.
   DropQueueingTimeEstimatorLock();
   EXPECT_FALSE(
       scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold()));
 }
 
 }  // namespace scheduler
 }  // namespace blink