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"
@@ skipping 367 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_InIsolation) {
   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);
   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_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::MouseDown);
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      blink::WebInputEvent::MouseUp);
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      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(
+      blink::WebInputEvent::MouseDown);
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      blink::WebInputEvent::MouseMove);
+  EnableIdleTasks();
+  RunUntilIdle();
+  // Note compositor tasks are not prioritized.
+  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(
@@ skipping 153 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