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 817 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("L1"), std::string("D1"),
-                                   std::string("C1"), std::string("D2"),
-                                   std::string("C2"), std::string("I1")));
+              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,
        TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
@@ skipping 406 matching lines @@
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
   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.

[Sami, 2017/05/04 00:33:38]

This test is a little useless now, so let's change it to simulate a bunch of
slow compositor tasks so that it verifies the previous behavior. We can do the
same for the other two below that also say "compositor tasks are not
prioritized"

[Dan Elphick, 2017/05/04 16:47:15]

Added a new RunSlowCompositorTask method to RendererSchedulerImplTest which this
and similar methods now call to force into the mode where compositor tasks are
not prioritized.

TestDefaultPolicy doesn't use it which contrasts with
TestDefaultPolicyWithSlowCompositor to show the difference in behaviours.

   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("D2"), std::string("C2"),
+              testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                   std::string("D1"), std::string("D2"),
                                    std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) {
   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());
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("D2"), std::string("C2"),
+              testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                   std::string("D1"), std::string("D2"),
                                    std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_MouseMove_WhenMouseDown) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   // Note that currently the compositor will never consume mouse move events,
   // but this test reflects what should happen if that was the case.
@@ skipping 197 matching lines @@
   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"),
+              testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                   std::string("D1"), std::string("D2"),
                                    std::string("I1")));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresKeyboardEvents) {
   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,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("D2"), std::string("C2"),
+              testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                   std::string("D1"), std::string("D2"),
                                    std::string("I1")));
   EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
   // Note compositor tasks are not prioritized.
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::kKeyDown),
       WebInputEventResult::kHandledSystem);
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestMainthreadScrollingUseCaseDoesNotStarveDefaultTasks) {
@@ skipping 815 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 1397 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