Async Wheel Event with only the first one cancellable behind a flag.

content/browser/renderer_host/input/legacy_input_router_impl_unittest.cc

 // Copyright 2013 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/input/legacy_input_router_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 131 matching lines @@
   for (size_t i = 0; i < subset.size(); ++i) {
     bool equivalent = TouchEventsAreEquivalent(*(subset[i]), *(set[i]));
     if (!equivalent)
       return false;
   }
 
   return true;
 }
 #endif  // defined(USE_AURA)
 
+enum WheelScrollingMode {
+  kWheelScrollingModeNone,
+  kWheelScrollLatching,
+  kAsyncWheelEvents,
+};
+
 }  // namespace
 
 class LegacyInputRouterImplTest : public testing::Test {
  public:
-  LegacyInputRouterImplTest(bool raf_aligned_touch = true,
-                            bool wheel_scroll_latching = true)
-      : scoped_task_environment_(
+  LegacyInputRouterImplTest(
+      bool raf_aligned_touch = true,
+      WheelScrollingMode wheel_scrolling_mode = kWheelScrollLatching)
+      : wheel_scroll_latching_enabled_(wheel_scrolling_mode !=
+                                       kWheelScrollingModeNone),
+        scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI) {
-    if (raf_aligned_touch && wheel_scroll_latching) {
+    if (raf_aligned_touch && wheel_scrolling_mode == kAsyncWheelEvents) {
+      feature_list_.InitWithFeatures({features::kRafAlignedTouchInputEvents,
+                                      features::kTouchpadAndWheelScrollLatching,
+                                      features::kAsyncWheelEvents},
+                                     {});
+    } else if (raf_aligned_touch &&
+               wheel_scrolling_mode == kWheelScrollLatching) {
       feature_list_.InitWithFeatures(
           {features::kRafAlignedTouchInputEvents,
            features::kTouchpadAndWheelScrollLatching},
-          {});
-    } else if (raf_aligned_touch && !wheel_scroll_latching) {
-      feature_list_.InitWithFeatures(
-          {features::kRafAlignedTouchInputEvents},
-          {features::kTouchpadAndWheelScrollLatching});
-    } else if (!raf_aligned_touch && wheel_scroll_latching) {
+          {features::kAsyncWheelEvents});
+    } else if (raf_aligned_touch &&
+               wheel_scrolling_mode == kWheelScrollingModeNone) {
+      feature_list_.InitWithFeatures({features::kRafAlignedTouchInputEvents},
+                                     {features::kTouchpadAndWheelScrollLatching,
+                                      features::kAsyncWheelEvents});
+    } else if (!raf_aligned_touch &&
+               wheel_scrolling_mode == kAsyncWheelEvents) {
+      feature_list_.InitWithFeatures({features::kTouchpadAndWheelScrollLatching,
+                                      features::kAsyncWheelEvents},
+                                     {features::kRafAlignedTouchInputEvents});
+    } else if (!raf_aligned_touch &&
+               wheel_scrolling_mode == kWheelScrollLatching) {
       feature_list_.InitWithFeatures(
           {features::kTouchpadAndWheelScrollLatching},
-          {features::kRafAlignedTouchInputEvents});
-    } else {  // !raf_aligned_touch && !wheel_scroll_latching
-      feature_list_.InitWithFeatures(
-          {}, {features::kRafAlignedTouchInputEvents,
-               features::kTouchpadAndWheelScrollLatching});
+          {features::kRafAlignedTouchInputEvents, features::kAsyncWheelEvents});
+    } else {  // !raf_aligned_touch && wheel_scroll_latching ==
+              // kWheelScrollingModeNone.
+      feature_list_.InitWithFeatures({},
+                                     {features::kRafAlignedTouchInputEvents,
+                                      features::kTouchpadAndWheelScrollLatching,
+                                      features::kAsyncWheelEvents});
     }
   }
 
   ~LegacyInputRouterImplTest() override {}
 
  protected:
   // testing::Test
   void SetUp() override {
     browser_context_.reset(new TestBrowserContext());
     process_.reset(new MockRenderProcessHost(browser_context_.get()));
@@ skipping 54 matching lines @@
                                    float dY,
                                    int modifiers,
                                    bool precise,
                                    WebMouseWheelEvent::Phase phase) {
     WebMouseWheelEvent wheel_event = SyntheticWebMouseWheelEventBuilder::Build(
         x, y, dX, dY, modifiers, precise);
     wheel_event.phase = phase;
     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(wheel_event));
   }
 
+  void SimulateWheelEventPossiblyIncludingPhase(
+      bool ignore_phase,
+      float x,
+      float y,
+      float dX,
+      float dY,
+      int modifiers,
+      bool precise,
+      WebMouseWheelEvent::Phase phase) {
+    if (ignore_phase)
+      SimulateWheelEvent(x, y, dX, dY, modifiers, precise);
+    else
+      SimulateWheelEventWithPhase(x, y, dX, dY, modifiers, precise, phase);
+  }
+
   void SimulateMouseEvent(WebInputEvent::Type type, int x, int y) {
     input_router_->SendMouseEvent(MouseEventWithLatencyInfo(
         SyntheticWebMouseEventBuilder::Build(type, x, y, 0)));
   }
 
   void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) {
     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(phase)));
   }
 
@@ skipping 111 matching lines @@
     process_->sink().ClearMessages();
     return count;
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay);
     base::RunLoop().Run();
   }
 
-  void UnhandledWheelEvent(bool wheel_scroll_latching_enabled) {
-    // Simulate wheel events.
-    if (wheel_scroll_latching_enabled) {
-      SimulateWheelEventWithPhase(
-          0, 0, 0, -5, 0, false,
-          WebMouseWheelEvent::kPhaseBegan);  // sent directly
-      SimulateWheelEventWithPhase(
-          0, 0, 0, -10, 0, false,
-          WebMouseWheelEvent::kPhaseChanged);  // enqueued
-    } else {
-      SimulateWheelEvent(0, 0, 0, -5, 0, false);   // sent directly
-      SimulateWheelEvent(0, 0, 0, -10, 0, false);  // enqueued
-    }
+  void UnhandledWheelEvent();
 
-    // Check that only the first event was sent.
-    EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-        InputMsg_HandleInputEvent::ID));
-    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-
-    // Indicate that the wheel event was unhandled.
-    SendInputEventACK(WebInputEvent::kMouseWheel,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-    // Check that the ack for the MouseWheel and ScrollBegin
-    // were processed.
-    EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
-
-    // There should be a ScrollBegin and ScrollUpdate, MouseWheel sent.
-    EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
-
-    EXPECT_EQ(ack_handler_->acked_wheel_event().delta_y, -5);
-    SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_CONSUMED);
-
-    if (wheel_scroll_latching_enabled) {
-      // Check that the ack for ScrollUpdate were processed.
-      EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
-    } else {
-      // The GestureScrollUpdate ACK releases the GestureScrollEnd.
-      EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-
-      // Check that the ack for the ScrollUpdate and ScrollEnd
-      // were processed.
-      EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
-    }
-
-    SendInputEventACK(WebInputEvent::kMouseWheel,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-    if (wheel_scroll_latching_enabled) {
-      // There should be a ScrollUpdate sent.
-      EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-      EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
-    } else {
-      // There should be a ScrollBegin and ScrollUpdate sent.
-      EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
-      EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
-    }
-
-    // Check that the correct unhandled wheel event was received.
-    EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
-              ack_handler_->acked_wheel_event_state());
-    EXPECT_EQ(ack_handler_->acked_wheel_event().delta_y, -10);
-
-    SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_CONSUMED);
-
-    if (wheel_scroll_latching_enabled) {
-      // Check that the ack for ScrollUpdate were processed.
-      EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
-    } else {
-      // The GestureScrollUpdate ACK releases the GestureScrollEnd.
-      EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-
-      // Check that the ack for the ScrollUpdate and ScrollEnd
-      // were processed.
-      EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
-    }
-  }
+  void OverscrollDispatch();
 
   InputRouter::Config config_;
   std::unique_ptr<MockRenderProcessHost> process_;
   std::unique_ptr<MockInputRouterClient> client_;
   std::unique_ptr<MockInputAckHandler> ack_handler_;
   std::unique_ptr<LegacyInputRouterImpl> input_router_;
+  bool wheel_scroll_latching_enabled_;
 
  private:
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   SyntheticWebTouchEvent touch_event_;
 
   base::test::ScopedFeatureList feature_list_;
   std::unique_ptr<TestBrowserContext> browser_context_;
 };
 
 class LegacyInputRouterImplRafAlignedTouchDisabledTest
     : public LegacyInputRouterImplTest {
  public:
   LegacyInputRouterImplRafAlignedTouchDisabledTest()
-      : LegacyInputRouterImplTest(false, false) {}
+      : LegacyInputRouterImplTest(false, kWheelScrollingModeNone) {}
 };
 
 class LegacyInputRouterImplWheelScrollLatchingDisabledTest
     : public LegacyInputRouterImplTest {
  public:
   LegacyInputRouterImplWheelScrollLatchingDisabledTest()
-      : LegacyInputRouterImplTest(true, false) {}
+      : LegacyInputRouterImplTest(true, kWheelScrollingModeNone) {}
+};
+
+class LegacyInputRouterImplAsyncWheelEventEnabledTest
+    : public LegacyInputRouterImplTest {
+ public:
+  LegacyInputRouterImplAsyncWheelEventEnabledTest()
+      : LegacyInputRouterImplTest(true, kAsyncWheelEvents) {}
 };
 
 TEST_F(LegacyInputRouterImplTest, CoalescesRangeSelection) {
   input_router_->SendInput(std::unique_ptr<IPC::Message>(
       new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))));
   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
       process_->sink().GetMessageAt(0), gfx::Point(1, 2), gfx::Point(3, 4));
   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 
   // Send two more messages without acking.
@@ skipping 73 matching lines @@
   // Send second message: MoveRangeSelectionExtent.
   input_router_->SendInput(std::unique_ptr<IPC::Message>(
       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(5, 6))));
   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 
   // Send third message: SelectRange.
   input_router_->SendInput(std::unique_ptr<IPC::Message>(
       new InputMsg_SelectRange(0, gfx::Point(7, 8), gfx::Point(9, 10))));
   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 
-  // Ack the messages and verify that they're not coalesced and that they're in
-  // correct order.
+  // Ack the messages and verify that they're not coalesced and that they're
+  // in correct order.
 
   // Ack the first message.
   {
     std::unique_ptr<IPC::Message> response(new InputHostMsg_SelectRange_ACK(0));
     input_router_->OnMessageReceived(*response);
   }
 
   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
       process_->sink().GetMessageAt(0), gfx::Point(5, 6));
   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
@@ skipping 58 matching lines @@
   input_router_->SendInput(std::unique_ptr<IPC::Message>(
       new InputMsg_MoveRangeSelectionExtent(0, gfx::Point(19, 20))));
   EXPECT_EQ(0u, GetSentMessageCountAndResetSink());
 
   // Ack the first message.
   {
     std::unique_ptr<IPC::Message> response(new InputHostMsg_SelectRange_ACK(0));
     input_router_->OnMessageReceived(*response);
   }
 
-  // Verify that the three MoveRangeSelectionExtent messages are coalesced into
-  // one message.
+  // Verify that the three MoveRangeSelectionExtent messages are coalesced
+  // into one message.
   ExpectIPCMessageWithArg1<InputMsg_MoveRangeSelectionExtent>(
       process_->sink().GetMessageAt(0), gfx::Point(9, 10));
   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
 
   // Ack the second message.
   {
     std::unique_ptr<IPC::Message> response(
         new InputHostMsg_MoveRangeSelectionExtent_ACK(0));
     input_router_->OnMessageReceived(*response);
   }
@@ skipping 94 matching lines @@
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 }
 
 TEST_F(LegacyInputRouterImplTest, NoncorrespondingKeyEvents) {
   SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
 
   SendInputEventACK(WebInputEvent::kKeyUp, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_TRUE(ack_handler_->unexpected_event_ack_called());
 }
 
-// Tests ported from RenderWidgetHostTest --------------------------------------
+// Tests ported from RenderWidgetHostTest -------------------------------------
 
 TEST_F(LegacyInputRouterImplTest, HandleKeyEventsWeSent) {
   // Simulate a keyboard event.
   SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
   ASSERT_TRUE(input_router_->GetLastKeyboardEvent());
   EXPECT_EQ(WebInputEvent::kRawKeyDown,
             input_router_->GetLastKeyboardEvent()->GetType());
 
   // Make sure we sent the input event to the renderer.
   EXPECT_TRUE(
@@ skipping 11 matching lines @@
 TEST_F(LegacyInputRouterImplTest, IgnoreKeyEventsWeDidntSend) {
   // Send a simulated, unrequested key response. We should ignore this.
   SendInputEventACK(WebInputEvent::kRawKeyDown,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
 }
 
 TEST_F(LegacyInputRouterImplTest, CoalescesWheelEvents) {
   // Simulate wheel events.
-  SimulateWheelEvent(0, 0, 0, -5, 0, false);   // sent directly
-  SimulateWheelEvent(0, 0, 0, -10, 0, false);  // enqueued
-  SimulateWheelEvent(0, 0, 8, -6, 0, false);   // coalesced into previous event
-  SimulateWheelEvent(0, 0, 9, -7, 1, false);   // enqueued, different modifiers
-  SimulateWheelEvent(0, 0, 0, -10, 0, false);  // enqueued, different modifiers
+  SimulateWheelEventPossiblyIncludingPhase(
+      !wheel_scroll_latching_enabled_, 0, 0, 0, -5, 0, false,
+      WebMouseWheelEvent::kPhaseBegan);  // sent directly
+  SimulateWheelEventPossiblyIncludingPhase(
+      !wheel_scroll_latching_enabled_, 0, 0, 0, -10, 0, false,
+      WebMouseWheelEvent::kPhaseChanged);  // enqueued
+  SimulateWheelEventPossiblyIncludingPhase(
+      !wheel_scroll_latching_enabled_, 0, 0, 8, -6, 0, false,
+      WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+  SimulateWheelEventPossiblyIncludingPhase(
+      !wheel_scroll_latching_enabled_, 0, 0, 9, -7, 1, false,
+      WebMouseWheelEvent::kPhaseChanged);  // enqueued, different modifiers
+  SimulateWheelEventPossiblyIncludingPhase(
+      !wheel_scroll_latching_enabled_, 0, 0, 0, -10, 0, false,
+      WebMouseWheelEvent::kPhaseChanged);  // enqueued, different modifiers
   // Explicitly verify that PhaseEnd isn't coalesced to avoid bugs like
   // https://crbug.com/154740.
   SimulateWheelEventWithPhase(WebMouseWheelEvent::kPhaseEnded);  // enqueued
 
   // Check that only the first event was sent.
   EXPECT_TRUE(
       process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
   const WebInputEvent* input_event =
       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
   ASSERT_EQ(WebInputEvent::kMouseWheel, input_event->GetType());
@@ skipping 129 matching lines @@
 
   SendTouchEventACK(WebInputEvent::kTouchMove, INPUT_EVENT_ACK_STATE_CONSUMED,
                     touch_move_event_id);
   EXPECT_TRUE(TouchEventQueueEmpty());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::kTouchMove,
             ack_handler_->acked_touch_event().event.GetType());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 }
 
-// Tests that the touch-queue is emptied after a page stops listening for touch
-// events and the outstanding ack is received.
+// Tests that the touch-queue is emptied after a page stops listening for
+// touch events and the outstanding ack is received.
 TEST_F(LegacyInputRouterImplTest, TouchEventQueueFlush) {
   OnHasTouchEventHandlers(true);
   EXPECT_TRUE(client_->has_touch_handler());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_TRUE(TouchEventQueueEmpty());
 
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   uint32_t touch_press_event_id = SendTouchEvent();
   MoveTouchPoint(0, 2, 2);
@@ skipping 107 matching lines @@
       break;
     expected_events.erase(expected_events.begin(),
                           expected_events.begin() + acked.size());
   }
 
   EXPECT_TRUE(TouchEventQueueEmpty());
   EXPECT_EQ(0U, expected_events.size());
 }
 #endif  // defined(USE_AURA)
 
+void LegacyInputRouterImplTest::UnhandledWheelEvent() {

[dtapuska, 2017/06/20 20:53:14]

Moving code around like this makes it *really* hard to review. I've looked at
the individual lines changed and it is fine. Just something useful for reviews
in the future.

[sahel, 2017/06/21 18:09:59]

I am sorry for the inconvenience, so I should apply the changes in place in one
patch, and only move the function in a separate patch?

+  // Simulate wheel events.
+  SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 0,
+                                           0, 0, -5, 0, false,
+                                           WebMouseWheelEvent::kPhaseBegan);
+  SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 0,
+                                           0, 0, -10, 0, false,
+                                           WebMouseWheelEvent::kPhaseChanged);
+
+  // Check that only the first event was sent.
+  EXPECT_TRUE(
+      process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+  // Indicate that the wheel event was unhandled.
+  SendInputEventACK(WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  // Check that the ack for the MouseWheel and ScrollBegin
+  // were processed.
+  EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+
+  // There should be a ScrollBegin and ScrollUpdate, MouseWheel sent.
+  EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
+
+  EXPECT_EQ(ack_handler_->acked_wheel_event().delta_y, -5);
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  if (wheel_scroll_latching_enabled_) {
+    // Check that the ack for ScrollUpdate were processed.
+    EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+  } else {
+    // The GestureScrollUpdate ACK releases the GestureScrollEnd.
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+    // Check that the ack for the ScrollUpdate and ScrollEnd
+    // were processed.
+    EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+  }
+
+  SendInputEventACK(WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  if (wheel_scroll_latching_enabled_) {
+    // There should be a ScrollUpdate sent.
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+  } else {
+    // There should be a ScrollBegin and ScrollUpdate sent.
+    EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
+    EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+  }
+
+  // Check that the correct unhandled wheel event was received.
+  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
+            ack_handler_->acked_wheel_event_state());
+  EXPECT_EQ(ack_handler_->acked_wheel_event().delta_y, -10);
+
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  if (wheel_scroll_latching_enabled_) {
+    // Check that the ack for ScrollUpdate were processed.
+    EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+  } else {
+    // The GestureScrollUpdate ACK releases the GestureScrollEnd.
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+    // Check that the ack for the ScrollUpdate and ScrollEnd
+    // were processed.
+    EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
+  }
+}
+
 TEST_F(LegacyInputRouterImplTest, UnhandledWheelEvent) {
-  UnhandledWheelEvent(true);
+  UnhandledWheelEvent();
 }
 TEST_F(LegacyInputRouterImplWheelScrollLatchingDisabledTest,
        UnhandledWheelEvent) {
-  UnhandledWheelEvent(false);
+  UnhandledWheelEvent();
+}
+TEST_F(LegacyInputRouterImplAsyncWheelEventEnabledTest, UnhandledWheelEvent) {
+  // Simulate wheel events.
+  SimulateWheelEventWithPhase(0, 0, 0, -5, 0, false,
+                              WebMouseWheelEvent::kPhaseBegan);
+  SimulateWheelEventWithPhase(0, 0, 0, -10, 0, false,
+                              WebMouseWheelEvent::kPhaseChanged);
+
+  // Check that only the first event was sent.
+  EXPECT_TRUE(
+      process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID));
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+  // Indicate that the wheel event was unhandled.
+  SendInputEventACK(WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  // Check that the ack for the first MouseWheel, ScrollBegin, and the second
+  // MouseWheel were processed.
+  EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount());
+
+  // There should be a ScrollBegin and ScrollUpdate, MouseWheel sent.
+  EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
+
+  // The last acked wheel event should be the second one since the input router
+  // has alread sent the immediate ack for the second wheel event.
+  EXPECT_EQ(ack_handler_->acked_wheel_event().delta_y, -10);
+  EXPECT_EQ(INPUT_EVENT_ACK_STATE_IGNORED,
+            ack_handler_->acked_wheel_event_state());
+
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // Check that the ack for the first ScrollUpdate were processed.
+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+
+  // There should be a second ScrollUpdate sent.
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // Check that the ack for ScrollUpdate were processed.
+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 }
 
 TEST_F(LegacyInputRouterImplTest, TouchTypesIgnoringAck) {
   OnHasTouchEventHandlers(true);
   // Only acks for TouchCancel should always be ignored.
   ASSERT_TRUE(
       ShouldBlockEventStream(GetEventWithType(WebInputEvent::kTouchStart)));
   ASSERT_TRUE(
       ShouldBlockEventStream(GetEventWithType(WebInputEvent::kTouchMove)));
   ASSERT_TRUE(
@@ skipping 777 matching lines @@
   // Ack the wheel event.
   SendInputEventACK(WebInputEvent::kGesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(0, client_->in_flight_event_count());
 }
 
 // Test proper routing of overscroll notifications received either from
 // event acks or from |DidOverscroll| IPC messages.
-TEST_F(LegacyInputRouterImplTest, OverscrollDispatch) {
+void LegacyInputRouterImplTest::OverscrollDispatch() {
   DidOverscrollParams overscroll;
   overscroll.accumulated_overscroll = gfx::Vector2dF(-14, 14);
   overscroll.latest_overscroll_delta = gfx::Vector2dF(-7, 0);
   overscroll.current_fling_velocity = gfx::Vector2dF(-1, 0);
 
   input_router_->OnMessageReceived(InputHostMsg_DidOverscroll(0, overscroll));
   DidOverscrollParams client_overscroll = client_->GetAndResetOverscroll();
   EXPECT_EQ(overscroll.accumulated_overscroll,
             client_overscroll.accumulated_overscroll);
   EXPECT_EQ(overscroll.latest_overscroll_delta,
             client_overscroll.latest_overscroll_delta);
   EXPECT_EQ(overscroll.current_fling_velocity,
             client_overscroll.current_fling_velocity);
 
   DidOverscrollParams wheel_overscroll;
   wheel_overscroll.accumulated_overscroll = gfx::Vector2dF(7, -7);
   wheel_overscroll.latest_overscroll_delta = gfx::Vector2dF(3, 0);
   wheel_overscroll.current_fling_velocity = gfx::Vector2dF(1, 0);
 
-  SimulateWheelEvent(0, 0, 3, 0, 0, false);
+  SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 0,
+                                           0, 3, 0, 0, false,
+                                           WebMouseWheelEvent::kPhaseBegan);
   InputEventAck ack(InputEventAckSource::COMPOSITOR_THREAD,
                     WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ack.overscroll.reset(new DidOverscrollParams(wheel_overscroll));
   input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
 
   client_overscroll = client_->GetAndResetOverscroll();
   EXPECT_EQ(wheel_overscroll.accumulated_overscroll,
             client_overscroll.accumulated_overscroll);
   EXPECT_EQ(wheel_overscroll.latest_overscroll_delta,
             client_overscroll.latest_overscroll_delta);
   EXPECT_EQ(wheel_overscroll.current_fling_velocity,
             client_overscroll.current_fling_velocity);
 }
+TEST_F(LegacyInputRouterImplTest, OverscrollDispatch) {
+  OverscrollDispatch();
+}
+TEST_F(LegacyInputRouterImplWheelScrollLatchingDisabledTest,
+       OverscrollDispatch) {
+  OverscrollDispatch();
+}
+TEST_F(LegacyInputRouterImplAsyncWheelEventEnabledTest, OverscrollDispatch) {
+  OverscrollDispatch();
+}
 
 // Tests that touch event stream validation passes when events are filtered
 // out. See crbug.com/581231 for details.
 TEST_F(LegacyInputRouterImplTest,
        TouchValidationPassesWithFilteredInputEvents) {
   // Touch sequence with touch handler.
   OnHasTouchEventHandlers(true);
   PressTouchPoint(1, 1);
   uint32_t touch_press_event_id = SendTouchEvent();
   SendTouchEventACK(WebInputEvent::kTouchStart,
@@ skipping 77 matching lines @@
 
 TEST_F(LegacyInputRouterImplScaleMouseEventTest, ScaleMouseEventTest) {
   RunMouseEventTest("Enter", WebInputEvent::kMouseEnter);
   RunMouseEventTest("Down", WebInputEvent::kMouseDown);
   RunMouseEventTest("Move", WebInputEvent::kMouseMove);
   RunMouseEventTest("Up", WebInputEvent::kMouseUp);
 }
 
 TEST_F(LegacyInputRouterImplScaleEventTest, ScaleMouseWheelEventTest) {
   ASSERT_EQ(0u, process_->sink().message_count());
-  SimulateWheelEvent(5, 5, 10, 10, 0, false);
+  SimulateWheelEventWithPhase(5, 5, 10, 10, 0, false,
+                              WebMouseWheelEvent::kPhaseBegan);
   ASSERT_EQ(1u, process_->sink().message_count());
 
   const WebMouseWheelEvent* sent_event =
       GetSentWebInputEvent<WebMouseWheelEvent>();
   EXPECT_EQ(10, sent_event->PositionInWidget().x);
   EXPECT_EQ(10, sent_event->PositionInWidget().y);
   EXPECT_EQ(20, sent_event->delta_x);
   EXPECT_EQ(20, sent_event->delta_y);
   EXPECT_EQ(2, sent_event->wheel_ticks_x);
   EXPECT_EQ(2, sent_event->wheel_ticks_y);
@@ skipping 343 matching lines @@
   EXPECT_EQ(80, sent_event->data.fling_start.velocity_y);
 
   const WebGestureEvent* filter_event =
       GetFilterWebInputEvent<WebGestureEvent>();
   TestLocationInFilterEvent(filter_event, orig);
   EXPECT_EQ(30, filter_event->data.fling_start.velocity_x);
   EXPECT_EQ(40, filter_event->data.fling_start.velocity_y);
 }
 
 }  // namespace content