Collapse the API surface on WebInputEvent via accessor functions.

ui/events/blink/blink_event_util.cc

 // Copyright 2015 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
@@ skipping 223 matching lines @@
   static_assert(
       WebInputEvent::DispatchType::ListenersNonBlockingPassive <
           WebInputEvent::DispatchType::ListenersForcedNonBlockingDueToFling,
       "Enum not ordered correctly");
   return static_cast<WebInputEvent::DispatchType>(
       std::min(static_cast<int>(type_1), static_cast<int>(type_2)));
 }
 
 bool CanCoalesce(const WebMouseEvent& event_to_coalesce,
                  const WebMouseEvent& event) {
-  return event.type == event_to_coalesce.type &&
-         event.type == WebInputEvent::MouseMove;
+  return event.type() == event_to_coalesce.type() &&
+         event.type() == WebInputEvent::MouseMove;
 }
 
 void Coalesce(const WebMouseEvent& event_to_coalesce, WebMouseEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
   // Accumulate movement deltas.
   int x = event->movementX;
   int y = event->movementY;
   *event = event_to_coalesce;
   event->movementX += x;
   event->movementY += y;
 }
 
 bool CanCoalesce(const WebMouseWheelEvent& event_to_coalesce,
                  const WebMouseWheelEvent& event) {
-  return event.modifiers == event_to_coalesce.modifiers &&
+  return event.modifiers() == event_to_coalesce.modifiers() &&
          event.scrollByPage == event_to_coalesce.scrollByPage &&
          event.phase == event_to_coalesce.phase &&
          event.momentumPhase == event_to_coalesce.momentumPhase &&
          event.hasPreciseScrollingDeltas ==
              event_to_coalesce.hasPreciseScrollingDeltas;
 }
 
 void Coalesce(const WebMouseWheelEvent& event_to_coalesce,
               WebMouseWheelEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
@@ skipping 19 matching lines @@
   event->movementX += old_movementX;
   event->movementY += old_movementY;
   event->accelerationRatioX =
       GetAccelerationRatio(event->deltaX, unaccelerated_x);
   event->accelerationRatioY =
       GetAccelerationRatio(event->deltaY, unaccelerated_y);
 }
 
 bool CanCoalesce(const WebTouchEvent& event_to_coalesce,
                  const WebTouchEvent& event) {
-  if (event.type != event_to_coalesce.type ||
-      event.type != WebInputEvent::TouchMove ||
-      event.modifiers != event_to_coalesce.modifiers ||
+  if (event.type() != event_to_coalesce.type() ||
+      event.type() != WebInputEvent::TouchMove ||
+      event.modifiers() != event_to_coalesce.modifiers() ||
       event.touchesLength != event_to_coalesce.touchesLength ||
       event.touchesLength > WebTouchEvent::kTouchesLengthCap)
     return false;
 
   static_assert(WebTouchEvent::kTouchesLengthCap <= sizeof(int32_t) * 8U,
                 "suboptimal kTouchesLengthCap size");
   // Ensure that we have a 1-to-1 mapping of pointer ids between touches.
   std::bitset<WebTouchEvent::kTouchesLengthCap> unmatched_event_touches(
       (1 << event.touchesLength) - 1);
   for (unsigned i = 0; i < event_to_coalesce.touchesLength; ++i) {
@@ skipping 23 matching lines @@
     if (old_event.touches[i_old].state == blink::WebTouchPoint::StateMoved)
       event->touches[i].state = blink::WebTouchPoint::StateMoved;
   }
   event->movedBeyondSlopRegion |= old_event.movedBeyondSlopRegion;
   event->dispatchType = MergeDispatchTypes(old_event.dispatchType,
                                            event_to_coalesce.dispatchType);
 }
 
 bool CanCoalesce(const WebGestureEvent& event_to_coalesce,
                  const WebGestureEvent& event) {
-  if (event.type != event_to_coalesce.type ||
+  if (event.type() != event_to_coalesce.type() ||
       event.sourceDevice != event_to_coalesce.sourceDevice ||
-      event.modifiers != event_to_coalesce.modifiers)
+      event.modifiers() != event_to_coalesce.modifiers())
     return false;
 
-  if (event.type == WebInputEvent::GestureScrollUpdate)
+  if (event.type() == WebInputEvent::GestureScrollUpdate)
     return true;
 
   // GesturePinchUpdate scales can be combined only if they share a focal point,
   // e.g., with double-tap drag zoom.
-  if (event.type == WebInputEvent::GesturePinchUpdate &&
+  if (event.type() == WebInputEvent::GesturePinchUpdate &&
       event.x == event_to_coalesce.x && event.y == event_to_coalesce.y)
     return true;
 
   return false;
 }
 
 void Coalesce(const WebGestureEvent& event_to_coalesce,
               WebGestureEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
-  if (event->type == WebInputEvent::GestureScrollUpdate) {
+  if (event->type() == WebInputEvent::GestureScrollUpdate) {
     event->data.scrollUpdate.deltaX +=
         event_to_coalesce.data.scrollUpdate.deltaX;
     event->data.scrollUpdate.deltaY +=
         event_to_coalesce.data.scrollUpdate.deltaY;
     DCHECK_EQ(
         event->data.scrollUpdate.previousUpdateInSequencePrevented,
         event_to_coalesce.data.scrollUpdate.previousUpdateInSequencePrevented);
-  } else if (event->type == WebInputEvent::GesturePinchUpdate) {
+  } else if (event->type() == WebInputEvent::GesturePinchUpdate) {
     event->data.pinchUpdate.scale *= event_to_coalesce.data.pinchUpdate.scale;
     // Ensure the scale remains bounded above 0 and below Infinity so that
     // we can reliably perform operations like log on the values.
     if (event->data.pinchUpdate.scale < numeric_limits<float>::min())
       event->data.pinchUpdate.scale = numeric_limits<float>::min();
     else if (event->data.pinchUpdate.scale > numeric_limits<float>::max())
       event->data.pinchUpdate.scale = numeric_limits<float>::max();
   }
 }
 
 // Returns the transform matrix corresponding to the gesture event.
 gfx::Transform GetTransformForEvent(const WebGestureEvent& gesture_event) {
   gfx::Transform gesture_transform;
-  if (gesture_event.type == WebInputEvent::GestureScrollUpdate) {
+  if (gesture_event.type() == WebInputEvent::GestureScrollUpdate) {
     gesture_transform.Translate(gesture_event.data.scrollUpdate.deltaX,
                                 gesture_event.data.scrollUpdate.deltaY);
-  } else if (gesture_event.type == WebInputEvent::GesturePinchUpdate) {
+  } else if (gesture_event.type() == WebInputEvent::GesturePinchUpdate) {
     float scale = gesture_event.data.pinchUpdate.scale;
     gesture_transform.Translate(-gesture_event.x, -gesture_event.y);
     gesture_transform.Scale(scale, scale);
     gesture_transform.Translate(gesture_event.x, gesture_event.y);
   } else {
     NOTREACHED() << "Invalid event type for transform retrieval: "
-                 << WebInputEvent::GetName(gesture_event.type);
+                 << WebInputEvent::GetName(gesture_event.type());
   }
   return gesture_transform;
 }
 
 }  // namespace
 
 bool CanCoalesce(const blink::WebInputEvent& event_to_coalesce,
                  const blink::WebInputEvent& event) {
-  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isGestureEventType(event.type)) {
+  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isGestureEventType(event.type())) {
     return CanCoalesce(
         static_cast<const blink::WebGestureEvent&>(event_to_coalesce),
         static_cast<const blink::WebGestureEvent&>(event));
   }
-  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isMouseEventType(event.type)) {
+  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isMouseEventType(event.type())) {
     return CanCoalesce(
         static_cast<const blink::WebMouseEvent&>(event_to_coalesce),
         static_cast<const blink::WebMouseEvent&>(event));
   }
-  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isTouchEventType(event.type)) {
+  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isTouchEventType(event.type())) {
     return CanCoalesce(
         static_cast<const blink::WebTouchEvent&>(event_to_coalesce),
         static_cast<const blink::WebTouchEvent&>(event));
   }
-  if (event_to_coalesce.type == blink::WebInputEvent::MouseWheel &&
-      event.type == blink::WebInputEvent::MouseWheel) {
+  if (event_to_coalesce.type() == blink::WebInputEvent::MouseWheel &&
+      event.type() == blink::WebInputEvent::MouseWheel) {
     return CanCoalesce(
         static_cast<const blink::WebMouseWheelEvent&>(event_to_coalesce),
         static_cast<const blink::WebMouseWheelEvent&>(event));
   }
   return false;
 }
 
 void Coalesce(const blink::WebInputEvent& event_to_coalesce,
               blink::WebInputEvent* event) {
-  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isGestureEventType(event->type)) {
+  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isGestureEventType(event->type())) {
     Coalesce(static_cast<const blink::WebGestureEvent&>(event_to_coalesce),
              static_cast<blink::WebGestureEvent*>(event));
     return;
   }
-  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isMouseEventType(event->type)) {
+  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isMouseEventType(event->type())) {
     Coalesce(static_cast<const blink::WebMouseEvent&>(event_to_coalesce),
              static_cast<blink::WebMouseEvent*>(event));
     return;
   }
-  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type) &&
-      blink::WebInputEvent::isTouchEventType(event->type)) {
+  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type()) &&
+      blink::WebInputEvent::isTouchEventType(event->type())) {
     Coalesce(static_cast<const blink::WebTouchEvent&>(event_to_coalesce),
              static_cast<blink::WebTouchEvent*>(event));
     return;
   }
-  if (event_to_coalesce.type == blink::WebInputEvent::MouseWheel &&
-      event->type == blink::WebInputEvent::MouseWheel) {
+  if (event_to_coalesce.type() == blink::WebInputEvent::MouseWheel &&
+      event->type() == blink::WebInputEvent::MouseWheel) {
     Coalesce(static_cast<const blink::WebMouseWheelEvent&>(event_to_coalesce),
              static_cast<blink::WebMouseWheelEvent*>(event));
   }
 }
 
 // Whether |event_in_queue| is GesturePinchUpdate or GestureScrollUpdate and
 // has the same modifiers/source as the new scroll/pinch event. Compatible
 // scroll and pinch event pairs can be logically coalesced.
 bool IsCompatibleScrollorPinch(const WebGestureEvent& new_event,
                                const WebGestureEvent& event_in_queue) {
-  DCHECK(new_event.type == WebInputEvent::GestureScrollUpdate ||
-         new_event.type == WebInputEvent::GesturePinchUpdate)
+  DCHECK(new_event.type() == WebInputEvent::GestureScrollUpdate ||
+         new_event.type() == WebInputEvent::GesturePinchUpdate)
       << "Invalid event type for pinch/scroll coalescing: "
-      << WebInputEvent::GetName(new_event.type);
-  DLOG_IF(WARNING, new_event.timeStampSeconds < event_in_queue.timeStampSeconds)
+      << WebInputEvent::GetName(new_event.type());
+  DLOG_IF(WARNING,
+          new_event.timeStampSeconds() < event_in_queue.timeStampSeconds())
       << "Event time not monotonic?\n";
-  return (event_in_queue.type == WebInputEvent::GestureScrollUpdate ||
-          event_in_queue.type == WebInputEvent::GesturePinchUpdate) &&
-         event_in_queue.modifiers == new_event.modifiers &&
+  return (event_in_queue.type() == WebInputEvent::GestureScrollUpdate ||
+          event_in_queue.type() == WebInputEvent::GesturePinchUpdate) &&
+         event_in_queue.modifiers() == new_event.modifiers() &&
          event_in_queue.sourceDevice == new_event.sourceDevice;
 }
 
 std::pair<WebGestureEvent, WebGestureEvent> CoalesceScrollAndPinch(
     const WebGestureEvent* second_last_event,
     const WebGestureEvent& last_event,
     const WebGestureEvent& new_event) {
   DCHECK(!CanCoalesce(new_event, last_event))
       << "New event can be coalesced with the last event in queue directly.";
-  DCHECK(IsContinuousGestureEvent(new_event.type));
+  DCHECK(IsContinuousGestureEvent(new_event.type()));
   DCHECK(IsCompatibleScrollorPinch(new_event, last_event));
   DCHECK(!second_last_event ||
          IsCompatibleScrollorPinch(new_event, *second_last_event));
 
-  WebGestureEvent scroll_event;
+  WebGestureEvent scroll_event(WebInputEvent::GestureScrollUpdate,
+                               new_event.modifiers(),
+                               new_event.timeStampSeconds());
   WebGestureEvent pinch_event;
-  scroll_event.modifiers |= new_event.modifiers;
   scroll_event.sourceDevice = new_event.sourceDevice;
-  scroll_event.timeStampSeconds = new_event.timeStampSeconds;
   pinch_event = scroll_event;
-  scroll_event.type = WebInputEvent::GestureScrollUpdate;
-  pinch_event.type = WebInputEvent::GesturePinchUpdate;
-  pinch_event.x = new_event.type == WebInputEvent::GesturePinchUpdate
+  pinch_event.setType(WebInputEvent::GesturePinchUpdate);
+  pinch_event.x = new_event.type() == WebInputEvent::GesturePinchUpdate
                       ? new_event.x
                       : last_event.x;
-  pinch_event.y = new_event.type == WebInputEvent::GesturePinchUpdate
+  pinch_event.y = new_event.type() == WebInputEvent::GesturePinchUpdate
                       ? new_event.y
                       : last_event.y;
 
   gfx::Transform combined_scroll_pinch = GetTransformForEvent(last_event);
   if (second_last_event) {
     combined_scroll_pinch.PreconcatTransform(
         GetTransformForEvent(*second_last_event));
   }
   combined_scroll_pinch.ConcatTransform(GetTransformForEvent(new_event));
 
@@ skipping 18 matching lines @@
     const MotionEvent& event,
     bool moved_beyond_slop_region) {
   static_assert(static_cast<int>(MotionEvent::MAX_TOUCH_POINT_COUNT) ==
                     static_cast<int>(blink::WebTouchEvent::kTouchesLengthCap),
                 "inconsistent maximum number of active touch points");
 
   blink::WebTouchEvent result(
       ToWebTouchEventType(event.GetAction()),
       EventFlagsToWebEventModifiers(event.GetFlags()),
       ui::EventTimeStampToSeconds(event.GetEventTime()));
-  result.dispatchType = result.type == WebInputEvent::TouchCancel
+  result.dispatchType = result.type() == WebInputEvent::TouchCancel
                             ? WebInputEvent::EventNonBlocking
                             : WebInputEvent::Blocking;
   result.movedBeyondSlopRegion = moved_beyond_slop_region;
 
   // TODO(mustaq): MotionEvent flags seems unrelated, should use
   // metaState instead?
 
   DCHECK_NE(event.GetUniqueEventId(), 0U);
   result.uniqueTouchEventId = event.GetUniqueEventId();
   result.touchesLength =
@@ skipping 182 matching lines @@
   return TranslateAndScaleWebInputEvent(event, gfx::Vector2d(0, 0), scale);
 }
 
 std::unique_ptr<blink::WebInputEvent> TranslateAndScaleWebInputEvent(
     const blink::WebInputEvent& event,
     const gfx::Vector2d& delta,
     float scale) {
   std::unique_ptr<blink::WebInputEvent> scaled_event;
   if (scale == 1.f && delta.IsZero())
     return scaled_event;
-  if (event.type == blink::WebMouseEvent::MouseWheel) {
+  if (event.type() == blink::WebMouseEvent::MouseWheel) {
     blink::WebMouseWheelEvent* wheel_event = new blink::WebMouseWheelEvent;
     scaled_event.reset(wheel_event);
     *wheel_event = static_cast<const blink::WebMouseWheelEvent&>(event);
     wheel_event->x += delta.x();
     wheel_event->y += delta.y();
     wheel_event->x *= scale;
     wheel_event->y *= scale;
     wheel_event->deltaX *= scale;
     wheel_event->deltaY *= scale;
     wheel_event->wheelTicksX *= scale;
     wheel_event->wheelTicksY *= scale;
-  } else if (blink::WebInputEvent::isMouseEventType(event.type)) {
+  } else if (blink::WebInputEvent::isMouseEventType(event.type())) {
     blink::WebMouseEvent* mouse_event = new blink::WebMouseEvent;
     scaled_event.reset(mouse_event);
     *mouse_event = static_cast<const blink::WebMouseEvent&>(event);
     mouse_event->x += delta.x();
     mouse_event->y += delta.y();
     mouse_event->x *= scale;
     mouse_event->y *= scale;
     mouse_event->windowX = mouse_event->x;
     mouse_event->windowY = mouse_event->y;
     mouse_event->movementX *= scale;
     mouse_event->movementY *= scale;
-  } else if (blink::WebInputEvent::isTouchEventType(event.type)) {
+  } else if (blink::WebInputEvent::isTouchEventType(event.type())) {
     blink::WebTouchEvent* touch_event = new blink::WebTouchEvent;
     scaled_event.reset(touch_event);
     *touch_event = static_cast<const blink::WebTouchEvent&>(event);
     for (unsigned i = 0; i < touch_event->touchesLength; i++) {
       touch_event->touches[i].position.x += delta.x();
       touch_event->touches[i].position.y += delta.y();
       touch_event->touches[i].position.x *= scale;
       touch_event->touches[i].position.y *= scale;
       touch_event->touches[i].radiusX *= scale;
       touch_event->touches[i].radiusY *= scale;
     }
-  } else if (blink::WebInputEvent::isGestureEventType(event.type)) {
+  } else if (blink::WebInputEvent::isGestureEventType(event.type())) {
     blink::WebGestureEvent* gesture_event = new blink::WebGestureEvent;
     scaled_event.reset(gesture_event);
     *gesture_event = static_cast<const blink::WebGestureEvent&>(event);
     gesture_event->x += delta.x();
     gesture_event->y += delta.y();
     gesture_event->x *= scale;
     gesture_event->y *= scale;
-    switch (gesture_event->type) {
+    switch (gesture_event->type()) {
       case blink::WebInputEvent::GestureScrollUpdate:
         gesture_event->data.scrollUpdate.deltaX *= scale;
         gesture_event->data.scrollUpdate.deltaY *= scale;
         break;
       case blink::WebInputEvent::GestureScrollBegin:
         gesture_event->data.scrollBegin.deltaXHint *= scale;
         gesture_event->data.scrollBegin.deltaYHint *= scale;
         break;
 
       case blink::WebInputEvent::GesturePinchUpdate:
@@ skipping 164 matching lines @@
   switch (type) {
     case blink::WebGestureEvent::GestureScrollUpdate:
     case blink::WebGestureEvent::GesturePinchUpdate:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace ui