Implement Wheel Gesture Scrolling on OSX.

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 <utility>
 
 #include "base/location.h"
@@ skipping 95 matching lines @@
                       float global_y,
                       float dX,
                       float dY,
                       int modifiers,
                       bool high_precision) {
     queue_->QueueEvent(MouseWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(
             x, y, global_x, global_y, dX, dY, modifiers, high_precision)));
   }
 
+  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.momentumPhase = momentum_phase;
+    queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event));
+  }
+
   void SendGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent event;
     event.type = type;
     event.sourceDevice = blink::WebGestureDeviceTouchscreen;
     queue_->OnGestureScrollEvent(
         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 46 matching lines @@
     RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2);
     EXPECT_EQ(1U, all_sent_events().size());
     EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type);
     EXPECT_EQ(scroll_units, sent_gesture_events()[0].data.scrollEnd.deltaUnits);
     EXPECT_EQ(kWheelScrollX, sent_gesture_events()[0].x);
     EXPECT_EQ(kWheelScrollY, sent_gesture_events()[0].y);
     EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[0].globalX);
     EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY);
   }
 
+  const uint32_t HAS_SCROLL_UPDATE = 1;
+  const uint32_t HAS_MOUSEWHEEL = 1 << 1;
+  const uint32_t HAS_SYNTHETIC_BEGIN = 1 << 2;
+  const uint32_t HAS_SYNTHETIC_END = 1 << 3;
+  const uint32_t HAS_INERTIAL = 1 << 4;
+
+  void ValidatePhaseSequence(bool high_precision,
+                             size_t expect_queue_count,
+                             uint32_t flags) {
+    const WebGestureEvent::ScrollUnits scroll_units =
+        high_precision ? WebGestureEvent::PrecisePixels
+                       : WebGestureEvent::Pixels;
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(expect_queue_count, queued_event_count());
+    EXPECT_EQ((flags & HAS_MOUSEWHEEL) != 0, event_in_flight());
+    EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
+
+    size_t expect_event_count = 2;
+    if (flags & HAS_SCROLL_UPDATE)
+      ++expect_event_count;
+    if (flags & HAS_MOUSEWHEEL)
+      ++expect_event_count;
+
+    EXPECT_EQ(1U, GetAndResetAckedEventCount());
+    EXPECT_EQ(expect_event_count, all_sent_events().size());
+    EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
+    EXPECT_EQ(scroll_units,
+              sent_gesture_events()[0].data.scrollBegin.deltaHintUnits);
+    EXPECT_EQ(kWheelScrollX, sent_gesture_events()[0].x);
+    EXPECT_EQ(kWheelScrollY, sent_gesture_events()[0].y);
+    EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[0].globalX);
+    EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY);
+    EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+              sent_gesture_events()[0].data.scrollBegin.inertial);
+    EXPECT_EQ((flags & HAS_SYNTHETIC_BEGIN) != 0,
+              sent_gesture_events()[0].data.scrollBegin.synthetic);
+    size_t index = 1;
+    if (flags & HAS_SCROLL_UPDATE) {
+      EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
+      EXPECT_EQ(scroll_units,
+                sent_gesture_events()[1].data.scrollUpdate.deltaUnits);
+      EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+                sent_gesture_events()[1].data.scrollUpdate.inertial);
+      EXPECT_EQ(kWheelScrollX, sent_gesture_events()[1].x);
+      EXPECT_EQ(kWheelScrollY, sent_gesture_events()[1].y);
+      EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[1].globalX);
+      EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[1].globalY);
+      ++index;
+    }
+
+    EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[index].type);
+    EXPECT_EQ(scroll_units,
+              sent_gesture_events()[index].data.scrollEnd.deltaUnits);
+    EXPECT_EQ(kWheelScrollX, sent_gesture_events()[index].x);
+    EXPECT_EQ(kWheelScrollY, sent_gesture_events()[index].y);
+    EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[index].globalX);
+    EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[index].globalY);
+    EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+              sent_gesture_events()[index].data.scrollEnd.inertial);
+    EXPECT_EQ((flags & HAS_SYNTHETIC_END) != 0,
+              sent_gesture_events()[index].data.scrollEnd.synthetic);
+    ++index;
+    if (flags & HAS_MOUSEWHEEL)
+      EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[index].type);
+    EXPECT_EQ(expect_event_count, GetAndResetSentEventCount());
+  }
+
+  void PhaseGestureSendingTest(bool high_precision) {
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 1, 1, 0, high_precision,
+                            WebMouseWheelEvent::PhaseBegan,
+                            WebMouseWheelEvent::PhaseNone);
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 5, 5, 0, high_precision,
+                            WebMouseWheelEvent::PhaseChanged,
+                            WebMouseWheelEvent::PhaseNone);
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 0, 0, 0, high_precision,
+                            WebMouseWheelEvent::PhaseEnded,
+                            WebMouseWheelEvent::PhaseNone);
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 5, 5, 0, high_precision,
+                            WebMouseWheelEvent::PhaseNone,
+                            WebMouseWheelEvent::PhaseBegan);
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 5, 5, 0, high_precision,
+                            WebMouseWheelEvent::PhaseNone,
+                            WebMouseWheelEvent::PhaseChanged);
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 0, 0, 0, high_precision,
+                            WebMouseWheelEvent::PhaseNone,
+                            WebMouseWheelEvent::PhaseEnded);
+
+    EXPECT_EQ(5U, queued_event_count());
+    EXPECT_TRUE(event_in_flight());
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
+
+    // Receive an ACK for the mouse wheel event and release the next
+    // mouse wheel event.
+    ValidatePhaseSequence(high_precision, 4U, HAS_SCROLL_UPDATE |
+                                                  HAS_MOUSEWHEEL |
+                                                  HAS_SYNTHETIC_END);

[tdresser, 2016/03/08 14:28:53]

The distance between sending the mousewheel and defining the expected result
makes this hard to follow. I also found interpreting the way that |flags| is
being used to be a bit tricky.

A few options for making this easier to read:

1. Create a local variable per set of flags, that you define directly after the
associated SendMouseWheelEventWithPhase. Rename |flags| to something like
|expected|.

2. Rename ValidatePhaseSequence to something like SendWheelAck, which returns a
struct containing the information you are currently expecting on via flags. You
could then instantiate one of these structs directly beneath each call to
SendMouseWheelWithPhase.

I think 2 would be my preference. You'd end up with something like:

SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                        kWheelScrollGlobalY, 1, 1, 0, high_precision,
                        WebMouseWheelEvent::PhaseBegan,
                        WebMouseWheelEvent::PhaseNone);
ExpectedEvents wheel_1_expected;
wheel_1_expected.has_scroll_update = true;
wheel_1_expected.has_mousewheel = true;
wheel_1_expected.has_synthetic_begin = true;
wheel_1_expected.has_synthetic_end = true;

// .. Rest of SendMouseWheelWithPhase calls, a few EXPECT's.

EXPECT_EQ(wheel_1_expected, SendWheelAck(high_precision));

[dtapuska, 2016/03/08 20:31:49]

I've replaced it with macros that I find much easier to read.

+    ValidatePhaseSequence(high_precision, 3U,
+                          HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL |
+                              HAS_SYNTHETIC_BEGIN | HAS_SYNTHETIC_END);
+    ValidatePhaseSequence(high_precision, 2U,
+                          HAS_SYNTHETIC_BEGIN | HAS_MOUSEWHEEL);
+    ValidatePhaseSequence(
+        high_precision, 1U,
+        HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL | HAS_SYNTHETIC_END | HAS_INERTIAL);
+    ValidatePhaseSequence(high_precision, 0U,
+                          HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL |
+                              HAS_SYNTHETIC_BEGIN | HAS_SYNTHETIC_END |
+                              HAS_INERTIAL);
+    ValidatePhaseSequence(high_precision, 0U,
+                          HAS_SYNTHETIC_BEGIN | HAS_INERTIAL);
+  }
+
   scoped_ptr<MouseWheelEventQueue> queue_;
   std::vector<WebInputEvent> sent_events_;
   std::vector<WebGestureEvent> sent_gesture_events_;
   size_t acked_event_count_;
   InputEventAckState last_acked_event_state_;
   base::MessageLoopForUI message_loop_;
   WebMouseWheelEvent last_acked_event_;
 };
 
 // Tests that mouse wheel events are queued properly.
@@ skipping 31 matching lines @@
 TEST_F(MouseWheelEventQueueTest, GestureSending) {
   SetUpForGestureTesting(true);
   GestureSendingTest(false);
 }
 
 TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
   SetUpForGestureTesting(true);
   GestureSendingTest(false);
 }
 
+TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) {

[tdresser, 2016/03/08 14:28:53]

You could use TEST_P here, but I don't think it has any strong benefits.

[dtapuska, 2016/03/08 20:31:49]

For two parameters; true vs false it is much more code.. but if this expands
then I agree.

+  SetUpForGestureTesting(true);
+  PhaseGestureSendingTest(false);
+}
+
+TEST_F(MouseWheelEventQueueTest,
+       GestureSendingWithPhaseInformationPrecisePixels) {
+  SetUpForGestureTesting(true);
+  PhaseGestureSendingTest(true);
+}
+
 TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   SetUpForGestureTesting(true);
   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 42 matching lines @@
   EXPECT_FALSE(event_in_flight());
   EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 }
 
 }  // namespace content