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();
+  // OOPS?
   // Note compositor tasks are not prioritized.

[Sami, 2017/04/27 17:38:17]

It *should* be fine to prioritize compositor tasks if they're fast, but this
might trigger some surprises especially with high refresh rate mice. Let's try
landing to see what comes up.

[Dan Elphick, 2017/05/03 09:41:06]

Done.

   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();
+  // TODO(delphick): this comment suggests we've got this wrong?

[Sami, 2017/04/27 17:38:17]

Similarly this test predates the "compositor is fast" check, but let's see what
happens.

[Dan Elphick, 2017/05/03 09:41:06]

Done.

   // 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