Separate rAF aligned Touch and Mouse Input settings

content/renderer/input/main_thread_event_queue_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <new>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/strings/string_util.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_simple_task_runner.h"
 #include "build/build_config.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/renderer/input/main_thread_event_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_scheduler.h"
 
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 
 namespace blink {
 bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) {
   return memcmp(&lhs, &rhs, lhs.size) == 0;
 }
 
 bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) {
   return memcmp(&lhs, &rhs, lhs.size) == 0;
 }
 }  // namespace blink
 
 namespace content {
 namespace {
 
+const unsigned kRafAlignedEnabledTouch = 1;
+const unsigned kRafAlignedEnabledMouse = 1 << 1;
+
 const int kTestRoutingID = 13;
 const char* kCoalescedCountHistogram =
     "Event.MainThreadEventQueue.CoalescedCount";
 
 }  // namespace
 
-class MainThreadEventQueueTest : public testing::TestWithParam<bool>,
+class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
                                  public MainThreadEventQueueClient {
  public:
   MainThreadEventQueueTest()
       : main_task_runner_(new base::TestSimpleTaskRunner()),
-        handle_raf_aligned_input_(GetParam()),
+        raf_aligned_input_setting_(GetParam()),
         needs_main_frame_(false) {
-    if (handle_raf_aligned_input_)
-      feature_list_.InitAndEnableFeature(features::kRafAlignedInputEvents);
+    std::vector<std::string> features;
+    if (raf_aligned_input_setting_ & kRafAlignedEnabledTouch)
+      features.push_back(features::kRafAlignedTouchInputEvents.name);
+    if (raf_aligned_input_setting_ & kRafAlignedEnabledMouse)
+      features.push_back(features::kRafAlignedMouseInputEvents.name);
+
+    feature_list_.InitFromCommandLine(base::JoinString(features, ","),
+                                      std::string());
   }
 
   void SetUp() override {
     queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_,
                                       &renderer_scheduler_);
   }
 
   void HandleEventOnMainThread(int routing_id,
                                const blink::WebInputEvent* event,
                                const ui::LatencyInfo& latency,
@@ skipping 48 matching lines @@
     }
   }
 
  protected:
   base::test::ScopedFeatureList feature_list_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
   std::vector<ui::ScopedWebInputEvent> handled_events_;
   std::vector<uint32_t> additional_acked_events_;
-  bool handle_raf_aligned_input_;
+  int raf_aligned_input_setting_;
   bool needs_main_frame_;
 };
 
 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   base::HistogramTester histogram_tester;
 
   WebMouseWheelEvent kEvents[4] = {
       SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
   };
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
 
   for (WebMouseWheelEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
-  EXPECT_EQ(handle_raf_aligned_input_, !main_task_runner_->HasPendingTask());
+  EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0,
+            main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
 
   {
     EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
     EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
     const WebMouseWheelEvent* last_wheel_event =
         static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
@@ skipping 119 matching lines @@
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
 
   HandleEvent(kWheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kTouchEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
-  EXPECT_EQ(handle_raf_aligned_input_, !main_task_runner_->HasPendingTask());
+  EXPECT_EQ(raf_aligned_input_setting_ !=
+                (kRafAlignedEnabledMouse | kRafAlignedEnabledTouch),
+            main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
   {
     EXPECT_EQ(kWheelEvents[0].size, handled_events_.at(0)->size);
     EXPECT_EQ(kWheelEvents[0].type, handled_events_.at(0)->type);
     const WebMouseWheelEvent* last_wheel_event =
         static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
@@ skipping 12 matching lines @@
     WebTouchEvent coalesced_event = kTouchEvents[0];
     internal::Coalesce(kTouchEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_touch_event);
   }
 }
 
 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) {
   // Don't run the test when we aren't supporting rAF aligned input.
-  if (!handle_raf_aligned_input_)
+  if ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0)
     return;
 
   WebMouseEvent mouseDown =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseDown, 10, 10, 0);
 
   WebMouseEvent mouseMove =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove, 10, 10, 0);
 
   WebMouseEvent mouseUp =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseUp, 10, 10, 0);
@@ skipping 34 matching lines @@
   EXPECT_EQ(2u, event_queue().size());
   main_task_runner_->RunUntilIdle();
   EXPECT_TRUE(needs_main_frame_);
   EXPECT_EQ(1u, event_queue().size());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_EQ(0u, event_queue().size());
 }
 
 TEST_P(MainThreadEventQueueTest, RafAlignedTouchInput) {
   // Don't run the test when we aren't supporting rAF aligned input.
-  if (!handle_raf_aligned_input_)
+  if ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0)
     return;
 
   SyntheticWebTouchEvent kEvents[3];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].MovePoint(0, 50, 50);
   kEvents[2].PressPoint(10, 10);
   kEvents[2].ReleasePoint(0);
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
@@ skipping 54 matching lines @@
   EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
   EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
   const WebTouchEvent* last_touch_event =
       static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
   kEvents[0].dispatchedDuringFling = true;
   kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
   EXPECT_EQ(kEvents[0], *last_touch_event);
 
   kEvents[0].MovePoint(0, 30, 30);
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(handle_raf_aligned_input_, !main_task_runner_->HasPendingTask());
+  EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0,
+            main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
   EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size);
   EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type);
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
       static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
   kEvents[0].dispatchedDuringFling = true;
@@ skipping 96 matching lines @@
   EXPECT_FALSE(kEvents[0].dispatchedDuringFling);
   EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
       static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
   EXPECT_EQ(kEvents[0], *last_touch_event);
 }
 
 // The boolean parameterized test varies whether rAF aligned input
 // is enabled or not.
-INSTANTIATE_TEST_CASE_P(MainThreadEventQueueTests,
-                        MainThreadEventQueueTest,
-                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(
+    MainThreadEventQueueTests,
+    MainThreadEventQueueTest,
+    testing::Range(0u,
+                   (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1));
 
 }  // namespace content