// Copyright 2017 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/browser/renderer_host/render_widget_host_input_event_router.h"

#include <vector>

#include "base/run_loop.h"
#include "base/test/scoped_task_environment.h"
#include "build/build_config.h"
#include "components/viz/common/features.h"
#include "components/viz/common/hit_test/aggregated_hit_test_region.h"
#include "components/viz/host/hit_test/hit_test_query.h"
#include "components/viz/host/host_frame_sink_manager.h"
#include "components/viz/test/host_frame_sink_manager_test_api.h"
#include "content/browser/compositor/surface_utils.h"
#include "content/browser/compositor/test/test_image_transport_factory.h"
#include "content/browser/renderer_host/frame_connector_delegate.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
#include "content/browser/renderer_host/render_widget_targeter.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/mock_render_widget_host_delegate.h"
#include "content/test/mock_widget_impl.h"
#include "content/test/test_render_view_host.h"
#include "services/viz/public/interfaces/hit_test/input_target_client.mojom.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace content {

namespace {

class MockFrameConnectorDelegate : public FrameConnectorDelegate {
 public:
  MockFrameConnectorDelegate(bool use_zoom_for_device_scale_factor)
      : FrameConnectorDelegate(use_zoom_for_device_scale_factor) {}
  ~MockFrameConnectorDelegate() override {}

  RenderWidgetHostViewBase* GetRootRenderWidgetHostView() override {
    return root_view_;
  }

  void set_root_view(RenderWidgetHostViewBase* root_view) {
    root_view_ = root_view;
  }

 private:
  RenderWidgetHostViewBase* root_view_;

  DISALLOW_COPY_AND_ASSIGN(MockFrameConnectorDelegate);
};

// Used as a target for the RenderWidgetHostInputEventRouter. We record what
// events were forwarded to us in order to verify that the events are being
// routed correctly.
class TestRenderWidgetHostViewChildFrame
    : public RenderWidgetHostViewChildFrame {
 public:
  explicit TestRenderWidgetHostViewChildFrame(RenderWidgetHost* widget)
      : RenderWidgetHostViewChildFrame(widget),
        frame_sink_id_(2, 1),
        last_gesture_seen_(blink::WebInputEvent::kUndefined) {}
  ~TestRenderWidgetHostViewChildFrame() override = default;

  void ProcessGestureEvent(const blink::WebGestureEvent& event,
                           const ui::LatencyInfo&) override {
    last_gesture_seen_ = event.GetType();
  }

  void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch,
                              InputEventAckState ack_result) override {
    unique_id_for_last_touch_ack_ = touch.event.unique_touch_event_id;
  }

  void SetBounds(const gfx::Rect& rect) override { bounds_ = rect; }

  gfx::Rect GetViewBounds() const override { return bounds_; }

  const viz::FrameSinkId& GetFrameSinkId() const override {
    return frame_sink_id_;
  }

  blink::WebInputEvent::Type last_gesture_seen() { return last_gesture_seen_; }
  uint32_t last_id_for_touch_ack() { return unique_id_for_last_touch_ack_; }

  void Reset() { last_gesture_seen_ = blink::WebInputEvent::kUndefined; }

 private:
  gfx::Rect bounds_;
  viz::FrameSinkId frame_sink_id_;
  blink::WebInputEvent::Type last_gesture_seen_;
  uint32_t unique_id_for_last_touch_ack_ = 0;
};

// The RenderWidgetHostInputEventRouter uses the root RWHV for hittesting, so
// here we stub out the hittesting logic so we can control which RWHV will be
// the result of a hittest by the RWHIER.
class MockRootRenderWidgetHostView : public TestRenderWidgetHostView {
 public:
  MockRootRenderWidgetHostView(
      RenderWidgetHost* rwh,
      std::map<RenderWidgetHostViewBase*, viz::FrameSinkId>& frame_sink_id_map)
      : TestRenderWidgetHostView(rwh),
        frame_sink_id_(1, 1),
        frame_sink_id_map_(frame_sink_id_map),
        current_hittest_result_(nullptr),
        force_query_renderer_on_hit_test_(false),
        last_gesture_seen_(blink::WebInputEvent::kUndefined) {}
  ~MockRootRenderWidgetHostView() override {}

  viz::FrameSinkId FrameSinkIdAtPoint(viz::SurfaceHittestDelegate*,
                                      const gfx::PointF&,
                                      gfx::PointF*,
                                      bool* query_renderer) override {
    if (force_query_renderer_on_hit_test_)
      *query_renderer = true;
    DCHECK(current_hittest_result_)
        << "Must set a Hittest result before calling this function";
    return frame_sink_id_map_[current_hittest_result_];
  }

  bool TransformPointToCoordSpaceForView(
      const gfx::PointF& point,
      RenderWidgetHostViewBase* target_view,
      gfx::PointF* transformed_point,
      viz::EventSource source = viz::EventSource::ANY) override {
    return true;
  }

  void ProcessGestureEvent(const blink::WebGestureEvent& event,
                           const ui::LatencyInfo&) override {
    last_gesture_seen_ = event.GetType();
  }

  void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch,
                              InputEventAckState ack_result) override {
    unique_id_for_last_touch_ack_ = touch.event.unique_touch_event_id;
  }

  void SetBounds(const gfx::Rect& rect) override { bounds_ = rect; }

  gfx::Rect GetViewBounds() const override { return bounds_; }

  const viz::FrameSinkId& GetFrameSinkId() const override {
    return frame_sink_id_;
  }

  viz::FrameSinkId GetRootFrameSinkId() override { return frame_sink_id_; }

  blink::WebInputEvent::Type last_gesture_seen() { return last_gesture_seen_; }
  uint32_t last_id_for_touch_ack() { return unique_id_for_last_touch_ack_; }

  void SetHittestResult(RenderWidgetHostViewBase* view) {
    current_hittest_result_ = view;
  }

  void set_force_query_renderer_on_hit_test(bool force) {
    force_query_renderer_on_hit_test_ = force;
  }

  void Reset() { last_gesture_seen_ = blink::WebInputEvent::kUndefined; }

 private:
  gfx::Rect bounds_;
  viz::FrameSinkId frame_sink_id_;
  std::map<RenderWidgetHostViewBase*, viz::FrameSinkId>& frame_sink_id_map_;
  RenderWidgetHostViewBase* current_hittest_result_;
  bool force_query_renderer_on_hit_test_;
  blink::WebInputEvent::Type last_gesture_seen_;
  uint32_t unique_id_for_last_touch_ack_ = 0;
};

}  // namespace

class RenderWidgetHostInputEventRouterTest : public testing::Test {
 public:
  RenderWidgetHostInputEventRouterTest() {}

  // Initializes the hit testing data required when
  // features::IsVizHitTestingEnabled. Where both |view_root_flags| and
  // |view_other_flags| are viz::HitTestRegionFlags, representing the type of
  // events to be responded to by each view, along with how they are processed.
  void InitVizHitTestData(int view_root_flags, int view_other_flags);

 protected:
  // testing::Test:
  void SetUp() override {
    browser_context_ = std::make_unique<TestBrowserContext>();

// ImageTransportFactory doesn't exist on Android. This is needed to create
// a RenderWidgetHostViewChildFrame in the test.
#if !defined(OS_ANDROID)
    ImageTransportFactory::SetFactory(
        std::make_unique<TestImageTransportFactory>());
#endif

    process_host1_ =
        std::make_unique<MockRenderProcessHost>(browser_context_.get());
    process_host2_ =
        std::make_unique<MockRenderProcessHost>(browser_context_.get());
    mojom::WidgetPtr widget1;
    widget_impl1_ =
        std::make_unique<MockWidgetImpl>(mojo::MakeRequest(&widget1));
    widget_host1_ = std::make_unique<RenderWidgetHostImpl>(
        &delegate_, process_host1_.get(), process_host1_->GetNextRoutingID(),
        std::move(widget1), false);
    mojom::WidgetPtr widget2;
    widget_impl2_ =
        std::make_unique<MockWidgetImpl>(mojo::MakeRequest(&widget2));
    widget_host2_ = std::make_unique<RenderWidgetHostImpl>(
        &delegate_, process_host2_.get(), process_host2_->GetNextRoutingID(),
        std::move(widget2), false);

    view_root_ = std::make_unique<MockRootRenderWidgetHostView>(
        widget_host1_.get(), frame_sink_id_map_);
    view_other_ = std::make_unique<TestRenderWidgetHostViewChildFrame>(
        widget_host2_.get());

    test_frame_connector_ = std::make_unique<MockFrameConnectorDelegate>(
        false /* use_zoom_for_device_scale_factor */);
    test_frame_connector_->set_root_view(view_root_.get());
    test_frame_connector_->SetView(view_other_.get());
    view_other_->SetFrameConnectorDelegate(test_frame_connector_.get());

    // Set up the RWHIER's FrameSinkId to RWHV map so that we can control the
    // result of RWHIER's hittesting.
    frame_sink_id_map_ = {{view_root_.get(), view_root_->GetFrameSinkId()},
                          {view_other_.get(), view_other_->GetFrameSinkId()}};
    rwhier_.AddFrameSinkIdOwner(frame_sink_id_map_[view_root_.get()],
                                view_root_.get());
    rwhier_.AddFrameSinkIdOwner(frame_sink_id_map_[view_other_.get()],
                                view_other_.get());
  }

  void TearDown() override {
    view_root_.reset();
    view_other_.reset();
    base::RunLoop().RunUntilIdle();
#if !defined(OS_ANDROID)
    ImageTransportFactory::Terminate();
#endif
  }

  RenderWidgetHostViewBase* touch_target() {
    return rwhier_.touch_target_.target;
  }
  RenderWidgetHostViewBase* touchscreen_gesture_target() {
    return rwhier_.touchscreen_gesture_target_.target;
  }

  TestBrowserThreadBundle thread_bundle_;

  MockRenderWidgetHostDelegate delegate_;
  std::unique_ptr<BrowserContext> browser_context_;
  std::unique_ptr<viz::HostFrameSinkManagerTestApi>
      host_frame_sink_manager_test_api_;
  std::unique_ptr<MockRenderProcessHost> process_host1_;
  std::unique_ptr<MockRenderProcessHost> process_host2_;
  std::unique_ptr<MockWidgetImpl> widget_impl1_;
  std::unique_ptr<RenderWidgetHostImpl> widget_host1_;
  std::unique_ptr<MockWidgetImpl> widget_impl2_;
  std::unique_ptr<RenderWidgetHostImpl> widget_host2_;

  std::unique_ptr<MockRootRenderWidgetHostView> view_root_;
  std::unique_ptr<TestRenderWidgetHostViewChildFrame> view_other_;
  std::unique_ptr<MockFrameConnectorDelegate> test_frame_connector_;

  std::map<RenderWidgetHostViewBase*, viz::FrameSinkId> frame_sink_id_map_;

  RenderWidgetHostInputEventRouter rwhier_;

 private:
  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostInputEventRouterTest);
};

void RenderWidgetHostInputEventRouterTest::InitVizHitTestData(
    int view_root_flags,
    int view_other_flags) {
  if (!features::IsVizHitTestingEnabled())
    return;
  DCHECK(GetHostFrameSinkManager());
  // Bounds chosen so that both |view_root_| and |view_other_| occupy (0, 0);
  // the default position in WebPointerProperties. This is done as the test
  // suite overrides enough of the classic hit testing path that there the
  // bounds do not matter. However Viz hit-testing always performs a contains
  // check on input events. This allows both views to handle the input
  // targetting in the tests below.
  view_root_->SetBounds(gfx::Rect(0, 0, 10, 10));
  view_other_->SetBounds(gfx::Rect(0, 0, 10, 5));

  host_frame_sink_manager_test_api_ =
      std::make_unique<viz::HostFrameSinkManagerTestApi>(
          GetHostFrameSinkManager());
  viz::HostFrameSinkManager::DisplayHitTestQueryMap hit_test_map;
  hit_test_map[view_root_->GetFrameSinkId()] =
      std::make_unique<viz::HitTestQuery>();

  std::vector<viz::AggregatedHitTestRegion> hit_test_data;
  uint32_t async_hit_test_reasons_root =
      (view_root_flags & viz::HitTestRegionFlags::kHitTestAsk)
          ? viz::AsyncHitTestReasons::kIrregularClip
          : viz::AsyncHitTestReasons::kNotAsyncHitTest;
  uint32_t async_hit_test_reasons_other =
      (view_other_flags & viz::HitTestRegionFlags::kHitTestAsk)
          ? viz::AsyncHitTestReasons::kIrregularClip
          : viz::AsyncHitTestReasons::kNotAsyncHitTest;
  hit_test_data.push_back(viz::AggregatedHitTestRegion(
      view_root_->GetFrameSinkId(), view_root_flags,
      view_root_->GetViewBounds(), gfx::Transform(), 1,
      async_hit_test_reasons_root));
  hit_test_data.push_back(viz::AggregatedHitTestRegion(
      view_other_->GetFrameSinkId(), view_other_flags,
      view_other_->GetViewBounds(), gfx::Transform(), 0,
      async_hit_test_reasons_other));
  hit_test_map[view_root_->GetFrameSinkId()]
      ->OnAggregatedHitTestRegionListUpdated(hit_test_data);

  host_frame_sink_manager_test_api_->SetDisplayHitTestQuery(
      std::move(hit_test_map));
}

// Make sure that when a touch scroll crosses out of the area for a
// RenderWidgetHostView, the RenderWidgetHostInputEventRouter continues to
// route gesture events to the same RWHV until the end of the gesture.
// See crbug.com/739831
TEST_F(RenderWidgetHostInputEventRouterTest,
       DoNotChangeTargetViewDuringTouchScrollGesture) {
  // Simulate the touch and gesture events produced from scrolling on a
  // touchscreen.

  // We start the touch in the area for |view_other_|.
  view_root_->SetHittestResult(view_other_.get());
  // Each view will want to process the touch event.
  InitVizHitTestData(viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine,
                     viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine);

  blink::WebTouchEvent touch_event(
      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests());
  touch_event.touches_length = 1;
  touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
  touch_event.unique_touch_event_id = 1;

  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(view_other_.get(), touch_target());

  blink::WebGestureEvent gesture_event(
      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests(),
      blink::kWebGestureDeviceTouchscreen);
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;

  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(view_other_.get(), touchscreen_gesture_target());
  EXPECT_EQ(blink::WebInputEvent::kGestureTapDown,
            view_other_->last_gesture_seen());
  EXPECT_NE(blink::WebInputEvent::kGestureTapDown,
            view_root_->last_gesture_seen());

  touch_event.SetType(blink::WebInputEvent::kTouchMove);
  touch_event.touches[0].state = blink::WebTouchPoint::kStateMoved;
  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));

  gesture_event.SetType(blink::WebInputEvent::kGestureTapCancel);
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollBegin);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  // The continuation of the touch moves should maintain their current target of
  // |view_other_|, even if they move outside of that view, and into
  // |view_root_|.
  //
  // Since this test is not using actual view sizes, nor event positions, we
  // need to setup our hit testing overrides to prevent targeting |view_other_|.
  //
  // If the target is maintained through the gesture this will pass. If instead
  // the hit testing logic is refered to, then this test will fail.
  view_root_->SetHittestResult(view_root_.get());
  InitVizHitTestData(viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine,
                     viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestIgnore);
  view_root_->Reset();
  view_other_->Reset();

  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  EXPECT_EQ(view_other_.get(), touch_target());
  EXPECT_EQ(view_other_.get(), touchscreen_gesture_target());
  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate,
            view_other_->last_gesture_seen());
  EXPECT_NE(blink::WebInputEvent::kGestureScrollUpdate,
            view_root_->last_gesture_seen());

  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
  touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollEnd);
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));

  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
            view_other_->last_gesture_seen());
  EXPECT_NE(blink::WebInputEvent::kGestureScrollEnd,
            view_root_->last_gesture_seen());
}

// Ensure that when RenderWidgetHostInputEventRouter receives an unexpected
// touch event, it calls the root view's method to Ack the event before
// dropping it.
TEST_F(RenderWidgetHostInputEventRouterTest, EnsureDroppedTouchEventsAreAcked) {
  // Send a touch move without a touch start.
  blink::WebTouchEvent touch_move_event(
      blink::WebInputEvent::kTouchMove, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests());
  touch_move_event.touches_length = 1;
  touch_move_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
  touch_move_event.unique_touch_event_id = 1;

  rwhier_.RouteTouchEvent(view_root_.get(), &touch_move_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(view_root_->last_id_for_touch_ack(), 1lu);

  // Send a touch cancel without a touch start.
  blink::WebTouchEvent touch_cancel_event(
      blink::WebInputEvent::kTouchCancel, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests());
  touch_cancel_event.touches_length = 1;
  touch_cancel_event.touches[0].state = blink::WebTouchPoint::kStateCancelled;
  touch_cancel_event.unique_touch_event_id = 2;

  rwhier_.RouteTouchEvent(view_root_.get(), &touch_cancel_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(view_root_->last_id_for_touch_ack(), 2lu);
}

TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceTouchEvents) {
  RenderWidgetTargeter* targeter = rwhier_.GetRenderWidgetTargeterForTests();
  view_root_->SetHittestResult(view_root_.get());
  view_root_->set_force_query_renderer_on_hit_test(true);
  // Also force the renderer to be queried.
  InitVizHitTestData(viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine |
                         viz::HitTestRegionFlags::kHitTestAsk,
                     viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine |
                         viz::HitTestRegionFlags::kHitTestAsk);

  // We need to set up a comm pipe, or else the targeter will crash when it
  // tries to query the renderer. It doesn't matter that the pipe isn't
  // connected on the other end, as we really don't want it to respond anyways.
  std::unique_ptr<service_manager::InterfaceProvider> remote_interfaces =
      std::make_unique<service_manager::InterfaceProvider>();
  viz::mojom::InputTargetClientPtr input_target_client;
  remote_interfaces->GetInterface(&input_target_client);
  widget_host1_->SetInputTargetClient(std::move(input_target_client));

  // Send TouchStart, TouchMove, TouchMove, TouchMove, TouchEnd and make sure
  // the targeter doesn't attempt to coalesce.
  blink::WebTouchEvent touch_event(
      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests());
  touch_event.touches_length = 1;
  touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
  touch_event.unique_touch_event_id = 1;

  EXPECT_EQ(0u, targeter->num_requests_in_queue_for_testing());
  EXPECT_FALSE(targeter->is_request_in_flight_for_testing());
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(0u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  touch_event.SetType(blink::WebInputEvent::kTouchMove);
  touch_event.touches[0].state = blink::WebTouchPoint::kStateMoved;
  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(1u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(2u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
  touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));

  EXPECT_EQ(3u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
}

TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceGestureEvents) {
  RenderWidgetTargeter* targeter = rwhier_.GetRenderWidgetTargeterForTests();
  view_root_->SetHittestResult(view_root_.get());
  view_root_->set_force_query_renderer_on_hit_test(true);
  // Also force the renderer to be queried.
  InitVizHitTestData(viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine |
                         viz::HitTestRegionFlags::kHitTestAsk,
                     viz::HitTestRegionFlags::kHitTestTouch |
                         viz::HitTestRegionFlags::kHitTestMine |
                         viz::HitTestRegionFlags::kHitTestAsk);

  // We need to set up a comm pipe, or else the targeter will crash when it
  // tries to query the renderer. It doesn't matter that the pipe isn't
  // connected on the other end, as we really don't want it to respond anyways.
  std::unique_ptr<service_manager::InterfaceProvider> remote_interfaces =
      std::make_unique<service_manager::InterfaceProvider>();
  viz::mojom::InputTargetClientPtr input_target_client;
  remote_interfaces->GetInterface(&input_target_client);
  widget_host1_->SetInputTargetClient(std::move(input_target_client));

  // Send TouchStart, GestureTapDown, TouchEnd, GestureScrollBegin,
  // GestureScrollUpdate (x2), GestureScrollEnd and make sure
  // the targeter doesn't attempt to coalesce.
  blink::WebTouchEvent touch_event(
      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests());
  touch_event.touches_length = 1;
  touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
  touch_event.unique_touch_event_id = 1;

  EXPECT_EQ(0u, targeter->num_requests_in_queue_for_testing());
  EXPECT_FALSE(targeter->is_request_in_flight_for_testing());
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(0u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  blink::WebGestureEvent gesture_event(
      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
      blink::WebInputEvent::GetStaticTimeStampForTests(),
      blink::kWebGestureDeviceTouchscreen);
  gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(1u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
  touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
  touch_event.unique_touch_event_id += 1;
  rwhier_.RouteTouchEvent(view_root_.get(), &touch_event,
                          ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(2u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollBegin);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(3u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(4u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(5u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());

  gesture_event.SetType(blink::WebInputEvent::kGestureScrollEnd);
  rwhier_.RouteGestureEvent(view_root_.get(), &gesture_event,
                            ui::LatencyInfo(ui::SourceEventType::TOUCH));
  EXPECT_EQ(6u, targeter->num_requests_in_queue_for_testing());
  EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
}

}  // namespace content