Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp

 /*
  * Copyright (C) 2014 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 292 matching lines @@
 
   WebRect damagedRect(0, 0, m_size.width, m_size.height);
   view->invalidateRect(damagedRect);
 }
 
 const WebInputEvent* WebFrameWidgetImpl::m_currentInputEvent = nullptr;
 
 WebInputEventResult WebFrameWidgetImpl::handleInputEvent(
     const WebInputEvent& inputEvent) {
   TRACE_EVENT1("input", "WebFrameWidgetImpl::handleInputEvent", "type",
-               WebInputEvent::GetName(inputEvent.type));
+               WebInputEvent::GetName(inputEvent.type()));
 
   // If a drag-and-drop operation is in progress, ignore input events.
   if (m_doingDragAndDrop)
     return WebInputEventResult::HandledSuppressed;
 
   // Don't handle events once we've started shutting down.
   if (!page())
     return WebInputEventResult::NotHandled;
 
   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 (ignoreInputEvents())
     return WebInputEventResult::NotHandled;
 
   // FIXME: pass event to m_localRoot's WebDevToolsAgentImpl once available.
 
   AutoReset<const WebInputEvent*> currentEventChange(&m_currentInputEvent,
                                                      &inputEvent);
 
-  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 381 matching lines @@
 
   if (event.button == WebMouseEvent::Button::Left && m_mouseCaptureNode)
     m_mouseCaptureGestureToken =
         mainFrame.eventHandler().takeLastMouseDownGestureToken();
 
   // 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 WebFrameWidgetImpl::mouseContextMenu(const WebMouseEvent& event) {
   page()->contextMenuController().clearContextMenu();
@@ skipping 44 matching lines @@
 WebInputEventResult WebFrameWidgetImpl::handleMouseWheel(
     LocalFrame& mainFrame,
     const WebMouseWheelEvent& event) {
   return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
 }
 
 WebInputEventResult WebFrameWidgetImpl::handleGestureEvent(
     const WebGestureEvent& event) {
   WebInputEventResult eventResult = WebInputEventResult::NotHandled;
   bool eventCancelled = false;
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureScrollBegin:
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureTapUnconfirmed:
     case WebInputEvent::GestureTapDown:
     case WebInputEvent::GestureShowPress:
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureDoubleTap:
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureLongPress:
     case WebInputEvent::GestureLongTap:
       break;
     case WebInputEvent::GestureFlingStart:
     case WebInputEvent::GestureFlingCancel:
       m_client->didHandleGestureEvent(event, eventCancelled);
       return WebInputEventResult::NotHandled;
     default:
       NOTREACHED();
   }
   LocalFrame* frame = m_localRoot->frame();
   WebGestureEvent scaledEvent = TransformWebGestureEvent(frame->view(), event);
   eventResult = frame->eventHandler().handleGestureEvent(scaledEvent);
   m_client->didHandleGestureEvent(event, eventCancelled);
   return eventResult;
 }
 
 WebInputEventResult WebFrameWidgetImpl::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));
 
   // 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;
 
   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())
         m_suppressNextKeypressEvent = true;
     }
     return result;
   }
 
 #if !OS(MACOSX)
   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)) {
     view()->sendContextMenuEvent(event);
     return WebInputEventResult::HandledSystem;
   }
 #endif  // !OS(MACOSX)
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult WebFrameWidgetImpl::handleCharEvent(
     const WebKeyboardEvent& event) {
-  DCHECK_EQ(event.type, WebInputEvent::Char);
+  DCHECK_EQ(event.type(), WebInputEvent::Char);
 
   // 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;
 
   LocalFrame* frame = toLocalFrame(focusedCoreFrame());
@@ skipping 195 matching lines @@
   return nullptr;
 }
 
 LocalFrame* WebFrameWidgetImpl::focusedLocalFrameAvailableForIme() const {
   if (!m_imeAcceptEvents)
     return nullptr;
   return focusedLocalFrameInWidget();
 }
 
 }  // namespace blink