Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/core/input/KeyboardEventManager.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 "KeyboardEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/Element.h"
 #include "core/editing/Editor.h"
 #include "core/events/KeyboardEvent.h"
@@ skipping 121 matching lines @@
   visitor->trace(m_scrollManager);
 }
 
 bool KeyboardEventManager::handleAccessKey(const WebKeyboardEvent& evt) {
   // FIXME: Ignoring the state of Shift key is what neither IE nor Firefox do.
   // IE matches lower and upper case access keys regardless of Shift key state -
   // but if both upper and lower case variants are present in a document, the
   // correct element is matched based on Shift key state.  Firefox only matches
   // an access key if Shift is not pressed, and does that case-insensitively.
   DCHECK(!(kAccessKeyModifiers & WebInputEvent::ShiftKey));
-  if ((evt.modifiers & (WebKeyboardEvent::KeyModifiers &
-                        ~WebInputEvent::ShiftKey)) != kAccessKeyModifiers)
+  if ((evt.modifiers() & (WebKeyboardEvent::KeyModifiers &
+                          ~WebInputEvent::ShiftKey)) != kAccessKeyModifiers)
     return false;
   String key = String(evt.unmodifiedText);
   Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
   if (!elem)
     return false;
   elem->accessKeyAction(false);
   return true;
 }
 
 WebInputEventResult KeyboardEventManager::keyEvent(
     const WebKeyboardEvent& initialKeyEvent) {
   m_frame->chromeClient().clearToolTip(*m_frame);
 
   if (initialKeyEvent.windowsKeyCode == VK_CAPITAL)
     capsLockStateMayHaveChanged();
 
   if (m_scrollManager->middleClickAutoscrollInProgress()) {
     DCHECK(RuntimeEnabledFeatures::middleClickAutoscrollEnabled());
     // If a key is pressed while the middleClickAutoscroll is in progress then
     // we want to stop.
-    if (initialKeyEvent.type == WebInputEvent::KeyDown ||
-        initialKeyEvent.type == WebInputEvent::RawKeyDown)
+    if (initialKeyEvent.type() == WebInputEvent::KeyDown ||
+        initialKeyEvent.type() == WebInputEvent::RawKeyDown)
       m_scrollManager->stopAutoscroll();
 
     // If we were in panscroll mode, we swallow the key event
     return WebInputEventResult::HandledSuppressed;
   }
 
   // Check for cases where we are too early for events -- possible unmatched key
   // up from pressing return in the location bar.
   Node* node = eventTargetNodeForDocument(m_frame->document());
   if (!node)
     return WebInputEventResult::NotHandled;
 
   UserGestureIndicator gestureIndicator(
       DocumentUserGestureToken::create(m_frame->document()));
 
   // In IE, access keys are special, they are handled after default keydown
   // processing, but cannot be canceled - this is hard to match.  On Mac OS X,
   // we process them before dispatching keydown, as the default keydown handler
   // implements Emacs key bindings, which may conflict with access keys. Then we
   // dispatch keydown, but suppress its default handling.
   // On Windows, WebKit explicitly calls handleAccessKey() instead of
   // dispatching a keypress event for WM_SYSCHAR messages.  Other platforms
   // currently match either Mac or Windows behavior, depending on whether they
   // send combined KeyDown events.
   bool matchedAnAccessKey = false;
-  if (initialKeyEvent.type == WebInputEvent::KeyDown)
+  if (initialKeyEvent.type() == WebInputEvent::KeyDown)
     matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
   // FIXME: it would be fair to let an input method handle KeyUp events before
   // DOM dispatch.
-  if (initialKeyEvent.type == WebInputEvent::KeyUp ||
-      initialKeyEvent.type == WebInputEvent::Char) {
+  if (initialKeyEvent.type() == WebInputEvent::KeyUp ||
+      initialKeyEvent.type() == WebInputEvent::Char) {
     KeyboardEvent* domEvent = KeyboardEvent::create(
         initialKeyEvent, m_frame->document()->domWindow());
 
     return EventHandlingUtil::toWebInputEventResult(
         node->dispatchEvent(domEvent));
   }
 
   WebKeyboardEvent keyDownEvent = initialKeyEvent;
-  if (keyDownEvent.type != WebInputEvent::RawKeyDown)
+  if (keyDownEvent.type() != WebInputEvent::RawKeyDown)
     keyDownEvent.setType(WebInputEvent::RawKeyDown);
   KeyboardEvent* keydown =
       KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
   if (matchedAnAccessKey)
     keydown->setDefaultPrevented(true);
   keydown->setTarget(node);
 
   DispatchEventResult dispatchResult = node->dispatchEvent(keydown);
   if (dispatchResult != DispatchEventResult::NotCanceled)
     return EventHandlingUtil::toWebInputEventResult(dispatchResult);
   // If frame changed as a result of keydown dispatch, then return early to
   // avoid sending a subsequent keypress message to the new frame.
   bool changedFocusedFrame =
       m_frame->page() &&
       m_frame != m_frame->page()->focusController().focusedOrMainFrame();
   if (changedFocusedFrame)
     return WebInputEventResult::HandledSystem;
 
-  if (initialKeyEvent.type == WebInputEvent::RawKeyDown)
+  if (initialKeyEvent.type() == WebInputEvent::RawKeyDown)
     return WebInputEventResult::NotHandled;
 
   // Focus may have changed during keydown handling, so refetch node.
   // But if we are dispatching a fake backward compatibility keypress, then we
   // pretend that the keypress happened on the original node.
   node = eventTargetNodeForDocument(m_frame->document());
   if (!node)
     return WebInputEventResult::NotHandled;
 
 #if OS(MACOSX)
@@ skipping 216 matching lines @@
   if (currentModifiers & ::cmdKey)
     modifiers |= WebInputEvent::MetaKey;
 #else
   // TODO(crbug.com/538289): Implement on other platforms.
   return static_cast<WebInputEvent::Modifiers>(0);
 #endif
   return static_cast<WebInputEvent::Modifiers>(modifiers);
 }
 
 }  // namespace blink