MouseWheelEventQueue sends scrollEnd right away when latching is disabled.

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 279 matching lines @@
     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::MouseWheel, acked_event().type());
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
-    EXPECT_EQ(3U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1));
-    EXPECT_MOUSE_WHEEL(sent_input_event(2));
-    EXPECT_EQ(3U, GetAndResetSentEventCount());
+    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_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));
+      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());
+    }
   }
 
   void PhaseGestureSendingTest(bool high_precision) {
     const WebGestureEvent::ScrollUnits scroll_units =
         high_precision ? WebGestureEvent::PrecisePixels
                        : WebGestureEvent::Pixels;
 
     SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                             kWheelScrollGlobalY, 1, 1, 0, high_precision,
                             WebMouseWheelEvent::PhaseBegan,
@@ skipping 183 matching lines @@
   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::MouseWheel, acked_event().type());
   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_EQ(2U, GetAndResetSentEventCount());
+  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(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());
+  }
 
   // Ensure that a gesture scroll begin terminates the current scroll event.
   SendGestureEvent(WebInputEvent::GestureScrollBegin);
-  EXPECT_EQ(1U, all_sent_events().size());
-  EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  if (scroll_latching_enabled_) {
+    EXPECT_EQ(1U, all_sent_events().size());
+    EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
+  } else {
+    // ScrollEnd has already been sent.
+    EXPECT_EQ(0U, all_sent_events().size());
+  }
 
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false);
   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);
@@ skipping 11 matching lines @@
   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::MouseWheel, acked_event().type());
   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_EQ(2U, GetAndResetSentEventCount());
+  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(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::Pixels;
 
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
                  WebInputEvent::RailsModeHorizontal);
   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::MouseWheel, acked_event().type());
   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_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
-  EXPECT_EQ(0U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
-  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());
+  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, sent_gesture_event(1)->data.scrollUpdate.deltaX);
+    EXPECT_EQ(0U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
+    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.scrollUpdate.deltaX);
+    EXPECT_EQ(0U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
+  }
 
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
                  WebInputEvent::RailsModeVertical);
   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::MouseWheel, acked_event().type());
   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));
+  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));
+  } 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(0U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
   EXPECT_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
+  if (scroll_latching_enabled_)
+    EXPECT_EQ(2U, GetAndResetSentEventCount());
+  else
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
 }
 
 TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) {
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::Pixels;
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
                  WebInputEvent::RailsModeVertical);
   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());

[dtapuska, 2017/03/29 17:49:03]

This test is a little odd cause it is called WheelScrollLatching. Should we
return early for this test? It is unclear what it is doing when latching is
disabled.

[sahel, 2017/03/29 20:10:43]

Done.

   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   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_EQ(0U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
-  EXPECT_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
-
-  RunTasksAndWait(base::TimeDelta::FromMilliseconds(1));
-  if (!scroll_latching_enabled_) {
-    EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
-    EXPECT_EQ(1U, GetAndResetSentEventCount());
+  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(0U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
+    EXPECT_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
+    EXPECT_EQ(2U, GetAndResetSentEventCount());
+    RunTasksAndWait(DefaultScrollEndTimeoutDelay() / 2);
+    EXPECT_EQ(0U, GetAndResetSentEventCount());
   } else {
-    EXPECT_EQ(0U, GetAndResetSentEventCount());
+    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(0U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
+    EXPECT_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
   }
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
                  WebInputEvent::RailsModeVertical);
   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::MouseWheel, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
-  int updateEventIndex = -1;
-  if (!scroll_latching_enabled_) {
-    EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0));
-    updateEventIndex = 1;
-  } else {
+  if (scroll_latching_enabled_) {
     // Scroll latching: no new scroll begin expected.
     EXPECT_EQ(1U, all_sent_events().size());
-    updateEventIndex = 0;
+    EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(0));
+    EXPECT_EQ(0U, sent_gesture_event(0)->data.scrollUpdate.deltaX);
+    EXPECT_EQ(1U, sent_gesture_event(0)->data.scrollUpdate.deltaY);
+    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(0U, sent_gesture_event(1)->data.scrollUpdate.deltaX);
+    EXPECT_EQ(1U, sent_gesture_event(1)->data.scrollUpdate.deltaY);
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
   }
-  EXPECT_GE(updateEventIndex, 0);
-  EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(updateEventIndex));
-  EXPECT_EQ(0U, sent_gesture_event(updateEventIndex)->data.scrollUpdate.deltaX);
-  EXPECT_EQ(1U, sent_gesture_event(updateEventIndex)->data.scrollUpdate.deltaY);
-  EXPECT_EQ(static_cast<size_t>(updateEventIndex + 1),
-            GetAndResetSentEventCount());
 }
 
 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests,
                         MouseWheelEventQueueTest,
                         testing::Bool());
 
 }  // namespace content