Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/core/input/GestureManager.cpp

 // 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 "core/input/GestureManager.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/SelectionController.h"
 #include "core/events/GestureEvent.h"
@@ skipping 79 matching lines @@
       DispatchEventResult gestureDomEventResult =
           eventTarget->dispatchEvent(gestureDomEvent);
       if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
         DCHECK(gestureDomEventResult !=
                DispatchEventResult::CanceledByEventHandler);
         return EventHandlingUtil::toWebInputEventResult(gestureDomEventResult);
       }
     }
   }
 
-  switch (gestureEvent.type) {
+  switch (gestureEvent.type()) {
     case WebInputEvent::GestureTapDown:
       return handleGestureTapDown(targetedEvent);
     case WebInputEvent::GestureTap:
       return handleGestureTap(targetedEvent);
     case WebInputEvent::GestureShowPress:
       return handleGestureShowPress();
     case WebInputEvent::GestureLongPress:
       return handleGestureLongPress(targetedEvent);
     case WebInputEvent::GestureLongTap:
       return handleGestureLongTap(targetedEvent);
@@ skipping 18 matching lines @@
       m_pointerEventManager->primaryPointerdownCanceled(
           targetedEvent.event().uniqueTouchEventId);
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult GestureManager::handleGestureTap(
     const GestureEventWithHitTestResults& targetedEvent) {
   FrameView* frameView(m_frame->view());
   const WebGestureEvent& gestureEvent = targetedEvent.event();
   HitTestRequest::HitTestRequestType hitType =
-      getHitTypeForGestureType(gestureEvent.type);
+      getHitTypeForGestureType(gestureEvent.type());
   uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
   uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
   HitTestResult currentHitTest = targetedEvent.hitTestResult();
 
   // We use the adjusted position so the application isn't surprised to see a
   // event with co-ordinates outside the target's bounds.
   IntPoint adjustedPoint = frameView->rootFrameToContents(
       flooredIntPoint(gestureEvent.positionInRootFrame()));
 
-  const unsigned modifiers = gestureEvent.modifiers;
+  const unsigned modifiers = gestureEvent.modifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
     PlatformMouseEvent fakeMouseMove(
         gestureEvent, WebPointerProperties::Button::NoButton,
         PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch,
-        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
+        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
         WebPointerProperties::PointerType::Mouse);
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
         currentHitTest.innerNode(), EventTypeNames::mousemove, fakeMouseMove);
   }
 
   // Do a new hit-test in case the mousemove event changed the DOM.
   // Note that if the original hit test wasn't over an element (eg. was over a
   // scrollbar) we don't want to re-hit-test because it may be in the wrong
   // frame (and there's no way the page could have seen the event anyway).  Also
   // note that the position of the frame may have changed, so we need to
@@ skipping 22 matching lines @@
     tappedNonTextNode = FlatTreeTraversal::parent(*tappedNonTextNode);
 
   m_mouseEventManager->setClickNode(tappedNonTextNode);
 
   PlatformMouseEvent fakeMouseDown(
       gestureEvent, WebPointerProperties::Button::Left,
       PlatformEvent::MousePressed, gestureEvent.tapCount(),
       static_cast<PlatformEvent::Modifiers>(modifiers |
                                             PlatformEvent::LeftButtonDown),
       PlatformMouseEvent::FromTouch,
-      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
+      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
       WebPointerProperties::PointerType::Mouse);
 
   // TODO(mustaq): We suppress MEs plus all it's side effects. What would that
   // mean for for TEs?  What's the right balance here? crbug.com/617255
   WebInputEventResult mouseDownEventResult =
       WebInputEventResult::HandledSuppressed;
   if (!m_suppressMouseEventsFromGestures) {
     m_mouseEventManager->setClickCount(gestureEvent.tapCount());
 
     mouseDownEventResult =
         m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
             currentHitTest.innerNode(), EventTypeNames::mousedown,
             fakeMouseDown);
     m_selectionController->initializeSelectionState();
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
       mouseDownEventResult = m_mouseEventManager->handleMouseFocus(
           currentHitTest,
           InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
       mouseDownEventResult = m_mouseEventManager->handleMousePressEvent(
           MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
   }
 
   if (currentHitTest.innerNode()) {
-    DCHECK(gestureEvent.type == WebInputEvent::GestureTap);
+    DCHECK(gestureEvent.type() == WebInputEvent::GestureTap);
     HitTestResult result = currentHitTest;
     result.setToShadowHostIfInUserAgentShadowRoot();
     m_frame->chromeClient().onMouseDown(result.innerNode());
   }
 
   // FIXME: Use a hit-test cache to avoid unnecessary hit tests.
   // http://crbug.com/398920
   if (currentHitTest.innerNode()) {
     LocalFrame* mainFrame = m_frame->localFrameRoot();
     if (mainFrame && mainFrame->view())
       mainFrame->view()->updateAllLifecyclePhases();
     adjustedPoint = frameView->rootFrameToContents(tappedPosition);
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
   PlatformMouseEvent fakeMouseUp(
       gestureEvent, WebPointerProperties::Button::Left,
       PlatformEvent::MouseReleased, gestureEvent.tapCount(),
       static_cast<PlatformEvent::Modifiers>(modifiers),
       PlatformMouseEvent::FromTouch,
-      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
+      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
       WebPointerProperties::PointerType::Mouse);
   WebInputEventResult mouseUpEventResult =
       m_suppressMouseEventsFromGestures
           ? WebInputEventResult::HandledSuppressed
           : m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
                 currentHitTest.innerNode(), EventTypeNames::mouseup,
                 fakeMouseUp);
 
   WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
   if (tappedNonTextNode) {
@@ skipping 92 matching lines @@
     const GestureEventWithHitTestResults& targetedEvent) {
   Node* innerNode = targetedEvent.hitTestResult().innerNode();
   if (innerNode && innerNode->layoutObject())
     m_selectionController->handleGestureTwoFingerTap(targetedEvent);
   return sendContextMenuEventForGesture(targetedEvent);
 }
 
 WebInputEventResult GestureManager::sendContextMenuEventForGesture(
     const GestureEventWithHitTestResults& targetedEvent) {
   const WebGestureEvent& gestureEvent = targetedEvent.event();
-  unsigned modifiers = gestureEvent.modifiers;
+  unsigned modifiers = gestureEvent.modifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
     // Send MouseMoved event prior to handling (https://crbug.com/485290).
     PlatformMouseEvent fakeMouseMove(
         gestureEvent, WebPointerProperties::Button::NoButton,
         PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch,
-        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
+        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
         WebPointerProperties::PointerType::Mouse);
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
         targetedEvent.hitTestResult().innerNode(), EventTypeNames::mousemove,
         fakeMouseMove);
   }
 
   PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
   if (m_frame->settings() && m_frame->settings()->getShowContextMenuOnMouseUp())
     eventType = PlatformEvent::MouseReleased;
 
@@ skipping 43 matching lines @@
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 TimeTicks GestureManager::getLastShowPressTimestamp() const {
   return m_lastShowPressTimestamp;
 }
 
 }  // namespace blink