Reland fix unit tests to enable them testing with the rAF aligned touch input.

content/browser/renderer_host/render_widget_host_unittest.cc

 // Copyright (c) 2012 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 <stdint.h>
 
 #include <memory>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/input/input_router_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/edit_command.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/common/input_messages.h"
 #include "content/common/resize_params.h"
 #include "content/common/view_messages.h"
+#include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/keycodes/keyboard_codes.h"
@@ skipping 418 matching lines @@
   }
   bool MouseEventCallback(const blink::WebMouseEvent& /* event */) {
     return handle_mouse_event_;
   }
 
  protected:
   // testing::Test
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kValidateInputEventStream);
+    feature_list_.InitFromCommandLine(
+        features::kRafAlignedTouchInputEvents.name, "");
 
     browser_context_.reset(new TestBrowserContext());
     delegate_.reset(new MockRenderWidgetHostDelegate());
     process_ = new RenderWidgetHostProcess(browser_context_.get());
 #if defined(USE_AURA) || defined(OS_MACOSX)
     ImageTransportFactory::InitializeForUnitTests(
         std::unique_ptr<ImageTransportFactory>(
             new NoTransportImageTransportFactory));
 #endif
 #if defined(OS_ANDROID)
@@ skipping 176 matching lines @@
   std::unique_ptr<display::Screen> screen_;
   bool handle_key_press_event_;
   bool handle_mouse_event_;
   double last_simulated_event_time_seconds_;
   double simulated_event_time_delta_seconds_;
 
  private:
   SyntheticWebTouchEvent touch_event_;
 
   TestBrowserThreadBundle thread_bundle_;
+  base::test::ScopedFeatureList feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostTest);
 };
 
 #if GTEST_HAS_PARAM_TEST
 // RenderWidgetHostWithSourceTest ----------------------------------------------
 
 // This is for tests that are to be run for all source devices.
 class RenderWidgetHostWithSourceTest
     : public RenderWidgetHostTest,
@@ skipping 646 matching lines @@
 
   // Mouse press becomes touch start which in turn becomes tap.
   SimulateMouseEvent(WebInputEvent::MouseDown, 10, 10, 0, true);
   EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
   EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
 
   // Mouse drag generates touch move, cancels tap and starts scroll.
   SimulateMouseEvent(WebInputEvent::MouseMove, 10, 30, 0, true);
   EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
   EXPECT_EQ(
-      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      "GestureTapCancel GestureScrollBegin TouchScrollStarted "
+      "GestureScrollUpdate",
       GetInputMessageTypes(process_));
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, process_->sink().message_count());
 
   // Mouse drag with shift becomes pinch.
   SimulateMouseEvent(
       WebInputEvent::MouseMove, 10, 40, WebInputEvent::ShiftKey, true);
   EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
   EXPECT_EQ("GesturePinchBegin",
@@ skipping 37 matching lines @@
 
   // Another mouse down continues scroll.
   SimulateMouseEvent(WebInputEvent::MouseDown, 10, 80, 0, true);
   EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
   EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
   EXPECT_EQ(0U, process_->sink().message_count());
 
   SimulateMouseEvent(WebInputEvent::MouseMove, 10, 100, 0, true);
   EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
   EXPECT_EQ(
-      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      "GestureTapCancel GestureScrollBegin TouchScrollStarted "
+      "GestureScrollUpdate",
       GetInputMessageTypes(process_));
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, process_->sink().message_count());
 
   // Another pinch.
   SimulateMouseEvent(
       WebInputEvent::MouseMove, 10, 110, WebInputEvent::ShiftKey, true);
   EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
   EXPECT_EQ("GesturePinchBegin",
@@ skipping 33 matching lines @@
   // Another touch.
   SimulateMouseEvent(WebInputEvent::MouseDown, 10, 10, 0, true);
   EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
   EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
   EXPECT_EQ(0U, process_->sink().message_count());
 
   // Scroll.
   SimulateMouseEvent(WebInputEvent::MouseMove, 10, 30, 0, true);
   EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
   EXPECT_EQ(
-      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      "GestureTapCancel GestureScrollBegin TouchScrollStarted "
+      "GestureScrollUpdate",
       GetInputMessageTypes(process_));
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Turn off emulation during a scroll.
   host_->SetTouchEventEmulationEnabled(
       false, ui::GestureProviderConfigType::GENERIC_MOBILE);
   EXPECT_EQ(WebInputEvent::TouchCancel, host_->acked_touch_event_type());
 
   EXPECT_EQ("GestureScrollEnd", GetInputMessageTypes(process_));
@@ skipping 175 matching lines @@
   const WebInputEvent* event = std::get<0>(params);
   ui::LatencyInfo latency_info = std::get<2>(params);
 
   EXPECT_TRUE(event->type() == expected_type);
   EXPECT_TRUE(latency_info.FindLatency(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, component_id, NULL));
 
   process->sink().ClearMessages();
 }
 
+void CheckLatencyInfoComponentInGestureScrollUpdate(
+    RenderWidgetHostProcess* process,
+    int64_t component_id) {
+  EXPECT_EQ(process->sink().message_count(), 2U);
+  const IPC::Message* message = process->sink().GetMessageAt(0);
+  EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type());
+  InputMsg_HandleInputEvent::Param params;
+  EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, &params));
+
+  const WebInputEvent* event = std::get<0>(params);
+  ui::LatencyInfo latency_info = std::get<2>(params);
+
+  EXPECT_TRUE(event->type() == WebInputEvent::TouchScrollStarted);
+
+  message = process->sink().GetMessageAt(1);
+  EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type());
+  EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, &params));
+
+  event = std::get<0>(params);
+  latency_info = std::get<2>(params);
+
+  EXPECT_TRUE(event->type() == WebInputEvent::GestureScrollUpdate);
+  EXPECT_TRUE(latency_info.FindLatency(
+      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, component_id, NULL));
+
+  process->sink().ClearMessages();
+}
+
 // Tests that after input event passes through RWHI through ForwardXXXEvent()
 // or ForwardXXXEventWithLatencyInfo(), LatencyInfo component
 // ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT will always present in the
 // event's LatencyInfo.
 TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
   host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
   process_->sink().ClearMessages();
 
   // Tests RWHI::ForwardWheelEvent().
   SimulateWheelEvent(-5, 0, 0, true);
@@ skipping 23 matching lines @@
   // Tests RWHI::ForwardGestureEvent().
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   CheckLatencyInfoComponentInMessage(
       process_, GetLatencyComponentId(), WebInputEvent::GestureScrollBegin);
 
   // Tests RWHI::ForwardGestureEventWithLatencyInfo().
   SimulateGestureEventWithLatencyInfo(WebInputEvent::GestureScrollUpdate,
                                       blink::WebGestureDeviceTouchscreen,
                                       ui::LatencyInfo());
-  CheckLatencyInfoComponentInMessage(
-      process_, GetLatencyComponentId(), WebInputEvent::GestureScrollUpdate);
+  CheckLatencyInfoComponentInGestureScrollUpdate(process_,
+                                                 GetLatencyComponentId());
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Tests RWHI::ForwardTouchEventWithLatencyInfo().
   PressTouchPoint(0, 1);
   uint32_t touch_event_id = SendTouchEvent();
   InputEventAck ack(InputEventAckSource::COMPOSITOR_THREAD,
                     WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED,
                     touch_event_id);
   host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
@@ skipping 73 matching lines @@
                                       ui::LatencyInfo());
 
 
   // Tests RWHI::ForwardWheelEventWithLatencyInfo().
   SimulateWheelEventWithLatencyInfo(-5, 0, 0, true, ui::LatencyInfo());
 
   ASSERT_FALSE(host_->input_router()->HasPendingEvents());
 }
 
 }  // namespace content