MouseWheelEventQueue sends scrollEnd right away when latching is disabled.

When latching is disabled, instead of setting a timer with zero timeout
to send the scrollEnd event, we send the event right away.
This change has happened to prevent unittests from unintentionally
simulating the latching behavior when it's disabled.

BUG=706175

Review-Url: https://codereview.chromium.org/2782733002
Cr-Commit-Position: refs/heads/master@{#460516}

content/browser/renderer_host/input/input_router_impl_unittest.cc

@@ -1026,19 +1026,41 @@ TEST_F(InputRouterImplTest, UnhandledWheelEvent) {
   // were processed.
   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
 
-  // There should be a ScrollBegin and ScrollUpdate, MouseWheel sent
+  // There should be a ScrollBegin and ScrollUpdate, MouseWheel sent.
   EXPECT_EQ(3U, GetSentMessageCountAndResetSink());
 
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // 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::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
+  // There should be a ScrollBegin and ScrollUpdate sent.
+  EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
+
   // Check that the correct unhandled wheel event was received.
   EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount());
-  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
+  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
+            ack_handler_->acked_wheel_event_state());
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -10);
+
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // 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(InputRouterImplTest, TouchTypesIgnoringAck) {

content/browser/renderer_host/input/mock_input_ack_handler.cc

@@ -48,6 +48,7 @@ void MockInputAckHandler::OnWheelEventAck(
     InputEventAckState ack_result) {
   VLOG(1) << __FUNCTION__ << " called!";
   acked_wheel_event_ = event.event;
+  acked_wheel_event_state_ = ack_result;
   RecordAckCalled(event.event.type(), ack_result);
 }
 

content/browser/renderer_host/input/mock_input_ack_handler.h

@@ -55,6 +55,10 @@ class MockInputAckHandler : public InputAckHandler {
   }
   InputEventAckState ack_state() const { return ack_state_; }
 
+  InputEventAckState acked_wheel_event_state() const {
+    return acked_wheel_event_state_;
+  }
+
   blink::WebInputEvent::Type ack_event_type() const { return ack_event_type_; }
 
   const NativeWebKeyboardEvent& acked_keyboard_event() const {
@@ -80,6 +84,7 @@ class MockInputAckHandler : public InputAckHandler {
   bool unexpected_event_ack_called_;
   blink::WebInputEvent::Type ack_event_type_;
   InputEventAckState ack_state_;
+  InputEventAckState acked_wheel_event_state_;
   std::unique_ptr<NativeWebKeyboardEvent> acked_key_event_;
   blink::WebMouseWheelEvent acked_wheel_event_;
   TouchEventWithLatencyInfo acked_touch_event_;

content/browser/renderer_host/input/mouse_wheel_event_queue.cc

@@ -246,11 +246,8 @@ void MouseWheelEventQueue::ProcessMouseWheelAck(
           // crbug.com/526463 is fully implemented.
           SendScrollEnd(scroll_update, true);
         } else if (!has_phase_info) {
-          scroll_end_timer_.Start(
-              FROM_HERE,
-              base::TimeDelta::FromMilliseconds(scroll_transaction_ms_),
-              base::Bind(&MouseWheelEventQueue::SendScrollEnd,
-                         base::Unretained(this), scroll_update, false));
+          DCHECK_EQ(0, scroll_transaction_ms_);
+          SendScrollEnd(scroll_update, false);
         }
       }
     }

content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc

@@ -297,6 +297,7 @@ class MouseWheelEventQueueTest : public testing::TestWithParam<bool>,
     EXPECT_TRUE(event_in_flight());
     EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
     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));
@@ -306,6 +307,14 @@ class MouseWheelEventQueueTest : public testing::TestWithParam<bool>,
       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) {
@@ -509,16 +518,29 @@ TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   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_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);
+  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);
@@ -550,10 +572,18 @@ TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   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_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) {
@@ -572,17 +602,26 @@ TEST_P(MouseWheelEventQueueTest, GestureRailScrolling) {
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   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_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,
@@ -597,15 +636,28 @@ TEST_P(MouseWheelEventQueueTest, GestureRailScrolling) {
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   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));
+  } 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);
+  if (scroll_latching_enabled_)
     EXPECT_EQ(2U, GetAndResetSentEventCount());
+  else
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
 }
 
 TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) {
+  if (!scroll_latching_enabled_)
+    return;
+
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::Pixels;
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
@@ -627,13 +679,8 @@ TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) {
   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());
-  } else {
+  RunTasksAndWait(DefaultScrollEndTimeoutDelay() / 2);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  }
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false,
                  WebInputEvent::RailsModeVertical);
@@ -648,22 +695,12 @@ TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) {
   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 {
   // Scroll latching: no new scroll begin expected.
   EXPECT_EQ(1U, all_sent_events().size());
-    updateEventIndex = 0;
-  }
-  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());
+  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());
 }
 
 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests,