Collapse the API surface on WebInputEvent via accessor functions.

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 14 matching lines @@
 using blink::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
 const float kWheelScrollX = 10;
 const float kWheelScrollY = 12;
 const float kWheelScrollGlobalX = 50;
 const float kWheelScrollGlobalY = 72;
 
-#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);            \
+#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)         \
   EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);         \
   EXPECT_FALSE(event->data.scrollBegin.synthetic); \
   EXPECT_EQ(WebGestureEvent::UnknownMomentumPhase, \
             event->data.scrollBegin.inertialPhase);
 
 #define EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(event) \
   EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);            \
@@ skipping 13 matching lines @@
   EXPECT_EQ(WebGestureEvent::MomentumPhase,         \
             event->data.scrollBegin.inertialPhase);
 
 #define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(event) \
   EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event);                    \
   EXPECT_TRUE(event->data.scrollBegin.synthetic);             \
   EXPECT_EQ(WebGestureEvent::MomentumPhase,                   \
             event->data.scrollBegin.inertialPhase);
 
 #define EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event)                \
-  EXPECT_EQ(WebInputEvent::GestureScrollUpdate, event->type);   \
+  EXPECT_EQ(WebInputEvent::GestureScrollUpdate, event->type()); \
   EXPECT_EQ(scroll_units, event->data.scrollUpdate.deltaUnits); \
   EXPECT_EQ(kWheelScrollX, event->x);                           \
   EXPECT_EQ(kWheelScrollY, event->y);                           \
   EXPECT_EQ(kWheelScrollGlobalX, event->globalX);               \
   EXPECT_EQ(kWheelScrollGlobalY, event->globalY);
 
 #define EXPECT_GESTURE_SCROLL_UPDATE(event)        \
   EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event);        \
   EXPECT_EQ(WebGestureEvent::UnknownMomentumPhase, \
             event->data.scrollUpdate.inertialPhase);
 
 #define EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(event) \
   EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event);            \
   EXPECT_EQ(WebGestureEvent::NonMomentumPhase,         \
             event->data.scrollUpdate.inertialPhase);
 
 #define EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(event) \
   EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event);          \
   EXPECT_EQ(WebGestureEvent::MomentumPhase,          \
             event->data.scrollUpdate.inertialPhase);
 
 #define EXPECT_GESTURE_SCROLL_END_IMPL(event)                \
-  EXPECT_EQ(WebInputEvent::GestureScrollEnd, event->type);   \
+  EXPECT_EQ(WebInputEvent::GestureScrollEnd, event->type()); \
   EXPECT_EQ(scroll_units, event->data.scrollEnd.deltaUnits); \
   EXPECT_EQ(kWheelScrollX, event->x);                        \
   EXPECT_EQ(kWheelScrollY, event->y);                        \
   EXPECT_EQ(kWheelScrollGlobalX, event->globalX);            \
   EXPECT_EQ(kWheelScrollGlobalY, event->globalY);
 
 #define EXPECT_GESTURE_SCROLL_END(event)           \
   EXPECT_GESTURE_SCROLL_END_IMPL(event);           \
   EXPECT_FALSE(event->data.scrollEnd.synthetic);   \
   EXPECT_EQ(WebGestureEvent::UnknownMomentumPhase, \
@@ skipping 17 matching lines @@
   EXPECT_EQ(WebGestureEvent::MomentumPhase,       \
             event->data.scrollEnd.inertialPhase);
 
 #define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(event) \
   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);
+  EXPECT_EQ(WebInputEvent::MouseWheel, event->type());
 
 }  // namespace
 
 class MouseWheelEventQueueTest : public testing::TestWithParam<bool>,
                                  public MouseWheelEventQueueClient {
  public:
   MouseWheelEventQueueTest()
       : acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {
     scroll_latching_enabled_ = GetParam();
@@ skipping 142 matching lines @@
                    kWheelScrollGlobalY, 5, 5, 0, high_precision);
     EXPECT_EQ(1U, queued_event_count());
     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(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());
 
     RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2);
     EXPECT_EQ(1U, all_sent_events().size());
     EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0));
@@ skipping 150 matching lines @@
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Receive an ACK for the first mouse wheel event.
   SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_TRUE(event_in_flight());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
+  EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
 
   // 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);
+  EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
 }
 
 TEST_P(MouseWheelEventQueueTest, GestureSending) {
   GestureSendingTest(false);
 }
 
 TEST_P(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
   GestureSendingTest(true);
 }
 
@@ skipping 12 matching lines @@
   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(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());
 
   // 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());
 
   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);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(event_in_flight());
-  EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
+  EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, all_sent_events().size());
 
   SendGestureEvent(WebInputEvent::GestureScrollEnd);
   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());
 
   // 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(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_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(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());
 
   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(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(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());
   } 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(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());
 }
 
 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests,
                         MouseWheelEventQueueTest,
                         testing::Bool());
 
 }  // namespace content