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 16 matching lines @@
 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);
 }
 
+struct CombinedEvent {

[tdresser, 2016/03/09 14:30:06]

What about just storing a WebInputEvent?
You'd need a few extra casts, but it might be cleaner.

[dtapuska, 2016/03/09 16:12:29]

Done.

+ public:
+  explicit CombinedEvent(const WebGestureEvent& event) { data.gesture = event; }
+  explicit CombinedEvent(const WebMouseWheelEvent& event) {
+    data.mouse_wheel = event;
+  }
+  union Data {
+    WebGestureEvent gesture;
+    WebMouseWheelEvent mouse_wheel;
+
+    Data() { memset(this, 0, sizeof(Data)); }
+  } data;
+};
+
+#define EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event)                          \
+  EXPECT_EQ(WebInputEvent::GestureScrollBegin, event.data.gesture.type); \
+  EXPECT_EQ(kWheelScrollX, event.data.gesture.x);                        \
+  EXPECT_EQ(kWheelScrollY, event.data.gesture.y);                        \
+  EXPECT_EQ(kWheelScrollGlobalX, event.data.gesture.globalX);            \
+  EXPECT_EQ(kWheelScrollGlobalY, event.data.gesture.globalY);            \
+  EXPECT_EQ(scroll_units, event.data.gesture.data.scrollBegin.deltaHintUnits);
+
+#define EXPECT_GESTURE_SCROLL_BEGIN(event)                     \
+  EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);                     \
+  EXPECT_FALSE(event.data.gesture.data.scrollBegin.synthetic); \
+  EXPECT_FALSE(event.data.gesture.data.scrollBegin.inertial);
+
+#define EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(event)          \
+  EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);                    \
+  EXPECT_TRUE(event.data.gesture.data.scrollBegin.synthetic); \
+  EXPECT_FALSE(event.data.gesture.data.scrollBegin.inertial);
+
+#define EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(event)            \
+  EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);                     \
+  EXPECT_FALSE(event.data.gesture.data.scrollBegin.synthetic); \
+  EXPECT_TRUE(event.data.gesture.data.scrollBegin.inertial);
+
+#define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(event) \
+  EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);                    \
+  EXPECT_TRUE(event.data.gesture.data.scrollBegin.synthetic); \
+  EXPECT_TRUE(event.data.gesture.data.scrollBegin.inertial);
+
+#define EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event)                            \
+  EXPECT_EQ(WebInputEvent::GestureScrollUpdate, event.data.gesture.type);   \
+  EXPECT_EQ(scroll_units, event.data.gesture.data.scrollUpdate.deltaUnits); \
+  EXPECT_EQ(kWheelScrollX, event.data.gesture.x);                           \
+  EXPECT_EQ(kWheelScrollY, event.data.gesture.y);                           \
+  EXPECT_EQ(kWheelScrollGlobalX, event.data.gesture.globalX);               \
+  EXPECT_EQ(kWheelScrollGlobalY, event.data.gesture.globalY);
+
+#define EXPECT_GESTURE_SCROLL_UPDATE(event) \
+  EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event); \
+  EXPECT_FALSE(event.data.gesture.data.scrollUpdate.inertial);
+
+#define EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(event) \
+  EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event);          \
+  EXPECT_TRUE(event.data.gesture.data.scrollUpdate.inertial);
+
+#define EXPECT_GESTURE_SCROLL_END_IMPL(event)                            \
+  EXPECT_EQ(WebInputEvent::GestureScrollEnd, event.data.gesture.type);   \
+  EXPECT_EQ(scroll_units, event.data.gesture.data.scrollEnd.deltaUnits); \
+  EXPECT_EQ(kWheelScrollX, event.data.gesture.x);                        \
+  EXPECT_EQ(kWheelScrollY, event.data.gesture.y);                        \
+  EXPECT_EQ(kWheelScrollGlobalX, event.data.gesture.globalX);            \
+  EXPECT_EQ(kWheelScrollGlobalY, event.data.gesture.globalY);
+
+#define EXPECT_GESTURE_SCROLL_END(event)                     \
+  EXPECT_GESTURE_SCROLL_END_IMPL(event);                     \
+  EXPECT_FALSE(event.data.gesture.data.scrollEnd.synthetic); \
+  EXPECT_FALSE(event.data.gesture.data.scrollEnd.inertial);
+
+#define EXPECT_SYNTHETIC_GESTURE_SCROLL_END(event)          \
+  EXPECT_GESTURE_SCROLL_END_IMPL(event);                    \
+  EXPECT_TRUE(event.data.gesture.data.scrollEnd.synthetic); \
+  EXPECT_FALSE(event.data.gesture.data.scrollEnd.inertial);
+
+#define EXPECT_INERTIAL_GESTURE_SCROLL_END(event)            \
+  EXPECT_GESTURE_SCROLL_END_IMPL(event);                     \
+  EXPECT_FALSE(event.data.gesture.data.scrollEnd.synthetic); \
+  EXPECT_TRUE(event.data.gesture.data.scrollEnd.inertial);
+
+#define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(event) \
+  EXPECT_GESTURE_SCROLL_END_IMPL(event);                    \
+  EXPECT_TRUE(event.data.gesture.data.scrollEnd.synthetic); \
+  EXPECT_TRUE(event.data.gesture.data.scrollEnd.inertial);
+
+#define EXPECT_MOUSE_WHEEL(event) \
+  EXPECT_EQ(WebInputEvent::MouseWheel, event.data.mouse_wheel.type);
+
 }  // namespace
 
 class MouseWheelEventQueueTest : public testing::Test,
                                  public MouseWheelEventQueueClient {
  public:
   MouseWheelEventQueueTest()
       : acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {
     SetUpForGestureTesting(false);
   }
 
   ~MouseWheelEventQueueTest() override {}
 
   // MouseWheelEventQueueClient
   void SendMouseWheelEventImmediately(
       const MouseWheelEventWithLatencyInfo& event) override {
-    sent_events_.push_back(event.event);
+    sent_events_.push_back(CombinedEvent(event.event));
   }
 
   void SendGestureEvent(const GestureEventWithLatencyInfo& event) override {
-    sent_events_.push_back(event.event);
-    sent_gesture_events_.push_back(event.event);
+    sent_events_.push_back(CombinedEvent(event.event));
   }
 
   void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event,
                             InputEventAckState ack_result) override {
     ++acked_event_count_;
     last_acked_event_ = event.event;
     last_acked_event_state_ = ack_result;
   }
 
  protected:
   void SetUpForGestureTesting(bool send_gestures) {
     queue_.reset(
         new MouseWheelEventQueue(this, send_gestures, kScrollEndTimeoutMs));
   }
 
   size_t queued_event_count() const { return queue_->queued_size(); }
 
   bool event_in_flight() const { return queue_->event_in_flight(); }
 
-  std::vector<WebInputEvent>& all_sent_events() { return sent_events_; }
-
-  std::vector<WebGestureEvent>& sent_gesture_events() {
-    return sent_gesture_events_;
-  }
+  std::vector<CombinedEvent>& all_sent_events() { return sent_events_; }
 
   const WebMouseWheelEvent& acked_event() const { return last_acked_event_; }
 
   size_t GetAndResetSentEventCount() {
     size_t count = sent_events_.size();
     sent_events_.clear();
-    sent_gesture_events_.clear();
     return count;
   }
 
   size_t GetAndResetAckedEventCount() {
     size_t count = acked_event_count_;
     acked_event_count_ = 0;
     return count;
   }
 
   void SendMouseWheelEventAck(InputEventAckState ack_result) {
     queue_->ProcessMouseWheelAck(ack_result, ui::LatencyInfo());
   }
 
   void SendMouseWheel(float x,
                       float y,
                       float global_x,
                       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 19 matching lines @@
     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_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(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
-    EXPECT_EQ(scroll_units,
-              sent_gesture_events()[1].data.scrollUpdate.deltaUnits);
-    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);
-    EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[2].type);
+    EXPECT_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[2]);
     EXPECT_EQ(3U, GetAndResetSentEventCount());
 
     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);
+    EXPECT_GESTURE_SCROLL_END(all_sent_events()[0]);
+  }
+
+  void PhaseGestureSendingTest(bool high_precision) {
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 1, 1, 0, high_precision,
+                            WebMouseWheelEvent::PhaseBegan,
+                            WebMouseWheelEvent::PhaseNone);

[tdresser, 2016/03/09 14:30:06]

I still find this difficult to read, as the expected result is so far from where
we dispatch the wheel event.

That being said, the approach you've taken with the EXPECT_* macros is a nice
cleanup.

Let's discuss this in person.

[dtapuska, 2016/03/09 16:12:29]

Done.

+    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);
+    // Send a double phase end; OSX does it consistently; note the modifiers
+    // are set differently as to avoid coalescing.
+    SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+                            kWheelScrollGlobalY, 0, 0, 1, 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(6U, queued_event_count());
+    EXPECT_TRUE(event_in_flight());
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
+
+    const WebGestureEvent::ScrollUnits scroll_units =
+        high_precision ? WebGestureEvent::PrecisePixels
+                       : WebGestureEvent::Pixels;
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(4U, all_sent_events().size());
+    EXPECT_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
+    EXPECT_SYNTHETIC_GESTURE_SCROLL_END(all_sent_events()[2]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[3]);
+    EXPECT_EQ(4U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(4U, all_sent_events().size());
+    EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
+    EXPECT_SYNTHETIC_GESTURE_SCROLL_END(all_sent_events()[2]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[3]);
+    EXPECT_EQ(4U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(3U, all_sent_events().size());
+    EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_GESTURE_SCROLL_END(all_sent_events()[1]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[2]);
+    EXPECT_EQ(3U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(1U, all_sent_events().size());
+    EXPECT_MOUSE_WHEEL(all_sent_events()[0]);
+    EXPECT_EQ(1U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(4U, all_sent_events().size());
+    EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
+    EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(all_sent_events()[2]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[3]);
+    EXPECT_EQ(4U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(4U, all_sent_events().size());
+    EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
+    EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(all_sent_events()[2]);
+    EXPECT_MOUSE_WHEEL(all_sent_events()[3]);
+    EXPECT_EQ(4U, GetAndResetSentEventCount());
+
+    SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    EXPECT_EQ(2U, all_sent_events().size());
+    EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+    EXPECT_INERTIAL_GESTURE_SCROLL_END(all_sent_events()[1]);
+    EXPECT_EQ(2U, GetAndResetSentEventCount());
   }
 
   scoped_ptr<MouseWheelEventQueue> queue_;
-  std::vector<WebInputEvent> sent_events_;
-  std::vector<WebGestureEvent> sent_gesture_events_;
+  std::vector<CombinedEvent> sent_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.
 TEST_F(MouseWheelEventQueueTest, Basic) {
   SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
                  kWheelScrollGlobalY, 1, 1, 0, false);
@@ skipping 28 matching lines @@
 TEST_F(MouseWheelEventQueueTest, GestureSending) {
   SetUpForGestureTesting(true);
   GestureSendingTest(false);
 }
 
 TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
   SetUpForGestureTesting(true);
   GestureSendingTest(false);
 }
 
+TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) {
+  SetUpForGestureTesting(true);
+  PhaseGestureSendingTest(false);
+}
+
+TEST_F(MouseWheelEventQueueTest,
+       GestureSendingWithPhaseInformationPrecisePixels) {
+  SetUpForGestureTesting(true);
+  PhaseGestureSendingTest(true);
+}
+
 TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) {
   SetUpForGestureTesting(true);
+  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);
   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_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
-  EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
+  EXPECT_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+  EXPECT_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 
   // Ensure that a gesture scroll begin terminates the current scroll event.
   SendGestureEvent(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(1U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type);
+  EXPECT_GESTURE_SCROLL_END(all_sent_events()[0]);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   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.
@@ skipping 13 matching lines @@
   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_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
-  EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
+  EXPECT_GESTURE_SCROLL_BEGIN(all_sent_events()[0]);
+  EXPECT_GESTURE_SCROLL_UPDATE(all_sent_events()[1]);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 }
 
 }  // namespace content