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 159 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 = TimeTicks::FromSeconds(e.timeStampSeconds);
+  m_timestamp = TimeTicks::FromSeconds(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 92 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 = TimeTicks::FromSeconds(event.timeStampSeconds);
+  m_type = toPlatformTouchEventType(event.type());
+  m_modifiers = event.modifiers();
+  m_timestamp = TimeTicks::FromSeconds(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;
 }
 
 static FloatPoint convertAbsoluteLocationForLayoutObjectFloat(
     const DoublePoint& location,
     const LayoutItem layoutItem) {
   return layoutItem.absoluteToLocal(FloatPoint(location), UseTransforms);
 }
 
 static IntPoint convertAbsoluteLocationForLayoutObjectInt(
     const DoublePoint& location,
     const LayoutItem layoutItem) {
   return roundedIntPoint(
       convertAbsoluteLocationForLayoutObjectFloat(location, layoutItem));
 }
 
 // FIXME: Change |widget| to const Widget& after RemoteFrames get
 // RemoteFrameViews.
 static void updateWebMouseEventFromCoreMouseEvent(const MouseEvent& event,
                                                   const Widget* widget,
                                                   const LayoutItem layoutItem,
                                                   WebMouseEvent& webEvent) {
-  webEvent.timeStampSeconds = event.platformTimeStamp().InSeconds();
-  webEvent.modifiers = event.modifiers();
+  webEvent.setTimeStampSeconds(event.platformTimeStamp().InSeconds());
+  webEvent.setModifiers(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().InSeconds();
+  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().InSeconds();
-  modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp().InSeconds();
+  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;
 }
 
 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().InSeconds();
+  m_modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp().InSeconds();
   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().InSeconds();
-  modifiers = event.modifiers();
+  m_timeStampSeconds = event.platformTimeStamp().InSeconds();
+  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());
 }
 
 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