Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/web/WebInputEventConversion.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 183 matching lines @@
 // TODO(mustaq): Add tests for this.
 PlatformMouseEventBuilder::PlatformMouseEventBuilder(Widget* widget,
                                                      const WebMouseEvent& e) {
   // FIXME: Widget is always toplevel, unless it's a popup. We may be able
   // to get rid of this once we abstract popups into a WebKit API.
   m_position = widget->convertFromRootFrame(
       flooredIntPoint(convertHitPointToRootFrame(widget, IntPoint(e.x, e.y))));
   m_globalPosition = IntPoint(e.globalX, e.globalY);
   m_movementDelta = IntPoint(scaleDeltaToWindow(widget, e.movementX),
                              scaleDeltaToWindow(widget, e.movementY));
-  m_modifiers = e.modifiers;
+  m_modifiers = e.modifiers();
 
-  m_timestamp = e.timeStampSeconds;
+  m_timestamp = e.timeStampSeconds();
   m_clickCount = e.clickCount;
 
   m_pointerProperties = static_cast<WebPointerProperties>(e);
 
-  switch (e.type) {
+  switch (e.type()) {
     case WebInputEvent::MouseMove:
     case WebInputEvent::MouseEnter:  // synthesize a move event
     case WebInputEvent::MouseLeave:  // synthesize a move event
       m_type = PlatformEvent::MouseMoved;
       break;
 
     case WebInputEvent::MouseDown:
       m_type = PlatformEvent::MousePressed;
       break;
 
@@ skipping 22 matching lines @@
   m_globalPosition = IntPoint(e.globalX, e.globalY);
   m_deltaX = scaleDeltaToWindow(widget, e.deltaX);
   m_deltaY = scaleDeltaToWindow(widget, e.deltaY);
   m_wheelTicksX = e.wheelTicksX;
   m_wheelTicksY = e.wheelTicksY;
   m_granularity =
       e.scrollByPage ? ScrollByPageWheelEvent : ScrollByPixelWheelEvent;
 
   m_type = PlatformEvent::Wheel;
 
-  m_timestamp = e.timeStampSeconds;
-  m_modifiers = e.modifiers;
+  m_timestamp = e.timeStampSeconds();
+  m_modifiers = e.modifiers();
   m_dispatchType = toPlatformDispatchType(e.dispatchType);
 
   m_hasPreciseScrollingDeltas = e.hasPreciseScrollingDeltas;
   m_resendingPluginId = e.resendingPluginId;
   m_railsMode = static_cast<PlatformEvent::RailsMode>(e.railsMode);
 #if OS(MACOSX)
   m_phase = static_cast<PlatformWheelEventPhase>(e.phase);
   m_momentumPhase = static_cast<PlatformWheelEventPhase>(e.momentumPhase);
 #endif
 }
 
 // PlatformGestureEventBuilder -----------------------------------------------
 
 PlatformGestureEventBuilder::PlatformGestureEventBuilder(
     Widget* widget,
     const WebGestureEvent& e) {
-  switch (e.type) {
+  switch (e.type()) {
     case WebInputEvent::GestureScrollBegin:
       m_type = PlatformEvent::GestureScrollBegin;
       m_data.m_scroll.m_resendingPluginId = e.resendingPluginId;
       m_data.m_scroll.m_deltaX = e.data.scrollBegin.deltaXHint;
       m_data.m_scroll.m_deltaY = e.data.scrollBegin.deltaYHint;
       m_data.m_scroll.m_deltaUnits =
           toPlatformScrollGranularity(e.data.scrollBegin.deltaHintUnits);
       m_data.m_scroll.m_inertialPhase =
           toPlatformScrollInertialPhase(e.data.scrollBegin.inertialPhase);
       m_data.m_scroll.m_synthetic = e.data.scrollBegin.synthetic;
@@ skipping 85 matching lines @@
     case WebInputEvent::GesturePinchUpdate:
       m_type = PlatformEvent::GesturePinchUpdate;
       m_data.m_pinchUpdate.m_scale = e.data.pinchUpdate.scale;
       break;
     default:
       NOTREACHED();
   }
   m_position = widget->convertFromRootFrame(flooredIntPoint(
       convertHitPointToRootFrame(widget, FloatPoint(e.x, e.y))));
   m_globalPosition = IntPoint(e.globalX, e.globalY);
-  m_timestamp = e.timeStampSeconds;
-  m_modifiers = e.modifiers;
+  m_timestamp = e.timeStampSeconds();
+  m_modifiers = e.modifiers();
   switch (e.sourceDevice) {
     case WebGestureDeviceTouchpad:
       m_source = PlatformGestureSourceTouchpad;
       break;
     case WebGestureDeviceTouchscreen:
       m_source = PlatformGestureSourceTouchscreen;
       break;
     case WebGestureDeviceUninitialized:
       NOTREACHED();
   }
@@ skipping 64 matching lines @@
       widget->convertFromRootFrame(flooredPoint) + (floatPos - flooredPoint);
 
   m_screenPos = FloatPoint(point.screenPosition.x, point.screenPosition.y);
   m_radius = scaleSizeToWindow(widget, FloatSize(point.radiusX, point.radiusY));
   m_rotationAngle = point.rotationAngle;
 }
 
 PlatformTouchEventBuilder::PlatformTouchEventBuilder(
     Widget* widget,
     const WebTouchEvent& event) {
-  m_type = toPlatformTouchEventType(event.type);
-  m_modifiers = event.modifiers;
-  m_timestamp = event.timeStampSeconds;
+  m_type = toPlatformTouchEventType(event.type());
+  m_modifiers = event.modifiers();
+  m_timestamp = event.timeStampSeconds();
   m_causesScrollingIfUncanceled = event.movedBeyondSlopRegion;
   m_touchStartOrFirstTouchMove = event.touchStartOrFirstTouchMove;
 
   for (unsigned i = 0; i < event.touchesLength; ++i)
     m_touchPoints.append(PlatformTouchPointBuilder(widget, event.touches[i]));
 
   m_dispatchType = toPlatformDispatchType(event.dispatchType);
   m_uniqueTouchEventId = event.uniqueTouchEventId;
 }
 
@@ skipping 10 matching lines @@
       convertAbsoluteLocationForLayoutObjectFloat(location, layoutItem));
 }
 
 // FIXME: Change |widget| to const Widget& after RemoteFrames get
 // RemoteFrameViews.
 static void updateWebMouseEventFromCoreMouseEvent(
     const MouseRelatedEvent& event,
     const Widget* widget,
     const LayoutItem layoutItem,
     WebMouseEvent& webEvent) {
-  webEvent.timeStampSeconds = event.platformTimeStamp();
-  webEvent.modifiers = event.modifiers();
-
   FrameView* view = widget ? toFrameView(widget->parent()) : 0;
   // TODO(bokan): If view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame(event.absoluteLocation().x(),
                             event.absoluteLocation().y());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
   webEvent.globalX = event.screenX();
   webEvent.globalY = event.screenY();
   webEvent.windowX = pointInRootFrame.x();
   webEvent.windowY = pointInRootFrame.y();
   IntPoint localPoint = convertAbsoluteLocationForLayoutObjectInt(
       event.absoluteLocation(), layoutItem);
   webEvent.x = localPoint.x();
   webEvent.y = localPoint.y();
 }
 
 WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget,
                                            const LayoutItem layoutItem,
                                            const MouseEvent& event) {
   if (event.type() == EventTypeNames::mousemove)
-    type = WebInputEvent::MouseMove;
+    m_type = WebInputEvent::MouseMove;
   else if (event.type() == EventTypeNames::mouseout)
-    type = WebInputEvent::MouseLeave;
+    m_type = WebInputEvent::MouseLeave;
   else if (event.type() == EventTypeNames::mouseover)
-    type = WebInputEvent::MouseEnter;
+    m_type = WebInputEvent::MouseEnter;
   else if (event.type() == EventTypeNames::mousedown)
-    type = WebInputEvent::MouseDown;
+    m_type = WebInputEvent::MouseDown;
   else if (event.type() == EventTypeNames::mouseup)
-    type = WebInputEvent::MouseUp;
+    m_type = WebInputEvent::MouseUp;
   else if (event.type() == EventTypeNames::contextmenu)
-    type = WebInputEvent::ContextMenu;
+    m_type = WebInputEvent::ContextMenu;
   else
     return;  // Skip all other mouse events.
 
+  m_timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
   updateWebMouseEventFromCoreMouseEvent(event, widget, layoutItem, *this);
 
   switch (event.button()) {
     case short(WebPointerProperties::Button::Left):
       button = WebMouseEvent::Button::Left;
       break;
     case short(WebPointerProperties::Button::Middle):
       button = WebMouseEvent::Button::Middle;
       break;
     case short(WebPointerProperties::Button::Right):
       button = WebMouseEvent::Button::Right;
       break;
   }
   if (event.buttonDown()) {
     switch (event.button()) {
       case short(WebPointerProperties::Button::Left):
-        modifiers |= WebInputEvent::LeftButtonDown;
+        m_modifiers |= WebInputEvent::LeftButtonDown;
         break;
       case short(WebPointerProperties::Button::Middle):
-        modifiers |= WebInputEvent::MiddleButtonDown;
+        m_modifiers |= WebInputEvent::MiddleButtonDown;
         break;
       case short(WebPointerProperties::Button::Right):
-        modifiers |= WebInputEvent::RightButtonDown;
+        m_modifiers |= WebInputEvent::RightButtonDown;
         break;
     }
   } else {
     button = WebMouseEvent::Button::NoButton;
   }
   movementX = event.movementX();
   movementY = event.movementY();
   clickCount = event.detail();
 
   pointerType = WebPointerProperties::PointerType::Mouse;
@@ skipping 14 matching lines @@
       return;
   }
 
   const Touch* touch = event.touches()->length() == 1
                            ? event.touches()->item(0)
                            : event.changedTouches()->item(0);
   if (touch->identifier())
     return;
 
   if (event.type() == EventTypeNames::touchstart)
-    type = MouseDown;
+    m_type = MouseDown;
   else if (event.type() == EventTypeNames::touchmove)
-    type = MouseMove;
+    m_type = MouseMove;
   else if (event.type() == EventTypeNames::touchend)
-    type = MouseUp;
+    m_type = MouseUp;
   else
     return;
 
-  timeStampSeconds = event.platformTimeStamp();
-  modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
 
   // The mouse event co-ordinates should be generated from the co-ordinates of
   // the touch point.
   FrameView* view = toFrameView(widget->parent());
   // FIXME: if view == nullptr, pointInRootFrame will really be
   // pointInRootContent.
   IntPoint pointInRootFrame = roundedIntPoint(touch->absoluteLocation());
   if (view)
     pointInRootFrame = view->contentsToRootFrame(pointInRootFrame);
   IntPoint screenPoint = roundedIntPoint(touch->screenLocation());
   globalX = screenPoint.x();
   globalY = screenPoint.y();
   windowX = pointInRootFrame.x();
   windowY = pointInRootFrame.y();
 
   button = WebMouseEvent::Button::Left;
-  modifiers |= WebInputEvent::LeftButtonDown;
-  clickCount = (type == MouseDown || type == MouseUp);
+  m_modifiers |= WebInputEvent::LeftButtonDown;
+  clickCount = (m_type == MouseDown || m_type == MouseUp);
 
   IntPoint localPoint = convertAbsoluteLocationForLayoutObjectInt(
       DoublePoint(touch->absoluteLocation()), layoutItem);
   x = localPoint.x();
   y = localPoint.y();
 
   pointerType = WebPointerProperties::PointerType::Touch;
 }
 
 WebMouseWheelEventBuilder::WebMouseWheelEventBuilder(
     const Widget* widget,
     const LayoutItem layoutItem,
     const WheelEvent& event) {
   if (event.type() != EventTypeNames::wheel &&
       event.type() != EventTypeNames::mousewheel)
     return;
-  type = WebInputEvent::MouseWheel;
+  m_type = WebInputEvent::MouseWheel;
+  m_timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
   updateWebMouseEventFromCoreMouseEvent(event, widget, layoutItem, *this);
   deltaX = -event.deltaX();
   deltaY = -event.deltaY();
   wheelTicksX = event.ticksX();
   wheelTicksY = event.ticksY();
   scrollByPage = event.deltaMode() == WheelEvent::kDomDeltaPage;
   resendingPluginId = event.resendingPluginId();
   railsMode = static_cast<RailsMode>(event.getRailsMode());
   hasPreciseScrollingDeltas = event.hasPreciseScrollingDeltas();
   dispatchType = event.cancelable() ? WebInputEvent::Blocking
                                     : WebInputEvent::EventNonBlocking;
 #if OS(MACOSX)
   phase = static_cast<Phase>(event.phase());
   momentumPhase = static_cast<Phase>(event.momentumPhase());
 #endif
 }
 
 WebKeyboardEventBuilder::WebKeyboardEventBuilder(const KeyboardEvent& event) {
   if (const WebKeyboardEvent* webEvent = event.keyEvent()) {
     *static_cast<WebKeyboardEvent*>(this) = *webEvent;
 
     // TODO(dtapuska): DOM KeyboardEvents converted back to WebInputEvents
     // drop the Raw behaviour. Figure out if this is actually really needed.
-    if (type == RawKeyDown)
-      type = KeyDown;
+    if (m_type == RawKeyDown)
+      m_type = KeyDown;
     return;
   }
 
   if (event.type() == EventTypeNames::keydown)
-    type = KeyDown;
+    m_type = KeyDown;
   else if (event.type() == EventTypeNames::keyup)
-    type = WebInputEvent::KeyUp;
+    m_type = WebInputEvent::KeyUp;
   else if (event.type() == EventTypeNames::keypress)
-    type = WebInputEvent::Char;
+    m_type = WebInputEvent::Char;
   else
     return;  // Skip all other keyboard events.
 
-  modifiers = event.modifiers();
-  timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp();
   windowsKeyCode = event.keyCode();
 }
 
 static WebTouchPoint toWebTouchPoint(const Touch* touch,
                                      const LayoutItem layoutItem,
                                      WebTouchPoint::State state,
                                      WebPointerProperties::PointerType type) {
   WebTouchPoint point;
   point.pointerType = type;
   point.id = touch->identifier();
@@ skipping 40 matching lines @@
       touchPoints[pointIndex] =
           toWebTouchPoint(touch, layoutItem, state, pointerType);
       ++(*touchPointsLength);
     }
   }
 }
 
 WebTouchEventBuilder::WebTouchEventBuilder(const LayoutItem layoutItem,
                                            const TouchEvent& event) {
   if (event.type() == EventTypeNames::touchstart)
-    type = TouchStart;
+    m_type = TouchStart;
   else if (event.type() == EventTypeNames::touchmove)
-    type = TouchMove;
+    m_type = TouchMove;
   else if (event.type() == EventTypeNames::touchend)
-    type = TouchEnd;
+    m_type = TouchEnd;
   else if (event.type() == EventTypeNames::touchcancel)
-    type = TouchCancel;
+    m_type = TouchCancel;
   else {
     NOTREACHED();
-    type = Undefined;
+    m_type = Undefined;
     return;
   }
 
-  timeStampSeconds = event.platformTimeStamp();
-  modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
   dispatchType = event.cancelable() ? WebInputEvent::Blocking
                                     : WebInputEvent::EventNonBlocking;
   movedBeyondSlopRegion = event.causesScrollingIfUncanceled();
 
   // Currently touches[] is empty, add stationary points as-is.
   for (unsigned i = 0;
        i < event.touches()->length() &&
        i < static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap);
        ++i) {
     touches[i] =
         toWebTouchPoint(event.touches()->item(i), layoutItem,
                         WebTouchPoint::StateStationary, event.pointerType());
     ++touchesLength;
   }
   // If any existing points are also in the change list, we should update
   // their state, otherwise just add the new points.
   addTouchPointsUpdateStateIfNecessary(
       toWebTouchPointState(event.type()), event.changedTouches(), touches,
       &touchesLength, layoutItem, event.pointerType());
 }
 
 WebGestureEventBuilder::WebGestureEventBuilder(const LayoutItem layoutItem,
                                                const GestureEvent& event) {
   if (event.type() == EventTypeNames::gestureshowpress) {
-    type = GestureShowPress;
+    m_type = GestureShowPress;
   } else if (event.type() == EventTypeNames::gesturelongpress) {
-    type = GestureLongPress;
+    m_type = GestureLongPress;
   } else if (event.type() == EventTypeNames::gesturetapdown) {
-    type = GestureTapDown;
+    m_type = GestureTapDown;
   } else if (event.type() == EventTypeNames::gesturescrollstart) {
-    type = GestureScrollBegin;
+    m_type = GestureScrollBegin;
     resendingPluginId = event.resendingPluginId();
     data.scrollBegin.deltaXHint = event.deltaX();
     data.scrollBegin.deltaYHint = event.deltaY();
     data.scrollBegin.deltaHintUnits =
         toWebGestureScrollUnits(event.deltaUnits());
     data.scrollBegin.inertialPhase =
         toWebGestureInertialPhaseState(event.inertialPhase());
     data.scrollBegin.synthetic = event.synthetic();
   } else if (event.type() == EventTypeNames::gesturescrollend) {
-    type = GestureScrollEnd;
+    m_type = GestureScrollEnd;
     resendingPluginId = event.resendingPluginId();
     data.scrollEnd.deltaUnits = toWebGestureScrollUnits(event.deltaUnits());
     data.scrollEnd.inertialPhase =
         toWebGestureInertialPhaseState(event.inertialPhase());
     data.scrollEnd.synthetic = event.synthetic();
   } else if (event.type() == EventTypeNames::gesturescrollupdate) {
-    type = GestureScrollUpdate;
+    m_type = GestureScrollUpdate;
     data.scrollUpdate.deltaUnits = toWebGestureScrollUnits(event.deltaUnits());
     data.scrollUpdate.deltaX = event.deltaX();
     data.scrollUpdate.deltaY = event.deltaY();
     data.scrollUpdate.inertialPhase =
         toWebGestureInertialPhaseState(event.inertialPhase());
     resendingPluginId = event.resendingPluginId();
   } else if (event.type() == EventTypeNames::gestureflingstart) {
-    type = GestureFlingStart;
+    m_type = GestureFlingStart;
     data.flingStart.velocityX = event.velocityX();
     data.flingStart.velocityY = event.velocityY();
   } else if (event.type() == EventTypeNames::gesturetap) {
-    type = GestureTap;
+    m_type = GestureTap;
     data.tap.tapCount = 1;
   }
 
-  timeStampSeconds = event.platformTimeStamp();
-  modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp();
+  m_modifiers = event.modifiers();
 
   globalX = event.screenX();
   globalY = event.screenY();
   IntPoint localPoint = convertAbsoluteLocationForLayoutObjectInt(
       event.absoluteLocation(), layoutItem);
   x = localPoint.x();
   y = localPoint.y();
 
   switch (event.source()) {
     case GestureSourceTouchpad:
       sourceDevice = WebGestureDeviceTouchpad;
       break;
     case GestureSourceTouchscreen:
       sourceDevice = WebGestureDeviceTouchscreen;
       break;
     case GestureSourceUninitialized:
       NOTREACHED();
   }
 }
 
 Vector<PlatformMouseEvent> createPlatformMouseEventVector(
     Widget* widget,
     const std::vector<const WebInputEvent*>& coalescedEvents) {
   Vector<PlatformMouseEvent> result;
   for (const auto& event : coalescedEvents) {
-    DCHECK(WebInputEvent::isMouseEventType(event->type));
+    DCHECK(WebInputEvent::isMouseEventType(event->type()));
     result.append(PlatformMouseEventBuilder(
         widget, static_cast<const WebMouseEvent&>(*event)));
   }
   return result;
 }
 
 Vector<PlatformTouchEvent> createPlatformTouchEventVector(
     Widget* widget,
     const std::vector<const WebInputEvent*>& coalescedEvents) {
   Vector<PlatformTouchEvent> result;
   for (const auto& event : coalescedEvents) {
-    DCHECK(WebInputEvent::isTouchEventType(event->type));
+    DCHECK(WebInputEvent::isTouchEventType(event->type()));
     result.append(PlatformTouchEventBuilder(
         widget, static_cast<const WebTouchEvent&>(*event)));
   }
   return result;
 }
 
 }  // namespace blink