Tiimer based phase info generated for mouse wheel events.

content/browser/renderer_host/render_widget_host_view_aura_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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 725 matching lines @@
   void EnableRafAlignedTouchInput() {
     feature_list_.InitFromCommandLine(
         features::kRafAlignedTouchInputEvents.name, "");
   }
 
   void DisableRafAlignedTouchInput() {
     feature_list_.InitFromCommandLine(
         "", features::kRafAlignedTouchInputEvents.name);
   }
 
+  void EnableWheelScrollLatching() {
+    feature_list_.InitFromCommandLine(
+        features::kTouchpadAndWheelScrollLatching.name, "");
+  }
+
+  void DisableWheelScrollLatching() {
+    feature_list_.InitFromCommandLine(
+        "", features::kTouchpadAndWheelScrollLatching.name);
+  }
+
   void SetFeatureList(bool raf_aligned_touch, bool wheel_scroll_latching) {
     if (raf_aligned_touch && wheel_scroll_latching) {
       feature_list_.InitWithFeatures(
           {features::kRafAlignedTouchInputEvents,
            features::kTouchpadAndWheelScrollLatching},
           {});
     } else if (raf_aligned_touch && !wheel_scroll_latching) {
       feature_list_.InitWithFeatures(
           {features::kRafAlignedTouchInputEvents},
           {features::kTouchpadAndWheelScrollLatching});
@@ skipping 84 matching lines @@
 
 class RenderWidgetHostViewAuraRafAlignedTouchDisabledTest
     : public RenderWidgetHostViewAuraTest {
  public:
   void SetUp() override {
     DisableRafAlignedTouchInput();
     RenderWidgetHostViewAuraTest::SetUp();
   }
 };
 
+class RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest
+    : public RenderWidgetHostViewAuraTest {
+ public:
+  void SetUp() override {
+    EnableWheelScrollLatching();
+    ui::GestureConfiguration::GetInstance()->set_scroll_debounce_interval_in_ms(
+        0);
+    RenderWidgetHostViewAuraTest::SetUp();
+  }
+};
+
 void InstallDelegatedFrameHostClient(
     RenderWidgetHostViewAura* render_widget_host_view,
     std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) {
   RenderWidgetHostViewAuraTest::InstallDelegatedFrameHostClient(
       render_widget_host_view, std::move(delegated_frame_host_client));
 }
 
 // Helper class to instantiate RenderWidgetHostViewGuest which is backed
 // by an aura platform view.
 class RenderWidgetHostViewGuestAuraTest : public RenderWidgetHostViewAuraTest {
@@ skipping 73 matching lines @@
                                          const ui::LatencyInfo& ui_latency) {
     widget_host_->ForwardMouseEventWithLatencyInfo(
         SyntheticWebMouseEventBuilder::Build(type), ui_latency);
   }
 
   void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) {
     widget_host_->ForwardWheelEvent(SyntheticWebMouseWheelEventBuilder::Build(
         0, 0, dX, dY, modifiers, precise));
   }
 
+  void SimulateWheelEventWithPhase(float dX,
+                                   float dY,
+                                   int modifiers,
+                                   bool precise,
+                                   WebMouseWheelEvent::Phase phase) {
+    WebMouseWheelEvent wheel_event = SyntheticWebMouseWheelEventBuilder::Build(
+        0, 0, dX, dY, modifiers, precise);
+    wheel_event.phase = phase;
+    widget_host_->ForwardWheelEvent(wheel_event);
+  }
+
   void SimulateWheelEventWithLatencyInfo(float dX,
                                          float dY,
                                          int modifiers,
                                          bool precise,
                                          const ui::LatencyInfo& ui_latency) {
     widget_host_->ForwardWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(0, 0, dX, dY, modifiers,
                                                   precise),
         ui_latency);
   }
@@ skipping 117 matching lines @@
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
   }
 
   void ExpectGestureScrollEndForWheelScrolling(bool is_last) {
     if (wheel_scroll_latching_enabled_) {
       if (!is_last) {
         EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
         return;
       }
-      // Let the ScrollEnd timer in mouseWheelEventQueue fire. This will cause
-      // the mouseWheelEventQueue to send a GestureScrollEnd event.
-      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
-          base::TimeDelta::FromMilliseconds(
-              kDefaultWheelScrollLatchingTransactionMs));
-      base::RunLoop().Run();
     }
 
     EXPECT_EQ(1U, sink_->message_count());
     InputMsg_HandleInputEvent::Param params;
     if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), &params)) {
       const blink::WebInputEvent* event = std::get<0>(params);
       EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType());
     }
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   }
@@ skipping 622 matching lines @@
 
   ui::TouchEvent release2(
       ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), base::TimeTicks::Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, 0));
   view_->OnTouchEvent(&release2);
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(0U, pointer_state().GetPointerCount());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 }
 
+TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest,
+       TimerBasedWheelEventPhaseInfo) {
+  view_->InitAsChild(nullptr);
+  view_->Show();
+  sink_->ClearMessages();
+
+  ui::MouseWheelEvent event(gfx::Vector2d(0, 5), gfx::Point(2, 2),
+                            gfx::Point(2, 2), ui::EventTimeForNow(), 0, 0);
+  view_->OnMouseEvent(&event);
+  const WebInputEvent* input_event =
+      GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  const WebMouseWheelEvent* wheel_event =
+      static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase);
+  SendInputEventACK(blink::WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  const WebGestureEvent* gesture_event =
+      static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
+  EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y);
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  sink_->ClearMessages();
+
+  // Send a ui::ScrollEvent instead of ui::MouseWheel event, the timer based
+  // phase info doesn't diffrentiate between the two types of events.
+  ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2),
+                          ui::EventTimeForNow(), 0, 0, 2, 0, 2, 2);
+  view_->OnScrollEvent(&scroll1);
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, wheel_event->phase);
+  SendInputEventACK(blink::WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
+  EXPECT_EQ(2U, gesture_event->data.scroll_update.delta_y);
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  sink_->ClearMessages();
+
+  // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. A
+  // synthetic wheel event with zero deltas and kPhaseEnded will be sent.
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
+      base::TimeDelta::FromMilliseconds(
+          kDefaultMouseWheelLatchingTransactionMs));
+  base::RunLoop().Run();
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase);
+  EXPECT_EQ(0U, wheel_event->delta_x);
+  EXPECT_EQ(0U, wheel_event->delta_y);
+  SendInputEventACK(blink::WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType());
+  sink_->ClearMessages();
+}
+
+// Tests that a gesture fling start with touchpad source stops the
+// RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ and no synthetic
+// wheel event will be sent.
+TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest,
+       TouchpadFlingStartStopsWheelPhaseTimer) {
+  ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2),
+                          ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2);
+  view_->OnScrollEvent(&scroll0);
+  const WebInputEvent* input_event =
+      GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  const WebMouseWheelEvent* wheel_event =
+      static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase);
+  SendInputEventACK(blink::WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  const WebGestureEvent* gesture_event =
+      static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
+  EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y);
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  sink_->ClearMessages();
+
+  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START, gfx::Point(2, 2),
+                              ui::EventTimeForNow(), 0, 0, 10, 0, 10, 2);
+  view_->OnScrollEvent(&fling_start);
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureFlingStart, gesture_event->GetType());
+  SendInputEventACK(WebInputEvent::kGestureFlingStart,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  sink_->ClearMessages();
+
+  // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. No
+  // synthetic wheel event will be sent since the timer has stopped.
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
+      base::TimeDelta::FromMilliseconds(
+          kDefaultMouseWheelLatchingTransactionMs));
+  base::RunLoop().Run();
+
+  EXPECT_EQ(0U, sink_->message_count());
+
+  // Handling the next ui::ET_SCROLL event will send a fling cancellation and a
+  // mouse wheel with kPhaseBegan.
+  ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2),
+                          ui::EventTimeForNow(), 0, 0, 15, 0, 15, 2);
+  view_->OnScrollEvent(&scroll1);
+  EXPECT_EQ(2U, sink_->message_count());
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+
+  EXPECT_EQ(WebInputEvent::kGestureFlingCancel, gesture_event->GetType());
+  SendInputEventACK(WebInputEvent::kGestureFlingCancel,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase);
+  sink_->ClearMessages();
+}
+
+TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest,
+       GSBWithTouchSourceStopsWheelScrollSequence) {
+  ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2),
+                          ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2);
+  view_->OnScrollEvent(&scroll0);
+  const WebInputEvent* input_event =
+      GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  const WebMouseWheelEvent* wheel_event =
+      static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase);
+  SendInputEventACK(blink::WebInputEvent::kMouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  const WebGestureEvent* gesture_event =
+      static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
+  EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y);
+  SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  sink_->ClearMessages();
+
+  ui::GestureEventDetails event_details(ui::ET_GESTURE_SCROLL_BEGIN);
+  event_details.set_device_type(ui::GestureDeviceType::DEVICE_TOUCHSCREEN);
+  ui::GestureEvent scroll_begin(2, 2, 0, ui::EventTimeForNow(), event_details);
+  view_->OnGestureEvent(&scroll_begin);
+  EXPECT_EQ(3U, sink_->message_count());
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0));
+  wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase);
+  EXPECT_EQ(0U, wheel_event->delta_x);
+  EXPECT_EQ(0U, wheel_event->delta_y);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType());
+  EXPECT_EQ(blink::kWebGestureDeviceTouchpad, gesture_event->source_device);
+
+  input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2));
+  gesture_event = static_cast<const WebGestureEvent*>(input_event);
+  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+  EXPECT_EQ(blink::kWebGestureDeviceTouchscreen, gesture_event->source_device);
+  sink_->ClearMessages();
+}
+
 // Checks that touch-event state is maintained correctly for multiple touch
 // points.
 TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) {
   view_->InitAsFullscreen(parent_view_);
   view_->Show();
   view_->UseFakeDispatcher();
   GetSentMessageCountAndResetSink();
 
   ui::TouchEvent press0(
       ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), ui::EventTimeForNow(),
@@ skipping 1782 matching lines @@
   EXPECT_EQ(ui::MotionEvent::ACTION_DOWN, pointer_state().GetAction());
   EXPECT_EQ(1U, pointer_state().GetPointerCount());
   EXPECT_EQ(kX, pointer_state().GetX(0));
   EXPECT_EQ(kY, pointer_state().GetY(0));
 }
 
 void RenderWidgetHostViewAuraOverscrollTest::WheelNotPreciseScrollEvent() {
   SetUpOverscrollEnvironment();
 
   // Simulate wheel events.
-  SimulateWheelEvent(-5, 0, 0, false);    // sent directly
-  SimulateWheelEvent(-60, 1, 0, false);    // enqueued
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-5, 0, 0, false);   // sent directly
+    SimulateWheelEvent(-60, 1, 0, false);  // enqueued
+  } else {
+    SimulateWheelEventWithPhase(
+        -5, 0, 0, false, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(-60, 1, 0, false,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+  }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Receive ACK the first wheel event as not processed.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  if (wheel_scroll_latching_enabled_) {
+    SimulateWheelEventWithPhase(0, 0, 0, false,
+                                WebMouseWheelEvent::kPhaseEnded);
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    SendInputEventACK(WebInputEvent::kMouseWheel,
+                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  }
   ExpectGestureScrollEndForWheelScrolling(true);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) {
   WheelNotPreciseScrollEvent();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        WheelNotPreciseScrollEvent) {
   WheelNotPreciseScrollEvent();
 }
 
 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() {
   SetUpOverscrollEnvironment();
 
   // Simulate wheel events.
-  SimulateWheelEvent(-5, 0, 0, true);    // sent directly
-  SimulateWheelEvent(-1, 1, 0, true);    // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-20, 6, 1, true);   // enqueued, different modifiers
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-5, 0, 0, true);    // sent directly
+    SimulateWheelEvent(-1, 1, 0, true);    // enqueued
+    SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-20, 6, 1, true);   // enqueued, different modifiers
+  } else {
+    SimulateWheelEventWithPhase(
+        -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(-1, 1, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    SimulateWheelEventWithPhase(
+        -10, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -15, -1, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -30, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -20, 6, 1, true,
+        WebMouseWheelEvent::kPhaseChanged);  // enqueued, different modifiers
+  }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Receive ACK the first wheel event as not processed.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
@@ skipping 46 matching lines @@
   WheelScrollEventOverscrolls();
 }
 
 // Tests that if some scroll events are consumed towards the start, then
 // subsequent scrolls do not horizontal overscroll.
 void RenderWidgetHostViewAuraOverscrollTest::
     WheelScrollConsumedDoNotHorizOverscroll() {
   SetUpOverscrollEnvironment();
 
   // Simulate wheel events.
-  SimulateWheelEvent(-5, 0, 0, true);    // sent directly
-  SimulateWheelEvent(-1, -1, 0, true);   // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-20, 6, 1, true);   // enqueued, different modifiers
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-5, 0, 0, true);    // sent directly
+    SimulateWheelEvent(-1, -1, 0, true);   // enqueued
+    SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-20, 6, 1, true);   // enqueued, different modifiers
+  } else {
+    SimulateWheelEventWithPhase(
+        -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(-1, -1, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    SimulateWheelEventWithPhase(
+        -10, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -15, -1, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -30, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -20, 6, 1, true,
+        WebMouseWheelEvent::kPhaseChanged);  // enqueued, different modifiers
+  }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Receive ACK the first wheel event as processed.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
@@ skipping 14 matching lines @@
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  if (wheel_scroll_latching_enabled_) {
+    SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded);
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    SendInputEventACK(WebInputEvent::kMouseWheel,
+                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  }
+
   ExpectGestureScrollEndForWheelScrolling(true);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest,
        WheelScrollConsumedDoNotHorizOverscroll) {
   WheelScrollConsumedDoNotHorizOverscroll();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        WheelScrollConsumedDoNotHorizOverscroll) {
   WheelScrollConsumedDoNotHorizOverscroll();
 }
 
 // Tests that wheel-scrolling correctly turns overscroll on and off.
 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() {
   SetUpOverscrollEnvironment();
 
   // Send a wheel event. ACK the event as not processed. This should not
   // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(10, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(10, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseBegan);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(10, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(10, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(10, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(40, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(40, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(40, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
   EXPECT_EQ(60.f, overscroll_delta_x());
   EXPECT_EQ(10.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
   // Scroll in the reverse direction enough to abort the overscroll.
-  SimulateWheelEvent(-20, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-20, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(-20, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   if (wheel_scroll_latching_enabled_) {
     EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   } else {
     // ScrollBegin and ScrollEnd will be queued events.
     EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
   }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Continue to scroll in the reverse direction.
-  SimulateWheelEvent(-20, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-20, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(-20, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Continue to scroll in the reverse direction enough to initiate overscroll
   // in that direction.
-  SimulateWheelEvent(-55, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-55, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(-55, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  if (wheel_scroll_latching_enabled_) {
+    SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded);
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    SendInputEventACK(WebInputEvent::kMouseWheel,
+                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  }
   ExpectGestureScrollEndForWheelScrolling(true);
 
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode());
   EXPECT_EQ(-75.f, overscroll_delta_x());
   EXPECT_EQ(-25.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) {
   WheelScrollOverscrollToggle();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        WheelScrollOverscrollToggle) {
   WheelScrollOverscrollToggle();
 }
 
 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() {
   SetUpOverscrollEnvironment();
 
   // Send a wheel event. ACK the event as not processed. This should not
   // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(10, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(10, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseBegan);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(20, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(20, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(20, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, sink_->message_count());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
   sink_->ClearMessages();
 
   // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(30, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(30, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(30, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
 
   EXPECT_EQ(60.f, overscroll_delta_x());
   EXPECT_EQ(10.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // Send a fling start, but with a small velocity, so that the overscroll is
   // aborted. The fling should proceed to the renderer, through the gesture
   // event filter.
   SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
                        blink::kWebGestureDeviceTouchscreen);
   SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
 
-  if (!wheel_scroll_latching_enabled_) {
-    // ScrollBegin and FlingStart will be queued events.
-    EXPECT_EQ(2U, sink_->message_count());
-  } else {
-    // ScrollEnd, ScrollBegin, and FlingStart will be queued events.
-    EXPECT_EQ(3U, sink_->message_count());
-  }
+  // ScrollBegin and FlingStart will be queued events.
+  EXPECT_EQ(2U, sink_->message_count());
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest,
        ScrollEventsOverscrollWithFling) {
   ScrollEventsOverscrollWithFling();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        ScrollEventsOverscrollWithFling) {
   ScrollEventsOverscrollWithFling();
 }
 
 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that
 // the zero-velocity fling does not reach the renderer.
 void RenderWidgetHostViewAuraOverscrollTest::
     ScrollEventsOverscrollWithZeroFling() {
   SetUpOverscrollEnvironment();
 
   // Send a wheel event. ACK the event as not processed. This should not
   // initiate an overscroll gesture since it doesn't cross the threshold yet.
-  SimulateWheelEvent(10, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(10, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(10, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseBegan);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Scroll some more so as to not overscroll.
-  SimulateWheelEvent(20, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(20, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(20, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   // Scroll some more to initiate an overscroll.
-  SimulateWheelEvent(30, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(30, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(30, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
 
   EXPECT_EQ(60.f, overscroll_delta_x());
   EXPECT_EQ(10.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // Send a fling start, but with a small velocity, so that the overscroll is
   // aborted. The fling should proceed to the renderer, through the gesture
   // event filter.
   SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
                        blink::kWebGestureDeviceTouchscreen);
   SimulateGestureFlingStartEvent(10.f, 0.f, blink::kWebGestureDeviceTouchpad);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
 
-  if (!wheel_scroll_latching_enabled_) {
     // ScrollBegin and FlingStart will be queued events.
     EXPECT_EQ(2U, sink_->message_count());
-  } else {
-    // ScrollEnd, ScrollBegin, and FlingStart will be queued events.
-    EXPECT_EQ(3U, sink_->message_count());
-  }
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest,
        ScrollEventsOverscrollWithZeroFling) {
   ScrollEventsOverscrollWithZeroFling();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        ScrollEventsOverscrollWithZeroFling) {
   ScrollEventsOverscrollWithZeroFling();
 }
 
@@ skipping 440 matching lines @@
   SimulateGestureScrollUpdateEvent(-20, 0, 0);
   EXPECT_EQ(1U, sink_->message_count());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
 }
 
 void RenderWidgetHostViewAuraOverscrollTest::
     OverscrollDirectionChangeMouseWheel() {
   SetUpOverscrollEnvironment();
 
   // Send wheel event and receive ack as not consumed.
-  SimulateWheelEvent(125, -5, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(125, -5, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(125, -5, 0, true,
+                                WebMouseWheelEvent::kPhaseBegan);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
 
   // Send another wheel event, but in the reverse direction. The overscroll
   // controller will not consume the event, because it is not triggering
   // gesture-nav.
 
-  SimulateWheelEvent(-260, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-260, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(-260, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);
+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
 
   // Since it was unhandled; the overscroll should now be west
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode());
 
-  SimulateWheelEvent(-20, 0, 0, true);
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-20, 0, 0, true);
+  } else {
+    SimulateWheelEventWithPhase(-20, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);

[tdresser, 2017/05/19 16:17:33]

Is it worth using the same trick here of adding a parameter indicating whether
or not phase information should be ignored?

[sahel, 2017/05/19 17:39:16]

Done.

+  }
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // wheel event ack generates gesture scroll update; which gets consumed
   // solely by the overflow controller.
   if (!wheel_scroll_latching_enabled_) {
     // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events.
     EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
   } else {
     EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   }
 
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode());
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollTest,
        OverscrollDirectionChangeMouseWheel) {
   OverscrollDirectionChangeMouseWheel();
 }
 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest,
        OverscrollDirectionChangeMouseWheel) {
   OverscrollDirectionChangeMouseWheel();
 }
 
 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() {
   SetUpOverscrollEnvironment();
 
-  SimulateWheelEvent(5, 0, 0, true);     // sent directly
-  SimulateWheelEvent(-1, 0, 0, true);    // enqueued
-  SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(5, 0, 0, true);     // sent directly
+    SimulateWheelEvent(-1, 0, 0, true);    // enqueued
+    SimulateWheelEvent(-10, -3, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-15, -1, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(-30, -3, 0, true);  // coalesced into previous event
+  } else {
+    SimulateWheelEventWithPhase(
+        5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(-1, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    SimulateWheelEventWithPhase(
+        -10, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -15, -1, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        -30, -3, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+  }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Receive ACK the first wheel event as not processed.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
@@ skipping 73 matching lines @@
        OverscrollMouseMoveCompletion) {
   OverscrollMouseMoveCompletion();
 }
 
 // Tests that if a page scrolled, then the overscroll controller's states are
 // reset after the end of the scroll.
 void RenderWidgetHostViewAuraOverscrollTest::
     OverscrollStateResetsAfterScroll() {
   SetUpOverscrollEnvironment();
 
-  SimulateWheelEvent(0, 5, 0, true);   // sent directly
-  SimulateWheelEvent(0, 30, 0, true);  // enqueued
-  SimulateWheelEvent(0, 40, 0, true);  // coalesced into previous event
-  SimulateWheelEvent(0, 10, 0, true);  // coalesced into previous event
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(0, 5, 0, true);   // sent directly
+    SimulateWheelEvent(0, 30, 0, true);  // enqueued
+    SimulateWheelEvent(0, 40, 0, true);  // coalesced into previous event
+    SimulateWheelEvent(0, 10, 0, true);  // coalesced into previous event
+  } else {
+    SimulateWheelEventWithPhase(
+        0, 5, 0, true, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(0, 30, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    SimulateWheelEventWithPhase(
+        0, 40, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+    SimulateWheelEventWithPhase(
+        0, 10, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+  }
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // The first wheel event is consumed. Dispatches the queued wheel event.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
   EXPECT_TRUE(ScrollStateIsContentScrolling());
 
   // The second wheel event is consumed.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  if (wheel_scroll_latching_enabled_) {
+    SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded);
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    SendInputEventACK(WebInputEvent::kMouseWheel,
+                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  }
   ExpectGestureScrollEndForWheelScrolling(true);
   EXPECT_TRUE(ScrollStateIsContentScrolling());
 
   // Touchpad scroll can end with a zero-velocity fling. But it is not
   // dispatched, but it should still reset the overscroll controller state.
   SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
                        blink::kWebGestureDeviceTouchscreen);
   SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad);
   EXPECT_TRUE(ScrollStateIsUnknown());
   // ScrollBegin will be queued events.
   EXPECT_EQ(1U, sink_->message_count());
 
   // Dropped flings should neither propagate *nor* indicate that they were
   // consumed and have triggered a fling animation (as tracked by the router).
   EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents());
 
   SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
                        blink::kWebGestureDeviceTouchscreen);
   // ScrollBegin, and ScrollEnd will be queued events.
   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
 
-  SimulateWheelEvent(-5, 0, 0, true);    // sent directly
-  SimulateWheelEvent(-60, 0, 0, true);   // enqueued
-  SimulateWheelEvent(-100, 0, 0, true);  // coalesced into previous event
+  if (!wheel_scroll_latching_enabled_) {
+    SimulateWheelEvent(-5, 0, 0, true);    // sent directly
+    SimulateWheelEvent(-60, 0, 0, true);   // enqueued
+    SimulateWheelEvent(-100, 0, 0, true);  // coalesced into previous event
+  } else {
+    SimulateWheelEventWithPhase(
+        -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan);  // sent directly
+    SimulateWheelEventWithPhase(-60, 0, 0, true,
+                                WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    SimulateWheelEventWithPhase(
+        -100, 0, 0, true,
+        WebMouseWheelEvent::kPhaseChanged);  // coalesced into previous event
+  }
   EXPECT_TRUE(ScrollStateIsUnknown());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // The first wheel scroll did not scroll content. Overscroll should not start
   // yet, since enough hasn't been scrolled.
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(true, true);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEndForWheelScrolling(false);
   EXPECT_TRUE(ScrollStateIsUnknown());
 
   SendInputEventACK(WebInputEvent::kMouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ExpectGestureScrollEventsAfterMouseWheelACK(false, false);
 
   SendInputEventACK(WebInputEvent::kGestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  if (wheel_scroll_latching_enabled_) {
+    SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded);
+    EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+    SendInputEventACK(WebInputEvent::kMouseWheel,
+                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  }
+
   ExpectGestureScrollEndForWheelScrolling(true);
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode());
   EXPECT_TRUE(ScrollStateIsOverscrolling());
 
   // The GestureScrollBegin will reset the delegate's mode, so check it here.
   EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode());
   SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
                        blink::kWebGestureDeviceTouchscreen);
   SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
@@ skipping 910 matching lines @@
     // There is no composition in the beginning.
     EXPECT_FALSE(has_composition_text());
     SetHasCompositionTextToTrue();
     view->ImeCancelComposition();
     // The composition must have been canceled.
     EXPECT_FALSE(has_composition_text());
   }
 }
 
 }  // namespace content