Return a enumeration of the state of handling of InputEvents.

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 298 matching lines @@
 void WebFrameWidgetImpl::themeChanged()
 {
     FrameView* view = m_localRoot->frameView();
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     view->invalidateRect(damagedRect);
 }
 
 const WebInputEvent* WebFrameWidgetImpl::m_currentInputEvent = nullptr;
 
-bool WebFrameWidgetImpl::handleInputEvent(const WebInputEvent& inputEvent)
+WebInputEventResult WebFrameWidgetImpl::handleInputEvent(const WebInputEvent& inputEvent)
 {
 
     TRACE_EVENT1("input", "WebFrameWidgetImpl::handleInputEvent", "type", inputTypeToName(inputEvent.type));
 
     // Report the event to be NOT processed by WebKit, so that the browser can handle it appropriately.
     if (m_ignoreInputEvents)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // FIXME: pass event to m_localRoot's WebDevToolsAgentImpl once available.
 
     TemporaryChange<const WebInputEvent*> currentEventChange(m_currentInputEvent, &inputEvent);
 
     if (m_mouseCaptureNode && WebInputEvent::isMouseEventType(inputEvent.type)) {
         TRACE_EVENT1("input", "captured mouse event", "type", inputEvent.type);
         // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.
         RefPtrWillBeRawPtr<Node> node = m_mouseCaptureNode;
 
@@ skipping 20 matching lines @@
             eventType = EventTypeNames::mouseup;
             gestureIndicator = adoptPtr(new UserGestureIndicator(m_mouseCaptureGestureToken.release()));
             break;
         default:
             ASSERT_NOT_REACHED();
         }
 
         node->dispatchMouseEvent(
             PlatformMouseEventBuilder(m_localRoot->frameView(), static_cast<const WebMouseEvent&>(inputEvent)),
             eventType, static_cast<const WebMouseEvent&>(inputEvent).clickCount);
-        return true;
+        return WebInputEventResult::HandledSystem;
     }
 
     return PageWidgetDelegate::handleInputEvent(*this, inputEvent, m_localRoot->frame());
 }
 
 void WebFrameWidgetImpl::setCursorVisibilityState(bool isVisible)
 {
     page()->setIsCursorVisible(isVisible);
 }
 
@@ skipping 319 matching lines @@
     PageWidgetEventHandler::handleMouseUp(mainFrame, event);
 
     if (page()->settings().showContextMenuOnMouseUp()) {
         // Dispatch the contextmenu event regardless of if the click was swallowed.
         // On Mac/Linux, we handle it on mouse down, not up.
         if (event.button == WebMouseEvent::ButtonRight)
             mouseContextMenu(event);
     }
 }
 
-bool WebFrameWidgetImpl::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
+WebInputEventResult WebFrameWidgetImpl::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
 {
     return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
 }
 
-bool WebFrameWidgetImpl::handleGestureEvent(const WebGestureEvent& event)
+WebInputEventResult WebFrameWidgetImpl::handleGestureEvent(const WebGestureEvent& event)
 {
-    bool eventSwallowed = false;
+    WebInputEventResult eventResult = WebInputEventResult::NotHandled;
     bool eventCancelled = false;
     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 false;
+        return WebInputEventResult::NotHandled;
     default:
         ASSERT_NOT_REACHED();
     }
     LocalFrame* frame = m_localRoot->frame();
-    eventSwallowed = frame->eventHandler().handleGestureEvent(PlatformGestureEventBuilder(frame->view(), event));
+    eventResult = frame->eventHandler().handleGestureEvent(PlatformGestureEventBuilder(frame->view(), event));
     m_client->didHandleGestureEvent(event, eventCancelled);
-    return eventSwallowed;
+    return eventResult;
 }
 
-bool WebFrameWidgetImpl::handleKeyEvent(const WebKeyboardEvent& event)
+WebInputEventResult WebFrameWidgetImpl::handleKeyEvent(const WebKeyboardEvent& event)
 {
     ASSERT((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;
 
     RefPtrWillBeRawPtr<Frame> focusedFrame = focusedCoreFrame();
     if (focusedFrame && focusedFrame->isRemoteFrame()) {
         WebRemoteFrameImpl* webFrame = WebRemoteFrameImpl::fromFrame(*toRemoteFrame(focusedFrame.get()));
         webFrame->client()->forwardInputEvent(&event);
-        return true;
+        return WebInputEventResult::HandledSystem;
     }
 
     if (!focusedFrame || !focusedFrame->isLocalFrame())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     RefPtrWillBeRawPtr<LocalFrame> frame = toLocalFrame(focusedFrame.get());
 
     PlatformKeyboardEventBuilder evt(event);
 
-    if (frame->eventHandler().keyEvent(evt)) {
+    WebInputEventResult result = frame->eventHandler().keyEvent(evt);
+    if (result != WebInputEventResult::NotHandled) {
         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 true;
+        return result;
     }
 
 #if !OS(MACOSX)
     const WebInputEvent::Type contextMenuTriggeringEventType =
 #if OS(WIN)
         WebInputEvent::KeyUp;
 #else
         WebInputEvent::RawKeyDown;
 #endif
 
     bool isUnmodifiedMenuKey = !(event.modifiers & WebInputEvent::InputModifiers) && event.windowsKeyCode == VKEY_APPS;
     bool isShiftF10 = event.modifiers == WebInputEvent::ShiftKey && event.windowsKeyCode == VKEY_F10;
     if ((isUnmodifiedMenuKey || isShiftF10) && event.type == contextMenuTriggeringEventType) {
         view()->sendContextMenuEvent(event);
-        return true;
+        return WebInputEventResult::HandledSystem;
     }
 #endif // !OS(MACOSX)
 
     return keyEventDefault(event);
 }
 
-bool WebFrameWidgetImpl::handleCharEvent(const WebKeyboardEvent& event)
+WebInputEventResult WebFrameWidgetImpl::handleCharEvent(const WebKeyboardEvent& event)
 {
     ASSERT(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());
     if (!frame)
-        return suppress;
+        return suppress ? WebInputEventResult::HandledSuppressed : WebInputEventResult::NotHandled;
 
     EventHandler& handler = frame->eventHandler();
 
     PlatformKeyboardEventBuilder evt(event);
     if (!evt.isCharacterKey())
-        return true;
+        return WebInputEventResult::HandledSuppressed;
 
     // Accesskeys are triggered by char events and can't be suppressed.
     if (handler.handleAccessKey(evt))
-        return true;
+        return WebInputEventResult::HandledSystem;

[Rick Byers, 2015/11/27 21:31:53]

since this event never makes it to the application, perhaps it should be
"Suppressed" instead?

[dtapuska, 2015/11/30 16:15:43]

I think that would be odd this is UA behaviour; although I'd probably argue
there is a bug here in that Firefox seems to always be dispatching the keypress
event. (opened bug 563507)

[Rick Byers, 2015/12/02 14:52:10]

Ok, so we think it's a bug that we're suppressing this, it really should be the
default action.  I guess it's OK if you prefer to have the return value indicate
what the code is _supposed_ to be doing (not what it actually did) as long as
you plan to try to fix this one way or another.

 
     // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to
     // the eventHandler::keyEvent. We mimic this behavior on all platforms since
     // for now we are converting other platform's key events to windows key
     // events.
     if (evt.isSystemKey())
-        return false;
+        return WebInputEventResult::NotHandled;
 
-    if (!suppress && !handler.keyEvent(evt))
-        return keyEventDefault(event);
+    if (suppress)
+        return WebInputEventResult::HandledSuppressed;
 
-    return true;
+    WebInputEventResult result = handler.keyEvent(evt);
+    if (result != WebInputEventResult::NotHandled)
+        return result;
+
+    return keyEventDefault(event);
 }
 
-
-bool WebFrameWidgetImpl::keyEventDefault(const WebKeyboardEvent& event)
+WebInputEventResult WebFrameWidgetImpl::keyEventDefault(const WebKeyboardEvent& event)
 {
     LocalFrame* frame = toLocalFrame(focusedCoreFrame());
     if (!frame)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     switch (event.type) {
     case WebInputEvent::Char:
         if (event.windowsKeyCode == VKEY_SPACE) {
             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
             return scrollViewWithKeyboard(keyCode, event.modifiers);
         }
         break;
     case WebInputEvent::RawKeyDown:
         if (event.modifiers == WebInputEvent::ControlKey) {
             switch (event.windowsKeyCode) {
 #if !OS(MACOSX)
             case 'A':
                 WebFrame::fromFrame(focusedCoreFrame())->executeCommand(WebString::fromUTF8("SelectAll"));
-                return true;
+                return WebInputEventResult::HandledSystem;
             case VKEY_INSERT:
             case 'C':
                 WebFrame::fromFrame(focusedCoreFrame())->executeCommand(WebString::fromUTF8("Copy"));
-                return true;
+                return WebInputEventResult::HandledSystem;
 #endif
             // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
             // key combinations which affect scrolling. Safari is buggy in the
             // sense that it scrolls the page for all Ctrl+scrolling key
             // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc.
             case VKEY_HOME:
             case VKEY_END:
                 break;
             default:
-                return false;
+                return WebInputEventResult::NotHandled;
             }
         }
         if (!event.isSystemKey && !(event.modifiers & WebInputEvent::ShiftKey))
             return scrollViewWithKeyboard(event.windowsKeyCode, event.modifiers);
         break;
     default:
         break;
     }
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
-bool WebFrameWidgetImpl::scrollViewWithKeyboard(int keyCode, int modifiers)
+WebInputEventResult WebFrameWidgetImpl::scrollViewWithKeyboard(int keyCode, int modifiers)
 {
     ScrollDirection scrollDirection;
     ScrollGranularity scrollGranularity;
 #if OS(MACOSX)
     // Control-Up/Down should be PageUp/Down on Mac.
     if (modifiers & WebMouseEvent::ControlKey) {
         if (keyCode == VKEY_UP)
             keyCode = VKEY_PRIOR;
         else if (keyCode == VKEY_DOWN)
             keyCode = VKEY_NEXT;
     }
 #endif
     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))
-        return false;
+        return WebInputEventResult::NotHandled;
 
-    if (LocalFrame* frame = toLocalFrame(focusedCoreFrame()))
-        return frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity);
-    return false;
+    LocalFrame* frame = toLocalFrame(focusedCoreFrame());
+    if (frame && frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity))
+        return WebInputEventResult::HandledSystem;
+    return WebInputEventResult::NotHandled;
 }
 
 bool WebFrameWidgetImpl::mapKeyCodeForScroll(
     int keyCode,
     ScrollDirection* scrollDirection,
     ScrollGranularity* scrollGranularity)
 {
     switch (keyCode) {
     case VKEY_LEFT:
         *scrollDirection = ScrollLeftIgnoringWritingMode;
@@ skipping 154 matching lines @@
 
 HitTestResult WebFrameWidgetImpl::hitTestResultForRootFramePos(const IntPoint& posInRootFrame)
 {
     IntPoint docPoint(m_localRoot->frame()->view()->rootFrameToContents(posInRootFrame));
     HitTestResult result = m_localRoot->frame()->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active);
     result.setToShadowHostIfInUserAgentShadowRoot();
     return result;
 }
 
 } // namespace blink