MouseMove when the mouse is down to signal compositor priority

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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
+namespace {
+class FakeInputEvent : public blink::WebInputEvent {
+ public:
+  explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
+      : WebInputEvent(sizeof(FakeInputEvent)) {
+    type = event_type;
+  }
+
+  FakeInputEvent(blink::WebInputEvent::Type event_type, int event_modifiers)
+      : WebInputEvent(sizeof(FakeInputEvent)) {
+    type = event_type;
+    modifiers = event_modifiers;
+  }
+};
+};  // namespace
+
 class RendererSchedulerImplTest : public testing::Test {
  public:
   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()) {
@@ skipping 100 matching lines @@
 void PostingYieldingTestTask(
     RendererSchedulerImpl* scheduler,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     bool simulate_input,
     bool* should_yield_before,
     bool* should_yield_after) {
   *should_yield_before = scheduler->ShouldYieldForHighPriorityWork();
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   if (simulate_input) {
     scheduler->DidReceiveInputEventOnCompositorThread(
-        blink::WebInputEvent::GestureFlingStart);
+        FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   }
   *should_yield_after = scheduler->ShouldYieldForHighPriorityWork();
 }
 
 void AnticipationTestTask(RendererSchedulerImpl* scheduler,
                           bool simulate_input,
                           bool* is_anticipated_before,
                           bool* is_anticipated_after) {
   *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
   if (simulate_input) {
     scheduler->DidReceiveInputEventOnCompositorThread(
-        blink::WebInputEvent::GestureFlingStart);
+        FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   }
   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 }
 
 TEST_F(RendererSchedulerImplTest, TestPostDefaultTask) {
   int result = 0;
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 1, &result));
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 2, &result));
@@ skipping 184 matching lines @@
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
-      blink::WebInputEvent::GestureFlingStart);
+      FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(order, testing::ElementsAre(
       std::string("C1"), std::string("C2"), std::string("D1"),
       std::string("D2"), std::string("L1"), std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_DidAnimateForInput) {
   std::vector<std::string> order;
 
@@ skipping 15 matching lines @@
 
   scheduler_->DidAnimateForInputOnCompositorThread();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("C2"),
                                           std::string("D1"), std::string("D2"),
                                           std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       DidReceiveInputEventOnCompositorThread_IgnoresMouseEvents) {
+       DidReceiveInputEventOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
   std::vector<std::string> order;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
-      blink::WebInputEvent::MouseMove);
+      FakeInputEvent(blink::WebInputEvent::MouseMove));
   EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(order, testing::ElementsAre(std::string("D1"), std::string("C1"),
                                           std::string("D2"), std::string("C2"),
                                           std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
+       DidReceiveInputEventOnCompositorThread_MouseMove_WhenMouseDown) {
+  std::vector<std::string> order;
+
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
+
+  scheduler_->DidReceiveInputEventOnCompositorThread(FakeInputEvent(
+      blink::WebInputEvent::MouseMove, blink::WebInputEvent::LeftButtonDown));
+  EnableIdleTasks();
+  RunUntilIdle();
+  // Note compositor tasks are not prioritized.

[Sami, 2015/02/10 14:02:45]

s/are not/are/

+  EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("C2"),
+                                          std::string("D1"), std::string("D2"),
+                                          std::string("I1")));
+}
+
+TEST_F(RendererSchedulerImplTest,
        DidReceiveInputEventOnCompositorThread_IgnoresKeyboardEvents) {
   std::vector<std::string> order;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
-      blink::WebInputEvent::KeyDown);
+      FakeInputEvent(blink::WebInputEvent::KeyDown));
   EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(order, testing::ElementsAre(std::string("D1"), std::string("C1"),
                                           std::string("D2"), std::string("C2"),
                                           std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicyDoesNotStarveDefaultTasks) {
   std::vector<std::string> order;
 
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
   for (int i = 0; i < 20; i++) {
     compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   }
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
-      blink::WebInputEvent::GestureFlingStart);
+      FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
   // Ensure that the default D1 task gets to run at some point before the final
   // C2 compositor task.
   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("D1"),
                                           std::string("C2")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestCompositorPolicyEnds) {
   std::vector<std::string> order;
 
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
-      blink::WebInputEvent::GestureFlingStart);
+      FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
   EXPECT_THAT(order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2")));
 
   order.clear();
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));
 
   default_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 80 matching lines @@
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             compositor_task_runner_, true, &should_yield_before,
                             &should_yield_after));
   RunUntilIdle();
   // We should be able to switch to compositor priority mid-task.
   EXPECT_FALSE(should_yield_before);
   EXPECT_TRUE(should_yield_after);
 }
 
 }  // namespace content