Wheel scroll latching enabled behind flag.

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 12 matching lines @@
 using blink::WebInputEvent;
 using blink::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
 const float kWheelScrollX = 10;
 const float kWheelScrollY = 12;
 const float kWheelScrollGlobalX = 50;
 const float kWheelScrollGlobalY = 72;
-const int64_t kScrollEndTimeoutMs = 100;
-
-base::TimeDelta DefaultScrollEndTimeoutDelay() {
-  return base::TimeDelta::FromMilliseconds(kScrollEndTimeoutMs);
-}
 
 #define EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event)              \
   EXPECT_EQ(WebInputEvent::GestureScrollBegin, event->type); \
   EXPECT_EQ(kWheelScrollX, event->x);                        \
   EXPECT_EQ(kWheelScrollY, event->y);                        \
   EXPECT_EQ(kWheelScrollGlobalX, event->globalX);            \
   EXPECT_EQ(kWheelScrollGlobalY, event->globalY);            \
   EXPECT_EQ(scroll_units, event->data.scrollBegin.deltaHintUnits);
 
 #define EXPECT_GESTURE_SCROLL_BEGIN(event)         \
@@ skipping 85 matching lines @@
   EXPECT_GESTURE_SCROLL_END_IMPL(event);                    \
   EXPECT_TRUE(event->data.scrollEnd.synthetic);             \
   EXPECT_EQ(WebGestureEvent::MomentumPhase,                 \
             event->data.scrollEnd.inertialPhase);
 
 #define EXPECT_MOUSE_WHEEL(event) \
   EXPECT_EQ(WebInputEvent::MouseWheel, event->type);
 
 }  // namespace
 
-class MouseWheelEventQueueTest : public testing::Test,
+class MouseWheelEventQueueTest : public testing::TestWithParam<bool>,
                                  public MouseWheelEventQueueClient {
  public:
   MouseWheelEventQueueTest()
       : acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {
-    queue_.reset(new MouseWheelEventQueue(this, kScrollEndTimeoutMs));
+    ScrollLatchingEnabled_ = GetParam();
+    queue_.reset(new MouseWheelEventQueue(this, ScrollLatchingEnabled_));
+    ScrollEndTimeoutMs_ = ScrollLatchingEnabled_ ? 100 : 0;
   }
 
   ~MouseWheelEventQueueTest() override {}
 
   // MouseWheelEventQueueClient
   void SendMouseWheelEventImmediately(
       const MouseWheelEventWithLatencyInfo& event) override {
     WebMouseWheelEvent* cloned_event = new WebMouseWheelEvent();
     std::unique_ptr<WebInputEvent> cloned_event_holder(cloned_event);
     *cloned_event = event.event;
     sent_events_.push_back(std::move(cloned_event_holder));
   }
 
   void ForwardGestureEventWithLatencyInfo(
       const blink::WebGestureEvent& event,
       const ui::LatencyInfo& latency_info) override {
     WebGestureEvent* cloned_event = new WebGestureEvent();
     std::unique_ptr<WebInputEvent> cloned_event_holder(cloned_event);
     *cloned_event = event;
     sent_events_.push_back(std::move(cloned_event_holder));
   }
 
   void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event,
                             InputEventAckState ack_result) override {
     ++acked_event_count_;
     last_acked_event_ = event.event;
     last_acked_event_state_ = ack_result;
   }
 
+  base::TimeDelta DefaultScrollEndTimeoutDelay() {
+    return base::TimeDelta::FromMilliseconds(ScrollEndTimeoutMs_);
+  }
+
+  bool ScrollLatchingEnabled() { return ScrollLatchingEnabled_; }

[tdresser, 2016/08/12 13:28:32]

scroll_latching_enabled()

Thin getters should be in underscore case.

[sahel, 2016/08/12 15:45:28]

Done.

+
  protected:
   size_t queued_event_count() const { return queue_->queued_size(); }
 
   bool event_in_flight() const { return queue_->event_in_flight(); }
 
   std::vector<std::unique_ptr<WebInputEvent>>& all_sent_events() {
     return sent_events_;
   }
 
   const std::unique_ptr<WebInputEvent>& sent_input_event(size_t index) {
@@ skipping 200 matching lines @@
     EXPECT_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(1));
     EXPECT_EQ(2U, GetAndResetSentEventCount());
   }
 
   std::unique_ptr<MouseWheelEventQueue> queue_;
   std::vector<std::unique_ptr<WebInputEvent>> sent_events_;
   size_t acked_event_count_;
   InputEventAckState last_acked_event_state_;
   base::MessageLoopForUI message_loop_;
   WebMouseWheelEvent last_acked_event_;
+  int64_t ScrollEndTimeoutMs_;

[tdresser, 2016/08/12 13:28:32]

scroll_end_timeout_ms_

[sahel, 2016/08/12 15:45:29]

Done.

+  bool ScrollLatchingEnabled_;

[tdresser, 2016/08/12 13:28:32]

scroll_latching_enabled_

[sahel, 2016/08/12 15:45:29]

Done.

 };
 
 // Tests that mouse wheel events are queued properly.
-TEST_F(MouseWheelEventQueueTest, Basic) {
+TEST_P(MouseWheelEventQueueTest, Basic) {
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false);
   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, false);
   EXPECT_EQ(1U, queued_event_count());
@@ skipping 10 matching lines @@
 
   // Receive an ACK for the second mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
 }
 
-TEST_F(MouseWheelEventQueueTest, GestureSending) {
+TEST_P(MouseWheelEventQueueTest, GestureSending) {
   GestureSendingTest(false);
 }
 
-TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
+TEST_P(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
   GestureSendingTest(false);
 }
 
-TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) {
+TEST_P(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) {
   PhaseGestureSendingTest(false);
 }
 
-TEST_F(MouseWheelEventQueueTest,
+TEST_P(MouseWheelEventQueueTest,
        GestureSendingWithPhaseInformationPrecisePixels) {
   PhaseGestureSendingTest(true);
 }
 
-TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) {
+TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::Pixels;
 
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false);
   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);
@@ skipping 41 matching lines @@
   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());
 }
 
-TEST_F(MouseWheelEventQueueTest, GestureRailScrolling) {
+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.
@@ skipping 28 matching lines @@
   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());
 }
 
+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());
+  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 (!ScrollLatchingEnabled_) {
+    // Scroll end time out happens.

[tdresser, 2016/08/12 13:28:32]

If scroll latching isn't enabled, there's no timeout, is there?
Isn't it sent immediately?

[sahel, 2016/08/12 15:45:28]

Yes, the timeout is zero. I think the comment is more confusing rather than
clarifying. I'll delete it.

+    EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
+  } else {
+    EXPECT_EQ(0U, 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 (!ScrollLatchingEnabled_) {
+    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());
+}
+
+INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests,
+                        MouseWheelEventQueueTest,
+                        testing::Bool());
+
 }  // namespace content