Tiimer based phase info generated for mouse wheel events.

content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 225 matching lines @@
                       float y,
                       float global_x,
                       float global_y,
                       float dX,
                       float dY,
                       int modifiers,
                       bool high_precision) {
     SendMouseWheel(x, y, global_x, global_y, dX, dY, modifiers, high_precision,
                    WebInputEvent::kRailsModeFree);
   }
+  void SendMouseWheelWithPhase(float x,
+                               float y,
+                               float global_x,
+                               float global_y,
+                               float dX,
+                               float dY,
+                               int modifiers,
+                               bool high_precision,
+                               blink::WebMouseWheelEvent::Phase phase,
+                               blink::WebMouseWheelEvent::Phase momentum_phase,
+                               WebInputEvent::RailsMode rails_mode) {
+    WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build(
+        x, y, global_x, global_y, dX, dY, modifiers, high_precision);
+    event.phase = phase;
+    event.momentum_phase = momentum_phase;
+    event.rails_mode = rails_mode;
+    queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event));
+  }
   void SendMouseWheelWithPhase(
       float x,
       float y,
       float global_x,
       float global_y,
       float dX,
       float dY,
       int modifiers,
       bool high_precision,
       blink::WebMouseWheelEvent::Phase phase,
       blink::WebMouseWheelEvent::Phase momentum_phase) {
-    WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build(
-        x, y, global_x, global_y, dX, dY, modifiers, high_precision);
-    event.phase = phase;
-    event.momentum_phase = momentum_phase;
-    queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event));
+    SendMouseWheelWithPhase(x, y, global_x, global_y, dX, dY, modifiers,
+                            high_precision, phase, momentum_phase,
+                            WebInputEvent::kRailsModeFree);
+  }
+
+  void SendMouseWheelPossiblyIncludingPhase(
+      bool ignore_phase,
+      float x,
+      float y,
+      float global_x,
+      float global_y,
+      float dX,
+      float dY,
+      int modifiers,
+      bool high_precision,
+      blink::WebMouseWheelEvent::Phase phase,
+      blink::WebMouseWheelEvent::Phase momentum_phase,
+      WebInputEvent::RailsMode rails_mode) {
+    if (ignore_phase) {
+      SendMouseWheel(x, y, global_x, global_y, dX, dY, modifiers,
+                     high_precision, rails_mode);
+    } else {
+      SendMouseWheelWithPhase(x, y, global_x, global_y, dX, dY, modifiers,
+                              high_precision, phase, momentum_phase,
+                              rails_mode);
+    }
+  }
+
+  void SendMouseWheelPossiblyIncludingPhase(
+      bool ignore_phase,
+      float x,
+      float y,
+      float global_x,
+      float global_y,
+      float dX,
+      float dY,
+      int modifiers,
+      bool high_precision,
+      blink::WebMouseWheelEvent::Phase phase,
+      blink::WebMouseWheelEvent::Phase momentum_phase) {
+    SendMouseWheelPossiblyIncludingPhase(
+        ignore_phase, x, y, global_x, global_y, dX, dY, modifiers,
+        high_precision, phase, momentum_phase, WebInputEvent::kRailsModeFree);
   }
 
   void SendGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent event(type, WebInputEvent::kNoModifiers,
                           ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
     event.source_device = blink::kWebGestureDeviceTouchscreen;
     queue_->OnGestureScrollEvent(
         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay);
     base::RunLoop().Run();
   }
 
   void GestureSendingTest(bool high_precision) {
     const WebGestureEvent::ScrollUnits scroll_units =
         high_precision ? WebGestureEvent::kPrecisePixels
                        : WebGestureEvent::kPixels;
-    SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                   kWheelScrollGlobalY, 1, 1, 0, high_precision);
+    SendMouseWheelPossiblyIncludingPhase(
+        !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+        kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, high_precision,
+        WebMouseWheelEvent::kPhaseBegan, WebMouseWheelEvent::kPhaseNone);
     EXPECT_EQ(0U, queued_event_count());
     EXPECT_TRUE(event_in_flight());
     EXPECT_EQ(1U, GetAndResetSentEventCount());
 
     // The second mouse wheel should not be sent since one is already in
     // queue.
-    SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                   kWheelScrollGlobalY, 5, 5, 0, high_precision);
+    SendMouseWheelPossiblyIncludingPhase(
+        !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+        kWheelScrollGlobalX, kWheelScrollGlobalY, 5, 5, 0, high_precision,
+        WebMouseWheelEvent::kPhaseChanged, WebMouseWheelEvent::kPhaseNone);
     EXPECT_EQ(1U, queued_event_count());
     EXPECT_TRUE(event_in_flight());
     EXPECT_EQ(0U, GetAndResetSentEventCount());
 
     // Receive an ACK for the mouse wheel event and release the next
     // mouse wheel event.
     SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_EQ(0U, queued_event_count());
     EXPECT_TRUE(event_in_flight());
     EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
     if (scroll_latching_enabled_) {
       EXPECT_EQ(3U, all_sent_events().size());
-      EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-      EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+      EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0));
+      EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
       EXPECT_MOUSE_WHEEL(sent_input_event(2));
       EXPECT_EQ(3U, GetAndResetSentEventCount());
-
-      RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2);
-      EXPECT_EQ(1U, all_sent_events().size());
-      EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
     } else {
       EXPECT_EQ(4U, all_sent_events().size());
       EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
       EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
       EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2));
       EXPECT_MOUSE_WHEEL(sent_input_event(3));
       EXPECT_EQ(4U, GetAndResetSentEventCount());
     }
   }
 
@@ skipping 32 matching lines @@
       EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0));
       EXPECT_EQ(1U, GetAndResetSentEventCount());
     } else {
       EXPECT_EQ(3U, all_sent_events().size());
       EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
       EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
       EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2));
       EXPECT_EQ(3U, GetAndResetSentEventCount());
     }
 
-    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                            kWheelScrollGlobalY, 0, 0, 0, high_precision,
-                            WebMouseWheelEvent::kPhaseEnded,
-                            WebMouseWheelEvent::kPhaseNone);
-    EXPECT_EQ(1U, GetAndResetSentEventCount());
-    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-    if (scroll_latching_enabled_) {
-      // ScrollEnd is not sent right away, a timer starts instead,
-      // to see if a wheel event with momentumPhase arrives or not.
-      EXPECT_EQ(0U, all_sent_events().size());
-      EXPECT_EQ(0U, GetAndResetSentEventCount());
-    } else {
+    // When wheel scroll latching is enabled no wheel event with phase =
+    // |kPhaseEnded| will be sent before a wheel event with momentum_phase =
+    // |kPhaseBegan|.
+    if (!scroll_latching_enabled_) {
+      SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                              kWheelScrollGlobalY, 0, 0, 0, high_precision,
+                              WebMouseWheelEvent::kPhaseEnded,
+                              WebMouseWheelEvent::kPhaseNone);
+      EXPECT_EQ(1U, GetAndResetSentEventCount());
+      SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       EXPECT_EQ(2U, all_sent_events().size());
       EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
       EXPECT_GESTURE_SCROLL_END_WITH_PHASE(sent_gesture_event(1));
       EXPECT_EQ(2U, GetAndResetSentEventCount());
+
+      // Send a double phase end; OSX does it consistently.
+      SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                              kWheelScrollGlobalY, 0, 0, 0, high_precision,
+                              WebMouseWheelEvent::kPhaseEnded,
+                              WebMouseWheelEvent::kPhaseNone);
+      EXPECT_EQ(1U, GetAndResetSentEventCount());
+      SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+      EXPECT_EQ(0U, all_sent_events().size());
+      EXPECT_EQ(0U, GetAndResetSentEventCount());
     }
 
-    // Send a double phase end; OSX does it consistently.
-    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                            kWheelScrollGlobalY, 0, 0, 0, high_precision,
-                            WebMouseWheelEvent::kPhaseEnded,
-                            WebMouseWheelEvent::kPhaseNone);
-    EXPECT_EQ(1U, GetAndResetSentEventCount());
-    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-    EXPECT_EQ(0U, all_sent_events().size());
-    EXPECT_EQ(0U, GetAndResetSentEventCount());
-
     SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                             kWheelScrollGlobalY, 5, 5, 0, high_precision,
                             WebMouseWheelEvent::kPhaseNone,
                             WebMouseWheelEvent::kPhaseBegan);
     EXPECT_EQ(1U, GetAndResetSentEventCount());
     SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     if (scroll_latching_enabled_) {
       // A fling has started, no ScrollEnd/ScrollBegin is sent.
       EXPECT_EQ(1U, all_sent_events().size());
       EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(0));
@@ skipping 98 matching lines @@
   PhaseGestureSendingTest(false);
 }
 
 TEST_P(MouseWheelEventQueueTest,
        GestureSendingWithPhaseInformationPrecisePixels) {
   PhaseGestureSendingTest(true);
 }
 
 TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels;
-
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false);
+  SendMouseWheelPossiblyIncludingPhase(
+      !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+      kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false,
+      WebMouseWheelEvent::kPhaseBegan, WebMouseWheelEvent::kPhaseNone);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   if (scroll_latching_enabled_) {
     EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+    EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0));
+    EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
     EXPECT_EQ(2U, GetAndResetSentEventCount());
   } else {
     EXPECT_EQ(3U, all_sent_events().size());
     EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
     EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
     EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2));
     EXPECT_EQ(3U, GetAndResetSentEventCount());
   }
 
+  // When wheel scroll latching is enabled and a touch based GSB arrives in the
+  // middle of wheel scrolling sequence, a synthetic wheel event with zero
+  // deltas and phase = |kPhaseEnded| will be sent.
+  if (scroll_latching_enabled_) {
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 0, 0, 0, false,
+                            WebMouseWheelEvent::kPhaseEnded,
+                            WebMouseWheelEvent::kPhaseNone);
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  }
   // Ensure that a gesture scroll begin terminates the current scroll event.
   SendGestureEvent(WebInputEvent::kGestureScrollBegin);
+
   if (scroll_latching_enabled_) {
-    EXPECT_EQ(1U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
-    EXPECT_EQ(1U, GetAndResetSentEventCount());
+    EXPECT_EQ(2U, all_sent_events().size());
+    EXPECT_GESTURE_SCROLL_END_WITH_PHASE(sent_gesture_event(1));
+    EXPECT_EQ(2U, GetAndResetSentEventCount());
   } else {
     // ScrollEnd has already been sent.
     EXPECT_EQ(0U, all_sent_events().size());
   }
 
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false);
+  SendMouseWheelPossiblyIncludingPhase(
+      !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+      kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false,
+      WebMouseWheelEvent::kPhaseBegan, WebMouseWheelEvent::kPhaseNone);
+
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // New mouse wheel events won't cause gestures because a scroll
   // is already in progress by another device.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, all_sent_events().size());
 
   SendGestureEvent(WebInputEvent::kGestureScrollEnd);
   EXPECT_EQ(0U, all_sent_events().size());
 
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false);
+  SendMouseWheelPossiblyIncludingPhase(
+      !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+      kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false,
+      WebMouseWheelEvent::kPhaseBegan, WebMouseWheelEvent::kPhaseNone);
+
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   if (scroll_latching_enabled_) {
     EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+    EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0));
+    EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
     EXPECT_EQ(2U, GetAndResetSentEventCount());
   } else {
     EXPECT_EQ(3U, all_sent_events().size());
     EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
     EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
     EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2));
     EXPECT_EQ(3U, GetAndResetSentEventCount());
   }
 }
 
 TEST_P(MouseWheelEventQueueTest, GestureRailScrolling) {
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels;
 
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false,
-                 WebInputEvent::kRailsModeHorizontal);
+  SendMouseWheelPossiblyIncludingPhase(
+      !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+      kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false,
+      WebMouseWheelEvent::kPhaseBegan, WebMouseWheelEvent::kPhaseNone,
+      WebInputEvent::kRailsModeHorizontal);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   if (scroll_latching_enabled_) {
     EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+    EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0));
+    EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
     EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x);
     EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y);
     EXPECT_EQ(2U, GetAndResetSentEventCount());
-    RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2);
-    EXPECT_EQ(1U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
-    EXPECT_EQ(1U, GetAndResetSentEventCount());
   } else {
     EXPECT_EQ(3U, all_sent_events().size());
     EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
     EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
     EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2));
     EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x);
     EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y);
     EXPECT_EQ(3U, GetAndResetSentEventCount());
   }
+  SendMouseWheelPossiblyIncludingPhase(
+      !scroll_latching_enabled_, kWheelScrollX, kWheelScrollY,
+      kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false,
+      WebMouseWheelEvent::kPhaseChanged, WebMouseWheelEvent::kPhaseNone,
+      WebInputEvent::kRailsModeVertical);
 
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false,
-                 WebInputEvent::kRailsModeVertical);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  size_t scroll_update_index = 0;
   if (scroll_latching_enabled_) {
-    EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+    EXPECT_EQ(1U, all_sent_events().size());
+    EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0));
   } else {
     EXPECT_EQ(3U, all_sent_events().size());
     EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
     EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
     EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2));
+    scroll_update_index = 1;
   }
-  EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_x);
-  EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_y);
+  EXPECT_EQ(
+      0U, sent_gesture_event(scroll_update_index)->data.scroll_update.delta_x);
+  EXPECT_EQ(
+      1U, sent_gesture_event(scroll_update_index)->data.scroll_update.delta_y);
   if (scroll_latching_enabled_)
-    EXPECT_EQ(2U, GetAndResetSentEventCount());
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
   else
     EXPECT_EQ(3U, GetAndResetSentEventCount());
 }
 
 TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) {
   if (!scroll_latching_enabled_)
     return;
 
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels;
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false,
-                 WebInputEvent::kRailsModeVertical);
+  SendMouseWheelWithPhase(
+      kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 1,
+      1, 0, false, WebMouseWheelEvent::kPhaseBegan,
+      WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeVertical);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-  EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
+  EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0));
+  EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1));
   EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_x);
   EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_y);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 
-  RunTasksAndWait(DefaultScrollEndTimeoutDelay() / 2);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
-                 kWheelScrollGlobalY, 1, 1, 0, false,
-                 WebInputEvent::kRailsModeVertical);
+  SendMouseWheelWithPhase(
+      kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 1,
+      1, 0, false, WebMouseWheelEvent::kPhaseChanged,
+      WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeVertical);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Scroll latching: no new scroll begin expected.
   EXPECT_EQ(1U, all_sent_events().size());
-  EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(0));
+  EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0));
   EXPECT_EQ(0U, sent_gesture_event(0)->data.scroll_update.delta_x);
   EXPECT_EQ(1U, sent_gesture_event(0)->data.scroll_update.delta_y);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests,
                         MouseWheelEventQueueTest,
                         testing::Bool());
 
 }  // namespace content