Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 515 matching lines @@
     // That click triggered a page popup that is the same as the one we just
     // closed.  It needs to be closed.
     cancelPagePopup();
   }
 
   // Dispatch the contextmenu event regardless of if the click was swallowed.
   if (!page()->settings().getShowContextMenuOnMouseUp()) {
 #if OS(MACOSX)
     if (event.button == WebMouseEvent::Button::Right ||
         (event.button == WebMouseEvent::Button::Left &&
-         event.modifiers & WebMouseEvent::ControlKey))
+         event.modifiers() & WebMouseEvent::ControlKey))
       mouseContextMenu(event);
 #else
     if (event.button == WebMouseEvent::Button::Right)
       mouseContextMenu(event);
 #endif
   }
 }
 
 void WebViewImpl::setDisplayMode(WebDisplayMode mode) {
   m_displayMode = mode;
@@ skipping 144 matching lines @@
 
 WebInputEventResult WebViewImpl::handleGestureEvent(
     const WebGestureEvent& event) {
   if (!m_client)
     return WebInputEventResult::NotHandled;
 
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
   bool eventCancelled = false;  // for disambiguation
 
   // Special handling for slow-path fling gestures.
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureFlingStart: {
       if (mainFrameImpl()
               ->frame()
               ->eventHandler()
               .isScrollbarHandlingGestures())
         break;
       endActiveFlingAnimation();
       m_client->cancelScheduledContentIntents();
       m_positionOnFlingStart = WebPoint(event.x, event.y);
       m_globalPositionOnFlingStart = WebPoint(event.globalX, event.globalY);
-      m_flingModifier = event.modifiers;
+      m_flingModifier = event.modifiers();
       m_flingSourceDevice = event.sourceDevice;
       DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
       std::unique_ptr<WebGestureCurve> flingCurve =
           WTF::wrapUnique(Platform::current()->createFlingAnimationCurve(
               event.sourceDevice,
               WebFloatPoint(event.data.flingStart.velocityX,
                             event.data.flingStart.velocityY),
               WebSize()));
       DCHECK(flingCurve);
       m_gestureAnimation = WebActiveGestureAnimation::createAtAnimationStart(
@@ skipping 21 matching lines @@
       return eventResult;
     default:
       break;
   }
 
   WebGestureEvent scaledEvent =
       TransformWebGestureEvent(mainFrameImpl()->frameView(), event);
 
   // Special handling for double tap and scroll events as we don't want to
   // hit test for them.
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureDoubleTap:
       if (m_webSettings->doubleTapToZoomEnabled() &&
           minimumPageScaleFactor() != maximumPageScaleFactor()) {
         m_client->cancelScheduledContentIntents();
         animateDoubleTapZoom(
             flooredIntPoint(scaledEvent.positionInRootFrame()));
       }
       // GestureDoubleTap is currently only used by Android for zooming. For
       // WebCore, GestureTap with tap count = 2 is used instead. So we drop
       // GestureDoubleTap here.
@@ skipping 24 matching lines @@
   }
 
   // Hit test across all frames and do touch adjustment as necessary for the
   // event type.
   GestureEventWithHitTestResults targetedEvent =
       m_page->deprecatedLocalMainFrame()->eventHandler().targetGestureEvent(
           scaledEvent);
 
   // Handle link highlighting outside the main switch to avoid getting lost in
   // the complicated set of cases handled below.
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureShowPress:
       // Queue a highlight animation, then hand off to regular handler.
       enableTapHighlightAtPoint(targetedEvent);
       break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureLongPress:
       for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->startHighlightAnimationIfNeeded();
       break;
     default:
       break;
   }
 
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureTap: {
       m_client->cancelScheduledContentIntents();
       if (detectContentOnTouch(targetedEvent)) {
         eventResult = WebInputEventResult::HandledSystem;
         break;
       }
 
       // Don't trigger a disambiguation popup on sites designed for mobile
       // devices.  Instead, assume that the page has been designed with big
       // enough buttons and links.  Don't trigger a disambiguation popup when
@@ skipping 97 matching lines @@
       break;
     }
     default: { NOTREACHED(); }
   }
   m_client->didHandleGestureEvent(event, eventCancelled);
   return eventResult;
 }
 
 WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent(
     const WebGestureEvent& pinchEvent) {
-  DCHECK_EQ(pinchEvent.type, WebInputEvent::GesturePinchUpdate);
+  DCHECK_EQ(pinchEvent.type(), WebInputEvent::GesturePinchUpdate);
 
   // For pinch gesture events, match typical trackpad behavior on Windows by
   // sending fake wheel events with the ctrl modifier set when we see trackpad
   // pinch gestures.  Ideally we'd someday get a platform 'pinch' event and
   // send that instead.
   WebMouseWheelEvent wheelEvent(
       WebInputEvent::MouseWheel,
-      pinchEvent.modifiers | WebInputEvent::ControlKey,
-      pinchEvent.timeStampSeconds);
+      pinchEvent.modifiers() | WebInputEvent::ControlKey,
+      pinchEvent.timeStampSeconds());
   wheelEvent.windowX = wheelEvent.x = pinchEvent.x;
   wheelEvent.windowY = wheelEvent.y = pinchEvent.y;
   wheelEvent.globalX = pinchEvent.globalX;
   wheelEvent.globalY = pinchEvent.globalY;
   wheelEvent.deltaX = 0;
 
   // The function to convert scales to deltaY values is designed to be
   // compatible with websites existing use of wheel events, and with existing
   // Windows trackpad behavior.  In particular, we want:
   //  - deltas should accumulate via addition: f(s1*s2)==f(s1)+f(s2)
@@ skipping 135 matching lines @@
 
 float WebViewImpl::expensiveBackgroundThrottlingMaxBudget() {
   return settingsImpl()->expensiveBackgroundThrottlingMaxBudget();
 }
 
 float WebViewImpl::expensiveBackgroundThrottlingMaxDelay() {
   return settingsImpl()->expensiveBackgroundThrottlingMaxDelay();
 }
 
 WebInputEventResult WebViewImpl::handleKeyEvent(const WebKeyboardEvent& event) {
-  DCHECK((event.type == WebInputEvent::RawKeyDown) ||
-         (event.type == WebInputEvent::KeyDown) ||
-         (event.type == WebInputEvent::KeyUp));
+  DCHECK((event.type() == WebInputEvent::RawKeyDown) ||
+         (event.type() == WebInputEvent::KeyDown) ||
+         (event.type() == WebInputEvent::KeyUp));
   TRACE_EVENT2("input", "WebViewImpl::handleKeyEvent", "type",
-               WebInputEvent::GetName(event.type), "text",
+               WebInputEvent::GetName(event.type()), "text",
                String(event.text).utf8());
 
   // Halt an in-progress fling on a key event.
   endActiveFlingAnimation();
 
   // Please refer to the comments explaining the m_suppressNextKeypressEvent
   // member.
   // The m_suppressNextKeypressEvent is set if the KeyDown is handled by
   // Webkit. A keyDown event is typically associated with a keyPress(char)
   // event and a keyUp event. We reset this flag here as this is a new keyDown
   // event.
   m_suppressNextKeypressEvent = false;
 
   // If there is a popup, it should be the one processing the event, not the
   // page.
   if (m_pagePopup) {
     m_pagePopup->handleKeyEvent(event);
     // We need to ignore the next Char event after this otherwise pressing
     // enter when selecting an item in the popup will go to the page.
-    if (WebInputEvent::RawKeyDown == event.type)
+    if (WebInputEvent::RawKeyDown == event.type())
       m_suppressNextKeypressEvent = true;
     return WebInputEventResult::HandledSystem;
   }
 
   Frame* focusedFrame = focusedCoreFrame();
   if (focusedFrame && focusedFrame->isRemoteFrame()) {
     WebRemoteFrameImpl* webFrame =
         WebRemoteFrameImpl::fromFrame(*toRemoteFrame(focusedFrame));
     webFrame->client()->forwardInputEvent(&event);
     return WebInputEventResult::HandledSystem;
   }
 
   if (!focusedFrame || !focusedFrame->isLocalFrame())
     return WebInputEventResult::NotHandled;
 
   LocalFrame* frame = toLocalFrame(focusedFrame);
 
   WebInputEventResult result = frame->eventHandler().keyEvent(event);
   if (result != WebInputEventResult::NotHandled) {
-    if (WebInputEvent::RawKeyDown == event.type) {
+    if (WebInputEvent::RawKeyDown == event.type()) {
       // Suppress the next keypress event unless the focused node is a plugin
       // node.  (Flash needs these keypress events to handle non-US keyboards.)
       Element* element = focusedElement();
       if (element && element->layoutObject() &&
           element->layoutObject()->isEmbeddedObject()) {
         if (event.windowsKeyCode == VKEY_TAB) {
           // If the plugin supports keyboard focus then we should not send a tab
           // keypress event.
           Widget* widget = toLayoutPart(element->layoutObject())->widget();
           if (widget && widget->isPluginContainer()) {
@@ skipping 13 matching lines @@
   const WebInputEvent::Type contextMenuKeyTriggeringEventType =
 #if OS(WIN)
       WebInputEvent::KeyUp;
 #else
       WebInputEvent::RawKeyDown;
 #endif
   const WebInputEvent::Type shiftF10TriggeringEventType =
       WebInputEvent::RawKeyDown;
 
   bool isUnmodifiedMenuKey =
-      !(event.modifiers & WebInputEvent::InputModifiers) &&
+      !(event.modifiers() & WebInputEvent::InputModifiers) &&
       event.windowsKeyCode == VKEY_APPS;
-  bool isShiftF10 = (event.modifiers & WebInputEvent::InputModifiers) ==
+  bool isShiftF10 = (event.modifiers() & WebInputEvent::InputModifiers) ==
                         WebInputEvent::ShiftKey &&
                     event.windowsKeyCode == VKEY_F10;
   if ((isUnmodifiedMenuKey &&
-       event.type == contextMenuKeyTriggeringEventType) ||
-      (isShiftF10 && event.type == shiftF10TriggeringEventType)) {
+       event.type() == contextMenuKeyTriggeringEventType) ||
+      (isShiftF10 && event.type() == shiftF10TriggeringEventType)) {
     sendContextMenuEvent(event);
     return WebInputEventResult::HandledSystem;
   }
 #endif  // !OS(MACOSX)
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult WebViewImpl::handleCharEvent(
     const WebKeyboardEvent& event) {
-  DCHECK_EQ(event.type, WebInputEvent::Char);
+  DCHECK_EQ(event.type(), WebInputEvent::Char);
   TRACE_EVENT1("input", "WebViewImpl::handleCharEvent", "text",
                String(event.text).utf8());
 
   // Please refer to the comments explaining the m_suppressNextKeypressEvent
   // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
   // handled by Webkit. A keyDown event is typically associated with a
   // keyPress(char) event and a keyUp event. We reset this flag here as it
   // only applies to the current keyPress event.
   bool suppress = m_suppressNextKeypressEvent;
   m_suppressNextKeypressEvent = false;
@@ skipping 914 matching lines @@
 
   WebAutofillClient* autofillClient = mainFrameImpl()->autofillClient();
   UserGestureNotifier notifier(this);
   // On the first input event since page load, |notifier| instructs the
   // autofill client to unblock values of password input fields of any forms
   // on the page. There is a single input event, GestureTap, which can both
   // be the first event after page load, and cause a form submission. In that
   // case, the form submission happens before the autofill client is told
   // to unblock the password values, and so the password values are not
   // submitted. To avoid that, GestureTap is handled explicitly:
-  if (inputEvent.type == WebInputEvent::GestureTap && autofillClient) {
+  if (inputEvent.type() == WebInputEvent::GestureTap && autofillClient) {
     m_userGestureObserved = true;
     autofillClient->firstUserGestureObserved();
   }
 
   page()->frameHost().visualViewport().startTrackingPinchStats();
 
   TRACE_EVENT1("input,rail", "WebViewImpl::handleInputEvent", "type",
-               WebInputEvent::GetName(inputEvent.type));
+               WebInputEvent::GetName(inputEvent.type()));
 
   // If a drag-and-drop operation is in progress, ignore input events.
   if (mainFrameImpl()->frameWidget()->doingDragAndDrop())
     return WebInputEventResult::HandledSuppressed;
 
   if (m_devToolsEmulator->handleInputEvent(inputEvent))
     return WebInputEventResult::HandledSuppressed;
 
   if (InspectorOverlay* overlay = inspectorOverlay()) {
     if (overlay->handleInputEvent(inputEvent))
       return WebInputEventResult::HandledSuppressed;
   }
 
   // Report the event to be NOT processed by WebKit, so that the browser can
   // handle it appropriately.
   if (WebFrameWidgetBase::ignoreInputEvents())
     return WebInputEventResult::NotHandled;
 
   AutoReset<const WebInputEvent*> currentEventChange(&m_currentInputEvent,
                                                      &inputEvent);
   UIEventWithKeyState::clearNewTabModifierSetFromIsolatedWorld();
 
   bool isPointerLocked = false;
   if (WebFrameWidgetBase* widget = mainFrameImpl()->frameWidget()) {
     if (WebWidgetClient* client = widget->client())
       isPointerLocked = client->isPointerLocked();
   }
 
-  if (isPointerLocked && WebInputEvent::isMouseEventType(inputEvent.type)) {
+  if (isPointerLocked && WebInputEvent::isMouseEventType(inputEvent.type())) {
     pointerLockMouseEvent(inputEvent);
     return WebInputEventResult::HandledSystem;
   }
 
-  if (m_mouseCaptureNode && WebInputEvent::isMouseEventType(inputEvent.type)) {
-    TRACE_EVENT1("input", "captured mouse event", "type", inputEvent.type);
+  if (m_mouseCaptureNode &&
+      WebInputEvent::isMouseEventType(inputEvent.type())) {
+    TRACE_EVENT1("input", "captured mouse event", "type", inputEvent.type());
     // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.
     Node* node = m_mouseCaptureNode;
 
     // Not all platforms call mouseCaptureLost() directly.
-    if (inputEvent.type == WebInputEvent::MouseUp)
+    if (inputEvent.type() == WebInputEvent::MouseUp)
       mouseCaptureLost();
 
     std::unique_ptr<UserGestureIndicator> gestureIndicator;
 
     AtomicString eventType;
-    switch (inputEvent.type) {
+    switch (inputEvent.type()) {
       case WebInputEvent::MouseMove:
         eventType = EventTypeNames::mousemove;
         break;
       case WebInputEvent::MouseLeave:
         eventType = EventTypeNames::mouseout;
         break;
       case WebInputEvent::MouseDown:
         eventType = EventTypeNames::mousedown;
         gestureIndicator = WTF::wrapUnique(
             new UserGestureIndicator(DocumentUserGestureToken::create(
@@ skipping 17 matching lines @@
     return WebInputEventResult::HandledSystem;
   }
 
   // FIXME: This should take in the intended frame, not the local frame root.
   WebInputEventResult result = PageWidgetDelegate::handleInputEvent(
       *this, WebCoalescedInputEvent(inputEvent), mainFrameImpl()->frame());
   if (result != WebInputEventResult::NotHandled)
     return result;
 
   // Unhandled pinch events should adjust the scale.
-  if (inputEvent.type == WebInputEvent::GesturePinchUpdate) {
+  if (inputEvent.type() == WebInputEvent::GesturePinchUpdate) {
     const WebGestureEvent& pinchEvent =
         static_cast<const WebGestureEvent&>(inputEvent);
 
     // For touchpad gestures synthesize a Windows-like wheel event
     // to send to any handlers that may exist. Not necessary for touchscreen
     // as touch events would have already been sent for the gesture.
     if (pinchEvent.sourceDevice == WebGestureDeviceTouchpad) {
       result = handleSyntheticWheelFromTouchpadPinchEvent(pinchEvent);
       if (result != WebInputEventResult::NotHandled)
         return result;
@@ skipping 1875 matching lines @@
     m_overrideCompositorVisibility = true;
   else
     m_overrideCompositorVisibility = false;
   if (m_layerTreeView)
     m_layerTreeView->setVisible(isVisible);
 }
 
 void WebViewImpl::pointerLockMouseEvent(const WebInputEvent& event) {
   std::unique_ptr<UserGestureIndicator> gestureIndicator;
   AtomicString eventType;
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::MouseDown:
       eventType = EventTypeNames::mousedown;
       if (!page() || !page()->pointerLockController().element())
         break;
       gestureIndicator = WTF::wrapUnique(
           new UserGestureIndicator(DocumentUserGestureToken::create(
               &page()->pointerLockController().element()->document(),
               UserGestureToken::NewGesture)));
       m_pointerLockGestureToken = gestureIndicator->currentToken();
       break;
@@ skipping 63 matching lines @@
   if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
     return nullptr;
   return focusedFrame;
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
   return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
 }
 
 }  // namespace blink