Return a enumeration of the state of handling of InputEvents.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 24 matching lines @@
 #include "core/clipboard/DataTransfer.h"
 #include "core/dom/Document.h"
 #include "core/dom/TouchList.h"
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/SelectionController.h"
 #include "core/events/DragEvent.h"
 #include "core/events/EventPath.h"
+#include "core/events/GestureEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
 #include "core/events/PointerEvent.h"
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
@@ skipping 41 matching lines @@
 #include "platform/scroll/Scrollbar.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/TemporaryChange.h"
 
 namespace blink {
 
 namespace {
 
+WebInputEventResult mergeEventResult(WebInputEventResult responseA, WebInputEventResult responseB)

[Rick Byers, 2015/11/23 21:59:55]

I _think_ we should never be "upgrading" a script-handled to a default-handled
state, or calling this with two "default handled" states.  So rather than
"merge" this is really just returning the input, or possibly changing
NotHandled->ScriptHandled.  Maybe the "merge" name is fine but should probably
RELEASE_ASSERT that we're not doing an invalid transition.

[dtapuska, 2015/11/24 15:23:02]

Look at the handleGestureTap case. It generates a mousedown which could be
HandledScript and a mouseup which could be HandledDefaultHandler (I don't know
if there is a default handler for mouseup specifically). But logically the code
could return it.

And that would have to merge (HandleScript, HandleDefaultHandler) to provide
something that is more definitive; like HandleDefaultHandler.

+{
+    return static_cast<WebInputEventResult>(max(static_cast<int>(responseA), static_cast<int>(responseB)));
+}
+
+WebInputEventResult boolToEventResult(bool value)

[Rick Byers, 2015/11/23 21:59:55]

Seems like any time you'd need this might be a potential bug confusing handled
vs. default handled, right?  Maybe better to inline (and leave TODOs for
possible outstanding issues)?

[dtapuska, 2015/11/24 15:23:02]

I didn't want to propagate the WebInputEventResult everywhere it was logical to
return a boolean. For example did I update the drop target? Yes or no. But I can
certainly replace inline; but there may not be TODOs to actually do.

+{
+    return value ? WebInputEventResult::HandledDefaultHandler : WebInputEventResult::NotHandled;
+}
+
+WebInputEventResult eventToEventResult(PassRefPtrWillBeRawPtr<Event> event, bool res)
+{
+    if (event->defaultPrevented())
+        return WebInputEventResult::HandledScript;
+    if (event->defaultHandled())
+        return WebInputEventResult::HandledDefaultHandler;
+
+    // TODO(dtapuska): There are cases in the code where dispatchEvent
+    // returns false (indicated handled) but event is not marked
+    // as default handled or default prevented. crbug.com/560355
+    if (!res)
+        return WebInputEventResult::HandledDefaultHandler;

[Rick Byers, 2015/11/23 21:59:55]

I think technically any handlers that run within the context of dispatchEvent
are not, by definition, "default handlers" (they can be triggered by synthetic
JS).  Although IIRC there are one or two well known exceptions for legacy compat
(click events on checkboxes or something).

[dtapuska, 2015/11/24 15:23:02]

I was more or less trying to capture "did the script call preventDefault?" And
everything else was the default handler. But we can discuss this when you got a
minute.

+    return WebInputEventResult::NotHandled;
+}
+
 bool isNodeInDocument(Node* n)
 {
     return n && n->inDocument();
 }
 
 const AtomicString& touchEventNameForTouchPointState(PlatformTouchPoint::State state)
 {
     switch (state) {
     case PlatformTouchPoint::TouchReleased:
         return EventTypeNames::touchend;
@@ skipping 277 matching lines @@
 
 void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)
 {
     if (nodeToBeRemoved.containsIncludingShadowDOM(m_clickNode.get())) {
         // We don't dispatch click events if the mousedown node is removed
         // before a mouseup event. It is compatible with IE and Firefox.
         m_clickNode = nullptr;
     }
 }
 
-bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
+WebInputEventResult EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");
 
     // Reset drag state.
     dragState().m_dragSrc = nullptr;
 
     cancelFakeMouseMoveEvent();
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     if (FrameView* frameView = m_frame->view()) {
         if (frameView->isPointInScrollbarCorner(event.event().position()))
-            return false;
+            return WebInputEventResult::NotHandled;
     }
 
     bool singleClick = event.event().clickCount() <= 1;
 
     m_mouseDownMayStartDrag = singleClick;
 
     selectionController().handleMousePressEvent(event);
 
     m_mouseDown = event.event();
 
     if (m_frame->document()->isSVGDocument() && m_frame->document()->accessSVGExtensions().zoomAndPanEnabled()) {
         if (event.event().shiftKey() && singleClick) {
             m_svgPan = true;
             m_frame->document()->accessSVGExtensions().startPan(m_frame->view()->rootFrameToContents(event.event().position()));
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
         }
     }
 
     // We don't do this at the start of mouse down handling,
     // because we don't want to do it until we know we didn't hit a widget.
     if (singleClick)
         focusDocumentView();
 
     Node* innerNode = event.innerNode();
 
     m_mousePressNode = innerNode;
     m_dragStartPos = event.event().position();
 
     bool swallowEvent = false;
     m_mousePressed = true;
 
     if (event.event().clickCount() == 2)
         swallowEvent = selectionController().handleMousePressEventDoubleClick(event);
     else if (event.event().clickCount() >= 3)
         swallowEvent = selectionController().handleMousePressEventTripleClick(event);
     else
         swallowEvent = selectionController().handleMousePressEventSingleClick(event);
 
     m_mouseDownMayStartAutoscroll = selectionController().mouseDownMayStartSelect()
         || (m_mousePressNode && m_mousePressNode->layoutBox() && m_mousePressNode->layoutBox()->canBeProgramaticallyScrolled());
 
-    return swallowEvent;
+    return boolToEventResult(swallowEvent);
 }
 
-bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)
+WebInputEventResult EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseDraggedEvent");
 
     // While resetting m_mousePressed here may seem out of place, it turns out
     // to be needed to handle some bugs^Wfeatures in Blink mouse event handling:
     // 1. Certain elements, such as <embed>, capture mouse events. They do not
     //    bubble back up. One way for a <embed> to start capturing mouse events
     //    is on a mouse press. The problem is the <embed> node only starts
     //    capturing mouse events *after* m_mousePressed for the containing frame
     //    has already been set to true. As a result, the frame's EventHandler
     //    never sees the mouse release event, which is supposed to reset
     //    m_mousePressed... so m_mousePressed ends up remaining true until the
     //    event handler finally gets another mouse released event. Oops.
     // 2. Dragging doesn't start until after a mouse press event, but a drag
     //    that ends as a result of a mouse release does not send a mouse release
     //    event. As a result, m_mousePressed also ends up remaining true until
     //    the next mouse release event seen by the EventHandler.
     if (event.event().button() != LeftButton)
         m_mousePressed = false;
 
     if (!m_mousePressed)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     if (handleDrag(event, DragInitiator::Mouse))
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
 
     Node* targetNode = event.innerNode();
     if (!targetNode)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     LayoutObject* layoutObject = targetNode->layoutObject();
     if (!layoutObject) {
         Node* parent = ComposedTreeTraversal::parent(*targetNode);
         if (!parent)
-            return false;
+            return WebInputEventResult::NotHandled;
 
         layoutObject = parent->layoutObject();
         if (!layoutObject || !layoutObject->isListBox())
-            return false;
+            return WebInputEventResult::NotHandled;
     }
 
     m_mouseDownMayStartDrag = false;
 
     if (m_mouseDownMayStartAutoscroll && !panScrollInProgress()) {
         if (AutoscrollController* controller = autoscrollController()) {
             controller->startAutoscrollForSelection(layoutObject);
             m_mouseDownMayStartAutoscroll = false;
         }
     }
 
     selectionController().handleMouseDraggedEvent(event, m_mouseDownPos, m_dragStartPos, m_mousePressNode.get(), m_lastKnownMousePosition);
-    return true;
+    return WebInputEventResult::HandledDefaultHandler;
 }
 
 void EventHandler::updateSelectionForMouseDrag()
 {
     selectionController().updateSelectionForMouseDrag(m_mousePressNode.get(), m_dragStartPos, m_lastKnownMousePosition);
 }
 
-bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
+WebInputEventResult EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
 {
     AutoscrollController* controller = autoscrollController();
     if (controller && controller->autoscrollInProgress())
         stopAutoscroll();
 
     // Used to prevent mouseMoveEvent from initiating a drag before
     // the mouse is pressed again.
     m_mousePressed = false;
     m_capturesDragging = false;
     m_mouseDownMayStartDrag = false;
     m_mouseDownMayStartAutoscroll = false;
 
-    return selectionController().handleMouseReleaseEvent(event, m_dragStartPos);
+    return boolToEventResult(selectionController().handleMouseReleaseEvent(event, m_dragStartPos));
 }
 
 #if OS(WIN)
 
 void EventHandler::startPanScrolling(LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
         return;
     AutoscrollController* controller = autoscrollController();
     if (!controller)
@@ skipping 396 matching lines @@
 }
 
 static LayoutPoint contentPointFromRootFrame(LocalFrame* frame, const IntPoint& pointInRootFrame)
 {
     FrameView* view = frame->view();
     // FIXME: Is it really OK to use the wrong coordinates here when view is 0?
     // Historically the code would just crash; this is clearly no worse than that.
     return view ? view->rootFrameToContents(pointInRootFrame) : pointInRootFrame;
 }
 
-bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
+WebInputEventResult EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
     m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken = gestureIndicator.currentToken();
 
     cancelFakeMouseMoveEvent();
     if (m_eventHandlerWillResetCapturingMouseEventsNode)
         m_capturingMouseEventsNode = nullptr;
     m_mousePressed = true;
     m_capturesDragging = true;
     setLastKnownMousePosition(mouseEvent);
     m_mouseDownTimestamp = mouseEvent.timestamp();
     m_mouseDownMayStartDrag = false;
     selectionController().setMouseDownMayStartSelect(false);
     m_mouseDownMayStartAutoscroll = false;
     if (FrameView* view = m_frame->view()) {
         m_mouseDownPos = view->rootFrameToContents(mouseEvent.position());
     } else {
         invalidateClick();
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 
     HitTestRequest request(HitTestRequest::Active);
     // Save the document point we generate in case the window coordinate is invalidated by what happens
     // when we dispatch the event.
     LayoutPoint documentPoint = contentPointFromRootFrame(m_frame, mouseEvent.position());
     MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
 
     if (!mev.innerNode()) {
         invalidateClick();
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 
     m_mousePressNode = mev.innerNode();
 
     RefPtrWillBeRawPtr<LocalFrame> subframe = subframeForHitTestResult(mev);
     if (subframe && passMousePressEventToSubframe(mev, subframe.get())) {
         // Start capturing future events for this frame.  We only do this if we didn't clear
         // the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
         m_capturesDragging = subframe->eventHandler().capturesDragging();
         if (m_mousePressed && m_capturesDragging) {
             m_capturingMouseEventsNode = mev.innerNode();
             m_eventHandlerWillResetCapturingMouseEventsNode = true;
         }
         invalidateClick();
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;

[Rick Byers, 2015/11/23 21:59:55]

this could be either I think.  Ultimately we probably need to propagate this
from passMousePressEventToSubframe, right?

[dtapuska, 2015/11/24 22:09:38]

Done.

     }
 
 #if OS(WIN)
     // We store whether pan scrolling is in progress before calling stopAutoscroll()
     // because it will set m_autoscrollType to NoAutoscroll on return.
     bool isPanScrollInProgress = panScrollInProgress();
     stopAutoscroll();
     if (isPanScrollInProgress) {
         // We invalidate the click when exiting pan scrolling so that we don't inadvertently navigate
         // away from the current page (e.g. the click was on a hyperlink). See <rdar://problem/6095023>.
         invalidateClick();
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 #endif
 
     m_clickCount = mouseEvent.clickCount();
     m_clickNode = mev.innerNode()->isTextNode() ?  ComposedTreeTraversal::parent(*mev.innerNode()) : mev.innerNode();
 
     if (FrameView* view = m_frame->view()) {
         PaintLayer* layer = mev.innerNode()->layoutObject() ? mev.innerNode()->layoutObject()->enclosingLayer() : nullptr;
         IntPoint p = view->rootFrameToContents(mouseEvent.position());
         if (layer && layer->scrollableArea() && layer->scrollableArea()->isPointInResizeControl(p, ResizerForPointer)) {
             m_resizeScrollableArea = layer->scrollableArea();
             m_resizeScrollableArea->setInResizeMode(true);
             m_offsetFromResizeCorner = LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));
             invalidateClick();
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
         }
     }
 
     m_frame->selection().setCaretBlinkingSuspended(true);
 
-    bool swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mouseEvent);
+    WebInputEventResult swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mouseEvent);

[Rick Byers, 2015/11/23 21:59:55]

nit: rename to 'eventResult'

[dtapuska, 2015/11/24 22:09:37]

Done.

 
     // m_selectionInitiationState is initialized after dispatching mousedown
     // event in order not to keep the selection by DOM APIs Because we can't
     // give the user the chance to handle the selection by user action like
     // dragging if we keep the selection in case of mousedown. FireFox also has
     // the same behavior and it's more compatible with other browsers.
     selectionController().initializeSelectionState();
     HitTestResult hitTestResult = hitTestResultInFrame(m_frame, documentPoint, HitTestRequest::ReadOnly);
     InputDeviceCapabilities* sourceCapabilities = mouseEvent.syntheticEventType() == PlatformMouseEvent::FromTouch ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities() :
         InputDeviceCapabilities::doesntFireTouchEventsSourceCapabilities();
-    swallowEvent = swallowEvent || handleMouseFocus(MouseEventWithHitTestResults(mouseEvent, hitTestResult), sourceCapabilities);
-    m_capturesDragging = !swallowEvent || mev.scrollbar();
+    if (swallowEvent == WebInputEventResult::NotHandled)
+        swallowEvent = handleMouseFocus(MouseEventWithHitTestResults(mouseEvent, hitTestResult), sourceCapabilities);
+    m_capturesDragging = swallowEvent == WebInputEventResult::NotHandled || mev.scrollbar();
 
     // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
     // in case the scrollbar widget was destroyed when the mouse event was handled.
     if (mev.scrollbar()) {
         const bool wasLastScrollBar = mev.scrollbar() == m_lastScrollbarUnderMouse.get();
         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
         mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
         if (wasLastScrollBar && mev.scrollbar() != m_lastScrollbarUnderMouse.get())
             m_lastScrollbarUnderMouse = nullptr;
     }
 
-    if (swallowEvent) {
+    if (swallowEvent != WebInputEventResult::NotHandled) {
         // scrollbars should get events anyway, even disabled controls might be scrollable
         passMousePressEventToScrollbar(mev);
     } else {
         if (shouldRefetchEventTarget(mev)) {
             HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
             mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
         }
 
         if (passMousePressEventToScrollbar(mev))
-            swallowEvent = true;
+            swallowEvent = WebInputEventResult::HandledDefaultHandler;
         else
             swallowEvent = handleMousePressEvent(mev);
     }
 
     if (mev.hitTestResult().innerNode() && mouseEvent.button() == LeftButton) {
         ASSERT(mouseEvent.type() == PlatformEvent::MousePressed);
         HitTestResult result = mev.hitTestResult();
         result.setToShadowHostIfInUserAgentShadowRoot();
         m_frame->chromeClient().onMouseDown(result.innerNode());
     }
@@ skipping 20 matching lines @@
 ScrollableArea* EventHandler::associatedScrollableArea(const PaintLayer* layer) const
 {
     if (PaintLayerScrollableArea* scrollableArea = layer->scrollableArea()) {
         if (scrollableArea->scrollsOverflow())
             return scrollableArea;
     }
 
     return nullptr;
 }
 
-bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)
+WebInputEventResult EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
     conditionallyEnableMouseEventForPointerTypeMouse(event);
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
     HitTestResult hoveredNode = HitTestResult();
-    bool result = handleMouseMoveOrLeaveEvent(event, &hoveredNode);
+    WebInputEventResult result = handleMouseMoveOrLeaveEvent(event, &hoveredNode);
 
     Page* page = m_frame->page();
     if (!page)
         return result;
 
     if (PaintLayer* layer = layerForNode(hoveredNode.innerNode())) {
         if (ScrollableArea* layerScrollableArea = associatedScrollableArea(layer))
             layerScrollableArea->mouseMovedInContentArea();
     }
 
     if (FrameView* frameView = m_frame->view())
         frameView->mouseMovedInContentArea();
 
     hoveredNode.setToShadowHostIfInUserAgentShadowRoot();
     page->chromeClient().mouseDidMoveOverElement(hoveredNode);
 
     return result;
 }
 
 void EventHandler::handleMouseLeaveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseLeaveEvent");
 
     conditionallyEnableMouseEventForPointerTypeMouse(event);
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     handleMouseMoveOrLeaveEvent(event, 0, false, true);
 }
 
-bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode, bool onlyUpdateScrollbars, bool forceLeave)
+WebInputEventResult EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode, bool onlyUpdateScrollbars, bool forceLeave)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->view());
 
     setLastKnownMousePosition(mouseEvent);
 
     if (m_hoverTimer.isActive())
         m_hoverTimer.stop();
 
     m_cursorUpdateTimer.stop();
 
     cancelFakeMouseMoveEvent();
 
     if (m_svgPan) {
         m_frame->document()->accessSVGExtensions().updatePan(m_frame->view()->rootFrameToContents(m_lastKnownMousePosition));
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 
     if (m_frameSetBeingResized)
         return updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove, m_frameSetBeingResized.get(), 0, mouseEvent);
 
     // Send events right to a scrollbar if the mouse is pressed.
     if (m_lastScrollbarUnderMouse && m_mousePressed) {
         m_lastScrollbarUnderMouse->mouseMoved(mouseEvent);
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 
     // Mouse events simulated from touch should not hit-test again.
     ASSERT(!mouseEvent.fromTouch());
 
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move;
     if (m_mousePressed) {
         hitType |= HitTestRequest::Active;
     } else if (onlyUpdateScrollbars) {
         // Mouse events should be treated as "read-only" if we're updating only scrollbars. This
@@ skipping 22 matching lines @@
     Scrollbar* scrollbar = nullptr;
 
     if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
         m_resizeScrollableArea->resize(mouseEvent, m_offsetFromResizeCorner);
     } else {
         if (!scrollbar)
             scrollbar = mev.scrollbar();
 
         updateLastScrollbarUnderMouse(scrollbar, !m_mousePressed);
         if (onlyUpdateScrollbars)
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
     }
 
     bool swallowEvent = false;
     RefPtrWillBeRawPtr<LocalFrame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
 
     // We want mouseouts to happen first, from the inside out.  First send a move event to the last subframe so that it will fire mouseouts.
     if (m_lastMouseMoveEventSubframe && m_lastMouseMoveEventSubframe->tree().isDescendantOf(m_frame) && m_lastMouseMoveEventSubframe != newSubframe)
         m_lastMouseMoveEventSubframe->eventHandler().handleMouseLeaveEvent(mouseEvent);
 
     if (newSubframe) {
@@ skipping 11 matching lines @@
             OptionalCursor optionalCursor = selectCursor(mev.hitTestResult());
             if (optionalCursor.isCursorChange()) {
                 view->setCursor(optionalCursor.cursor());
             }
         }
     }
 
     m_lastMouseMoveEventSubframe = newSubframe;
 
     if (swallowEvent)
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
 
-    swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove, mev.innerNode(), 0, mouseEvent);
+    WebInputEventResult result = updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove, mev.innerNode(), 0, mouseEvent);
+    if (result != WebInputEventResult::NotHandled)
+        return result;
 
-    if (!swallowEvent)
-        swallowEvent = handleMouseDraggedEvent(mev);
-
-    return swallowEvent;
+    return handleMouseDraggedEvent(mev);
 }
 
 void EventHandler::invalidateClick()
 {
     m_clickCount = 0;
     m_clickNode = nullptr;
 }
 
 static ContainerNode* parentForClickEvent(const Node& node)
 {
     // IE doesn't dispatch click events for mousedown/mouseup events across form
     // controls.
     if (node.isHTMLElement() && toHTMLElement(node).isInteractiveContent())
         return nullptr;
 
     return ComposedTreeTraversal::parent(node);
 }
 
-bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
+WebInputEventResult EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
     m_frame->selection().setCaretBlinkingSuspended(false);
 
     OwnPtr<UserGestureIndicator> gestureIndicator;
 
     if (m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken)
         gestureIndicator = adoptPtr(new UserGestureIndicator(m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken.release()));
     else
         gestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingUserGesture));
 
 #if OS(WIN)
     if (Page* page = m_frame->page())
         page->autoscrollController().handleMouseReleaseForPanScrolling(m_frame, mouseEvent);
 #endif
 
     m_mousePressed = false;
     setLastKnownMousePosition(mouseEvent);
 
     if (m_svgPan) {
         m_svgPan = false;
         m_frame->document()->accessSVGExtensions().updatePan(m_frame->view()->rootFrameToContents(m_lastKnownMousePosition));
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 
     if (m_frameSetBeingResized)
         return dispatchMouseEvent(EventTypeNames::mouseup, m_frameSetBeingResized.get(), m_clickCount, mouseEvent);
 
     if (m_lastScrollbarUnderMouse) {
         invalidateClick();
         m_lastScrollbarUnderMouse->mouseUp(mouseEvent);
         return dispatchMouseEvent(EventTypeNames::mouseup, m_nodeUnderMouse.get(), m_clickCount, mouseEvent);
     }
 
     // Mouse events simulated from touch should not hit-test again.
     ASSERT(!mouseEvent.fromTouch());
 
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::Release;
     HitTestRequest request(hitType);
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
     LocalFrame* subframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
     if (m_eventHandlerWillResetCapturingMouseEventsNode)
         m_capturingMouseEventsNode = nullptr;
     if (subframe && passMouseReleaseEventToSubframe(mev, subframe))
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;

[Rick Byers, 2015/11/23 21:59:55]

ditto

[dtapuska, 2015/11/24 22:09:37]

Done.

 
-    bool swallowUpEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mouseup, mev.innerNode(), m_clickCount, mouseEvent);
+    WebInputEventResult swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mouseup, mev.innerNode(), m_clickCount, mouseEvent);
 
     // TODO(crbug/545647): This state should reset with pointercancel too.
     m_preventMouseEventForPointerTypeMouse = false;
 
     bool contextMenuEvent = mouseEvent.button() == RightButton;
 #if OS(MACOSX)
     // FIXME: The Mac port achieves the same behavior by checking whether the context menu is currently open in WebPage::mouseEvent(). Consider merging the implementations.
     if (mouseEvent.button() == LeftButton && mouseEvent.modifiers() & PlatformEvent::CtrlKey)
         contextMenuEvent = true;
 #endif
 
-    bool swallowClickEvent = false;
     if (m_clickCount > 0 && !contextMenuEvent && mev.innerNode() && m_clickNode && mev.innerNode()->canParticipateInComposedTree() && m_clickNode->canParticipateInComposedTree()) {
         // Updates distribution because a 'mouseup' event listener can make the
         // tree dirty at dispatchMouseEvent() invocation above.
         // Unless distribution is updated, commonAncestor would hit ASSERT.
         // Both m_clickNode and mev.innerNode() don't need to be updated
         // because commonAncestor() will exit early if their documents are different.
         m_clickNode->updateDistribution();
         if (Node* clickTargetNode = mev.innerNode()->commonAncestor(
             *m_clickNode, parentForClickEvent)) {
 
             // Dispatch mouseup directly w/o calling updateMouseEventTargetNode
             // because the mouseup dispatch above has already updated it
             // correctly. Moreover, clickTargetNode is different from
             // mev.innerNode at drag-release.
             clickTargetNode->dispatchMouseEvent(mouseEvent,
                 EventTypeNames::click, m_clickCount);
         }
     }
 
     if (m_resizeScrollableArea) {
         m_resizeScrollableArea->setInResizeMode(false);
         m_resizeScrollableArea = nullptr;
     }
 
-    bool swallowMouseReleaseEvent = false;
-    if (!swallowUpEvent)
-        swallowMouseReleaseEvent = handleMouseReleaseEvent(mev);
+    if (swallowEvent == WebInputEventResult::NotHandled)
+        swallowEvent = handleMouseReleaseEvent(mev);
 
     invalidateClick();
 
-    return swallowUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
+    return swallowEvent;
 }
 
-bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
+WebInputEventResult EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     FrameView* view = m_frame->view();
 
     // FIXME: We might want to dispatch a dragleave even if the view is gone.
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     RefPtrWillBeRawPtr<DragEvent> me = DragEvent::create(eventType,
         true, true, m_frame->document()->domWindow(),
         0, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
         event.movementDelta().x(), event.movementDelta().y(),
         event.modifiers(),
         0, MouseEvent::platformModifiersToButtons(event.modifiers()), nullptr, dataTransfer, event.syntheticEventType(), event.timestamp());
 
-    dragTarget->dispatchEvent(me.get());
-    return me->defaultPrevented();
+    bool dispatchResult = dragTarget->dispatchEvent(me.get());
+    return eventToEventResult(me, dispatchResult);
 }
 
 static bool targetIsFrame(Node* target, LocalFrame*& frame)
 {
     if (!isHTMLFrameElementBase(target))
         return false;
 
     // Cross-process drag and drop is not yet supported.
     if (toHTMLFrameElementBase(target)->contentFrame() && !toHTMLFrameElementBase(target)->contentFrame()->isLocalFrame())
         return false;
@@ skipping 34 matching lines @@
                 break;
         }
         if (matched) {
             dataTransfer->setDropEffect(convertDragOperationToDropZoneOperation(dragOperation));
             return true;
         }
     }
     return false;
 }
 
-bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
+WebInputEventResult EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
-    bool accept = false;
+    WebInputEventResult result = WebInputEventResult::NotHandled;
 
     if (!m_frame->view())
-        return false;
+        return result;
 
     HitTestRequest request(HitTestRequest::ReadOnly);
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
 
     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
     RefPtrWillBeRawPtr<Node> newTarget = mev.innerNode();
     if (newTarget && newTarget->isTextNode())
         newTarget = ComposedTreeTraversal::parent(*newTarget);
 
     if (AutoscrollController* controller = autoscrollController())
         controller->updateDragAndDrop(newTarget.get(), event.position(), event.timestamp());
 
     if (m_dragTarget != newTarget) {
         // FIXME: this ordering was explicitly chosen to match WinIE. However,
         // it is sometimes incorrect when dragging within subframes, as seen with
         // LayoutTests/fast/events/drag-in-frames.html.
         //
         // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
         LocalFrame* targetFrame;
         if (targetIsFrame(newTarget.get(), targetFrame)) {
             if (targetFrame)
-                accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
+                result = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
         } else if (newTarget) {
             // As per section 7.9.4 of the HTML 5 spec., we must always fire a drag event before firing a dragenter, dragleave, or dragover event.
             if (dragState().m_dragSrc) {
                 // for now we don't care if event handler cancels default behavior, since there is none
                 dispatchDragSrcEvent(EventTypeNames::drag, event);
             }
-            accept = dispatchDragEvent(EventTypeNames::dragenter, newTarget.get(), event, dataTransfer);
-            if (!accept)
-                accept = findDropZone(newTarget.get(), dataTransfer);
+            result = dispatchDragEvent(EventTypeNames::dragenter, newTarget.get(), event, dataTransfer);
+            if (result == WebInputEventResult::NotHandled)
+                result = boolToEventResult(findDropZone(newTarget.get(), dataTransfer));
         }
 
         if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
             if (targetFrame)
-                accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
+                result = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
         } else if (m_dragTarget) {
             dispatchDragEvent(EventTypeNames::dragleave, m_dragTarget.get(), event, dataTransfer);
         }
 
         if (newTarget) {
             // We do not explicitly call dispatchDragEvent here because it could ultimately result in the appearance that
             // two dragover events fired. So, we mark that we should only fire a dragover event on the next call to this function.
             m_shouldOnlyFireDragOverEvent = true;
         }
     } else {
         LocalFrame* targetFrame;
         if (targetIsFrame(newTarget.get(), targetFrame)) {
             if (targetFrame)
-                accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
+                result = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);
         } else if (newTarget) {
             // Note, when dealing with sub-frames, we may need to fire only a dragover event as a drag event may have been fired earlier.
             if (!m_shouldOnlyFireDragOverEvent && dragState().m_dragSrc) {
                 // for now we don't care if event handler cancels default behavior, since there is none
                 dispatchDragSrcEvent(EventTypeNames::drag, event);
             }
-            accept = dispatchDragEvent(EventTypeNames::dragover, newTarget.get(), event, dataTransfer);
-            if (!accept)
-                accept = findDropZone(newTarget.get(), dataTransfer);
+            result = dispatchDragEvent(EventTypeNames::dragover, newTarget.get(), event, dataTransfer);
+            if (result == WebInputEventResult::NotHandled)
+                result = boolToEventResult(findDropZone(newTarget.get(), dataTransfer));
             m_shouldOnlyFireDragOverEvent = false;
         }
     }
     m_dragTarget = newTarget;
 
-    return accept;
+    return result;
 }
 
 void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     LocalFrame* targetFrame;
     if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
         if (targetFrame)
             targetFrame->eventHandler().cancelDragAndDrop(event, dataTransfer);
     } else if (m_dragTarget.get()) {
         if (dragState().m_dragSrc)
             dispatchDragSrcEvent(EventTypeNames::drag, event);
         dispatchDragEvent(EventTypeNames::dragleave, m_dragTarget.get(), event, dataTransfer);
     }
     clearDragState();
 }
 
-bool EventHandler::performDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
+WebInputEventResult EventHandler::performDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     LocalFrame* targetFrame;
-    bool preventedDefault = false;
+    WebInputEventResult result = WebInputEventResult::NotHandled;
     if (targetIsFrame(m_dragTarget.get(), targetFrame)) {
         if (targetFrame)
-            preventedDefault = targetFrame->eventHandler().performDragAndDrop(event, dataTransfer);
+            result = targetFrame->eventHandler().performDragAndDrop(event, dataTransfer);
     } else if (m_dragTarget.get()) {
-        preventedDefault = dispatchDragEvent(EventTypeNames::drop, m_dragTarget.get(), event, dataTransfer);
+        result = dispatchDragEvent(EventTypeNames::drop, m_dragTarget.get(), event, dataTransfer);
     }
     clearDragState();
-    return preventedDefault;
+    return result;
 }
 
 void EventHandler::clearDragState()
 {
     stopAutoscroll();
     m_dragTarget = nullptr;
     m_capturingMouseEventsNode = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
 }
 
@@ skipping 56 matching lines @@
 
     if (lastNodeUnderMouse && lastNodeUnderMouse->document() != m_frame->document()) {
         lastNodeUnderMouse = nullptr;
         m_lastScrollbarUnderMouse = nullptr;
     }
 
     if (lastNodeUnderMouse != m_nodeUnderMouse)
         sendMouseEventsForNodeTransition(lastNodeUnderMouse.get(), m_nodeUnderMouse.get(), mouseEvent);
 }
 
-bool EventHandler::dispatchPointerEvent(Node* target, const AtomicString& eventType,
+WebInputEventResult EventHandler::dispatchPointerEvent(Node* target, const AtomicString& eventType,
     const PlatformMouseEvent& mouseEvent, Node* relatedTarget)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(eventType, true,
         mouseEvent, relatedTarget, m_frame->document()->domWindow());
-    target->dispatchEvent(pointerEvent.get());
-    return pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
+
+    bool dispatchResult = target->dispatchEvent(pointerEvent.get());
+    return eventToEventResult(pointerEvent, dispatchResult);
 }
 
 void EventHandler::sendMouseEventsForNodeTransition(Node* exitedNode, Node* enteredNode,
     const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(exitedNode != enteredNode);
 
     // Dispatch pointerout/mouseout events
     if (isNodeInDocument(exitedNode)) {
         dispatchPointerEvent(exitedNode, EventTypeNames::pointerout, mouseEvent, enteredNode);
@@ skipping 85 matching lines @@
     for (size_t i = enteredAncestorIndex; i > 0; i--) {
         if (enteredNodeHasCapturingAncestor || enteredAncestors[i-1]->hasEventListeners(EventTypeNames::pointerenter)) {
             dispatchPointerEvent(enteredAncestors[i-1].get(), EventTypeNames::pointerenter, mouseEvent,
                 exitedNode);
         }
         if (enteredNodeHasCapturingAncestor || enteredAncestors[i-1]->hasEventListeners(EventTypeNames::mouseenter))
             enteredAncestors[i-1]->dispatchMouseEvent(mouseEvent, EventTypeNames::mouseenter, 0, exitedNode);
     }
 }
 
-bool EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
+WebInputEventResult EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     updateMouseEventTargetNode(targetNode, mouseEvent);
-    return m_nodeUnderMouse && !m_nodeUnderMouse->dispatchMouseEvent(mouseEvent, eventType, clickCount);
+    if (!m_nodeUnderMouse)
+        return WebInputEventResult::NotHandled;
+
+    RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(eventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
+    bool dispatchResult = m_nodeUnderMouse->dispatchEvent(event);
+    return eventToEventResult(event, dispatchResult);
 }
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
-bool EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
+WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(mouseEventType == EventTypeNames::mousedown
         || mouseEventType == EventTypeNames::mousemove
         || mouseEventType == EventTypeNames::mouseup);
 
     updateMouseEventTargetNode(targetNode, mouseEvent);
     if (!m_nodeUnderMouse)
-        return false;
+        return WebInputEventResult::NotHandled;
 
-    bool swallowEvent = dispatchPointerEvent(m_nodeUnderMouse.get(),
+    WebInputEventResult result = dispatchPointerEvent(m_nodeUnderMouse.get(),
         pointerEventNameForMouseEventName(mouseEventType),
         mouseEvent);
 
-    if (swallowEvent && mouseEventType == EventTypeNames::mousedown) {
+    if (result != WebInputEventResult::NotHandled && mouseEventType == EventTypeNames::mousedown) {
         m_preventMouseEventForPointerTypeMouse = true;
     }
 
     if (!m_preventMouseEventForPointerTypeMouse) {
-        swallowEvent |= !m_nodeUnderMouse->dispatchMouseEvent(mouseEvent, mouseEventType, clickCount);
+        RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
+        bool dispatchResult = m_nodeUnderMouse->dispatchEvent(event);
+        result = mergeEventResult(result, eventToEventResult(event, dispatchResult));
     }
 
-    return swallowEvent;
+    return result;
 }
 
-bool EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
+WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
     if (targetedEvent.hitTestResult().scrollbar() && m_frame->contentLayoutObject()) {
         if (targetedEvent.hitTestResult().scrollbar()->scrollableArea() == m_frame->contentLayoutObject()->scrollableArea())
-            return false;
+            return WebInputEventResult::NotHandled;
     }
 
     // The layout needs to be up to date to determine if an element is focusable.
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     Element* element = nullptr;
     if (m_nodeUnderMouse)
         element = m_nodeUnderMouse->isElementNode() ? toElement(m_nodeUnderMouse) : m_nodeUnderMouse->parentOrShadowHostElement();
     for (; element; element = element->parentOrShadowHostElement()) {
         if (element->isFocusable() && element->isFocusedElementInDocument())
-            return false;
+            return WebInputEventResult::NotHandled;
         if (element->isMouseFocusable())
             break;
     }
     ASSERT(!element || element->isMouseFocusable());
 
     // To fix <rdar://problem/4895428> Can't drag selected ToDo, we don't focus
     // a node on mouse down if it's selected and inside a focused node. It will
     // be focused if the user does a mouseup over it, however, because the
     // mouseup will set a selection inside it, which will call
     // FrameSelection::setFocusedNodeIfNeeded.
     if (element && m_frame->selection().isRange()) {
         // TODO(yosin) We should not create |Range| object for calling
         // |isNodeFullyContained()|.
         if (createRange(m_frame->selection().selection().toNormalizedEphemeralRange())->isNodeFullyContained(*element)
             && element->isDescendantOf(m_frame->document()->focusedElement()))
-            return false;
+            return WebInputEventResult::NotHandled;
     }
 
 
     // Only change the focus when clicking scrollbars if it can transfered to a
     // mouse focusable node.
     if (!element && targetedEvent.hitTestResult().scrollbar())
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
 
     if (Page* page = m_frame->page()) {
         // If focus shift is blocked, we eat the event. Note we should never
         // clear swallowEvent if the page already set it (e.g., by canceling
         // default behavior).
         if (element) {
             if (slideFocusOnShadowHostIfNecessary(*element))
-                return true;
+                return WebInputEventResult::HandledDefaultHandler;
             if (!page->focusController().setFocusedElement(element, m_frame, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeMouse, sourceCapabilities)))
-                return true;
+                return WebInputEventResult::HandledDefaultHandler;
         } else {
             // We call setFocusedElement even with !element in order to blur
             // current focus element when a link is clicked; this is expected by
             // some sites that rely on onChange handlers running from form
             // fields before the button click is processed.
             if (!page->focusController().setFocusedElement(nullptr, m_frame, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, sourceCapabilities)))
-                return true;
+                return WebInputEventResult::HandledDefaultHandler;
         }
     }
 
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
 bool EventHandler::slideFocusOnShadowHostIfNecessary(const Element& element)
 {
     if (element.authorShadowRoot() && element.authorShadowRoot()->delegatesFocus()) {
         Document* doc = m_frame->document();
         if (element.containsIncludingShadowDOM(doc->focusedElement())) {
             // If the inner element is already focused, do nothing.
             return true;
         }
@@ skipping 40 matching lines @@
     ScrollResult result;
     result.didScrollY = resultY.didScroll;
     result.didScrollX = resultX.didScroll;
     result.unusedScrollDeltaY = resultY.unusedScrollDelta;
     result.unusedScrollDeltaX = resultX.unusedScrollDelta;
     return result;
 }
 
 } // namespace
 
-bool EventHandler::handleWheelEvent(const PlatformWheelEvent& event)
+WebInputEventResult EventHandler::handleWheelEvent(const PlatformWheelEvent& event)
 {
-#define RETURN_WHEEL_EVENT_HANDLED() \
-    { \
-        setFrameWasScrolledByUser(); \
-        return true; \
-    }
-
     Document* doc = m_frame->document();
 
     if (!doc->layoutView())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
     FrameView* view = m_frame->view();
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     LayoutPoint vPoint = view->rootFrameToContents(event.position());
 
     HitTestRequest request(HitTestRequest::ReadOnly);
     HitTestResult result(request, vPoint);
     doc->layoutView()->hitTest(result);
 
     Node* node = result.innerNode();
     // Wheel events should not dispatch to text nodes.
     if (node && node->isTextNode())
         node = ComposedTreeTraversal::parent(*node);
 
     if (m_previousWheelScrolledNode)
         m_previousWheelScrolledNode = nullptr;
 
     bool isOverWidget = result.isOverWidget();
 
     if (node) {
         // Figure out which view to send the event to.
         LayoutObject* target = node->layoutObject();
 
         if (isOverWidget && target && target->isLayoutPart()) {
-            Widget* widget = toLayoutPart(target)->widget();
-            if (widget && passWheelEventToWidget(event, *widget))
-                RETURN_WHEEL_EVENT_HANDLED();
+            if (Widget* widget = toLayoutPart(target)->widget()) {
+                WebInputEventResult result = passWheelEventToWidget(event, *widget);
+                if (result != WebInputEventResult::NotHandled) {
+                    setFrameWasScrolledByUser();
+                    return result;
+                }
+            }
         }
 
-        if (node && !node->dispatchWheelEvent(event))
-            RETURN_WHEEL_EVENT_HANDLED();
+        RefPtrWillBeRawPtr<Event> domEvent = WheelEvent::create(event, node->document().domWindow());
+        if (!node->dispatchEvent(domEvent)) {
+            setFrameWasScrolledByUser();
+            return eventToEventResult(domEvent, false);
+        }
     }
 
     // We do another check on the frame view because the event handler can run
     // JS which results in the frame getting destroyed.
     view = m_frame->view();
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // Wheel events which do not scroll are used to trigger zooming.
     if (!event.canScroll())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     ScrollResult scrollResult = scrollAreaWithWheelEvent(event, *view->scrollableArea());
     if (m_frame->settings() && m_frame->settings()->reportWheelOverscroll())
         handleOverscroll(scrollResult);
-    if (scrollResult.didScroll())
-        RETURN_WHEEL_EVENT_HANDLED();
+    if (scrollResult.didScroll()) {
+        setFrameWasScrolledByUser();
+        return WebInputEventResult::HandledDefaultHandler;
+    }
 
-    return false;
-#undef RETURN_WHEEL_EVENT_HANDLED
+    return WebInputEventResult::NotHandled;
 }
 
 void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)
 {
     if (!startNode || !wheelEvent)
         return;
 
     // When the wheelEvent do not scroll, we trigger zoom in/out instead.
     if (!wheelEvent->canScroll())
         return;
@@ skipping 10 matching lines @@
         && scroll(ScrollRightIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaX(), absolutePosition).didScroll)
         wheelEvent->setDefaultHandled();
 
     if (wheelEvent->railsMode() != Event::RailsModeHorizontal
         && scroll(ScrollDownIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaY(), absolutePosition).didScroll)
         wheelEvent->setDefaultHandled();
 
     m_previousWheelScrolledNode = stopNode;
 }
 
-bool EventHandler::handleGestureShowPress()
+WebInputEventResult EventHandler::handleGestureShowPress()
 {
     m_lastShowPressTimestamp = WTF::currentTime();
 
     FrameView* view = m_frame->view();
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
     if (ScrollAnimatorBase* scrollAnimator = view->existingScrollAnimator())
         scrollAnimator->cancelAnimations();
     const FrameView::ScrollableAreaSet* areas = view->scrollableAreas();
     if (!areas)
-        return false;
+        return WebInputEventResult::NotHandled;
     for (const ScrollableArea* scrollableArea : *areas) {
         ScrollAnimatorBase* animator = scrollableArea->existingScrollAnimator();
         if (animator)
             animator->cancelAnimations();
     }
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
-bool EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
+WebInputEventResult EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 {
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_frame->localFrameRoot());
 
     // Scrolling-related gesture events invoke EventHandler recursively for each frame down
     // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
     // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
     if (gestureEvent.isScrollEvent())
         return handleGestureScrollEvent(gestureEvent);
 
     // Hit test across all frames and do touch adjustment as necessary for the event type.
     GestureEventWithHitTestResults targetedEvent = targetGestureEvent(gestureEvent);
 
     return handleGestureEvent(targetedEvent);
 }
 
-bool EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
 
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_frame->localFrameRoot());
 
     // Non-scrolling related gesture events do a single cross-frame hit-test and jump
     // directly to the inner most frame. This matches handleMousePressEvent etc.
     ASSERT(!targetedEvent.event().isScrollEvent());
 
     // update mouseout/leave/over/enter events before jumping directly to the inner most frame
     if (targetedEvent.event().type() == PlatformEvent::GestureTap)
         updateGestureTargetNodeForMouseEvent(targetedEvent);
 
     // Route to the correct frame.
     if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
         return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
     return handleGestureEventInFrame(targetedEvent);
 }
 
-bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
     ASSERT(!targetedEvent.event().isScrollEvent());
 
     RefPtrWillBeRawPtr<Node> eventTarget = targetedEvent.hitTestResult().innerNode();
     RefPtrWillBeRawPtr<Scrollbar> scrollbar = targetedEvent.hitTestResult().scrollbar();
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
 
     if (scrollbar) {
         bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
         if (gestureEvent.type() == PlatformEvent::GestureTapDown && eventSwallowed)
             m_scrollbarHandlingScrollGesture = scrollbar;
         if (eventSwallowed)
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
     }
 
-    if (eventTarget && eventTarget->dispatchGestureEvent(gestureEvent))
-        return true;
+    if (eventTarget) {
+        RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
+        if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))
+            return eventToEventResult(gestureDomEvent, false);
+    }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureTap:
         return handleGestureTap(targetedEvent);
     case PlatformEvent::GestureShowPress:
         return handleGestureShowPress();
     case PlatformEvent::GestureLongPress:
         return handleGestureLongPress(targetedEvent);
     case PlatformEvent::GestureLongTap:
         return handleGestureLongTap(targetedEvent);
     case PlatformEvent::GestureTwoFingerTap:
         return sendContextMenuEventForGesture(targetedEvent);
     case PlatformEvent::GestureTapDown:
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
     case PlatformEvent::GestureTapDownCancel:
     case PlatformEvent::GestureTapUnconfirmed:
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
-bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
+WebInputEventResult EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
 
     RefPtrWillBeRawPtr<Node> eventTarget = nullptr;
     RefPtrWillBeRawPtr<Scrollbar> scrollbar = nullptr;
     if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
         scrollbar = m_scrollbarHandlingScrollGesture.get();
         eventTarget = m_scrollGestureHandlingNode.get();
     }
 
     if (!eventTarget) {
         Document* document = m_frame->document();
         if (!document->layoutView())
-            return false;
+            return WebInputEventResult::NotHandled;
 
         FrameView* view = m_frame->view();
         LayoutPoint viewPoint = view->rootFrameToContents(gestureEvent.position());
         HitTestRequest request(HitTestRequest::ReadOnly);
         HitTestResult result(request, viewPoint);
         document->layoutView()->hitTest(result);
 
         eventTarget = result.innerNode();
 
         m_lastGestureScrollOverWidget = result.isOverWidget();
         m_scrollGestureHandlingNode = eventTarget;
         m_previousGestureScrolledNode = nullptr;
 
         if (!scrollbar)
             scrollbar = result.scrollbar();
     }
 
     if (scrollbar) {
         bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
         if (gestureEvent.type() == PlatformEvent::GestureScrollEnd
             || gestureEvent.type() == PlatformEvent::GestureFlingStart
             || !eventSwallowed) {
             m_scrollbarHandlingScrollGesture = nullptr;
         }
         if (eventSwallowed)
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
     }
 
     if (eventTarget) {
-        bool eventSwallowed = handleScrollGestureOnResizer(eventTarget.get(), gestureEvent);
-        if (!eventSwallowed)
-            eventSwallowed = eventTarget->dispatchGestureEvent(gestureEvent);
-        if (eventSwallowed)
-            return true;
+        if (handleScrollGestureOnResizer(eventTarget.get(), gestureEvent))
+            return WebInputEventResult::HandledDefaultHandler;
+
+        RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
+        if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))
+            return eventToEventResult(gestureDomEvent, false);
     }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureScrollBegin:
         return handleGestureScrollBegin(gestureEvent);
     case PlatformEvent::GestureScrollUpdate:
         return handleGestureScrollUpdate(gestureEvent);
     case PlatformEvent::GestureScrollEnd:
         return handleGestureScrollEnd(gestureEvent);
     case PlatformEvent::GestureFlingStart:
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
-        return false;
+        return WebInputEventResult::NotHandled;
     default:
         ASSERT_NOT_REACHED();
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 }
 
-bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
 {
     RefPtrWillBeRawPtr<FrameView> frameView(m_frame->view());
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
     uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
     HitTestResult currentHitTest = targetedEvent.hitTestResult();
@@ skipping 29 matching lines @@
     RefPtrWillBeRawPtr<Node> tappedNode = m_clickNode;
     IntPoint tappedPosition = gestureEvent.position();
 
     if (m_clickNode && m_clickNode->isTextNode())
         m_clickNode = ComposedTreeTraversal::parent(*m_clickNode);
 
     PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
         static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
         PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
-    bool swallowMouseDownEvent = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
+    WebInputEventResult swallowMouseDownEvent = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
     selectionController().initializeSelectionState();
-    if (!swallowMouseDownEvent)
+    if (swallowMouseDownEvent == WebInputEventResult::NotHandled)
         swallowMouseDownEvent = handleMouseFocus(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest), InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
-    if (!swallowMouseDownEvent)
+    if (swallowMouseDownEvent == WebInputEventResult::NotHandled)
         swallowMouseDownEvent = handleMousePressEvent(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
 
     if (currentHitTest.innerNode()) {
         ASSERT(gestureEvent.type() == PlatformEvent::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(gestureEvent.position());
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     }
     PlatformMouseEvent fakeMouseUp(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MouseReleased, gestureEvent.tapCount(),
         static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
-    bool swallowMouseUpEvent = dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp);
+    WebInputEventResult swallowMouseUpEvent = dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp);
 
-    bool swallowClickEvent = false;
+    WebInputEventResult swallowClickEvent = WebInputEventResult::NotHandled;
     if (m_clickNode) {
         if (currentHitTest.innerNode()) {
             // Updates distribution because a mouseup (or mousedown) event listener can make the
             // tree dirty at dispatchMouseEvent() invocation above.
             // Unless distribution is updated, commonAncestor would hit ASSERT.
             // Both m_clickNode and currentHitTest.innerNode()) don't need to be updated
             // because commonAncestor() will exit early if their documents are different.
             m_clickNode->updateDistribution();
             Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(*m_clickNode, parentForClickEvent);
             swallowClickEvent = dispatchMouseEvent(EventTypeNames::click, clickTargetNode, gestureEvent.tapCount(), fakeMouseUp);
         }
         m_clickNode = nullptr;
     }
 
-    if (!swallowMouseUpEvent)
+    if (swallowMouseUpEvent == WebInputEventResult::NotHandled)
         swallowMouseUpEvent = handleMouseReleaseEvent(MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
 
-    bool swallowed = swallowMouseDownEvent | swallowMouseUpEvent | swallowClickEvent;
-    if (!swallowed && tappedNode && m_frame->page()) {
+    WebInputEventResult swallowed = mergeEventResult(mergeEventResult(swallowMouseDownEvent, swallowMouseUpEvent), swallowClickEvent);
+    if (swallowed == WebInputEventResult::NotHandled && tappedNode && m_frame->page()) {
         bool domTreeChanged = preDispatchDomTreeVersion != m_frame->document()->domTreeVersion();
         bool styleChanged = preDispatchStyleVersion != m_frame->document()->styleVersion();
 
         IntPoint tappedPositionInViewport = m_frame->page()->frameHost().visualViewport().rootFrameToViewport(tappedPosition);
         m_frame->chromeClient().showUnhandledTapUIIfNeeded(tappedPositionInViewport, tappedNode.get(), domTreeChanged || styleChanged);
     }
     return swallowed;
 }
 
-bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
 {
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     IntPoint adjustedPoint = gestureEvent.position();
 
     unsigned modifiers = gestureEvent.modifiers();
 
     // FIXME: Ideally we should try to remove the extra mouse-specific hit-tests here (re-using the
     // supplied HitTestResult), but that will require some overhaul of the touch drag-and-drop code
     // and LongPress is such a special scenario that it's unlikely to matter much in practice.
 
     m_longTapShouldInvokeContextMenu = false;
     if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
         PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
             static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
             PlatformMouseEvent::FromTouch, WTF::currentTime());
         m_mouseDown = mouseDownEvent;
 
         PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
             static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
             PlatformMouseEvent::FromTouch, WTF::currentTime());
         HitTestRequest request(HitTestRequest::ReadOnly);
         MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
         m_mouseDownMayStartDrag = true;
         dragState().m_dragSrc = nullptr;
         m_mouseDownPos = m_frame->view()->rootFrameToContents(mouseDragEvent.position());
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
         if (handleDrag(mev, DragInitiator::Touch)) {
             m_longTapShouldInvokeContextMenu = true;
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
         }
     }
 
     IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(gestureEvent.position());
     HitTestResult result = hitTestResultAtPoint(hitTestPoint);
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     if (selectionController().handleGestureLongPress(gestureEvent, result)) {
         focusDocumentView();
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 
     return sendContextMenuEventForGesture(targetedEvent);
 }
 
-bool EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)
 {
 #if !OS(ANDROID)
     if (m_longTapShouldInvokeContextMenu) {
         m_longTapShouldInvokeContextMenu = false;
         return sendContextMenuEventForGesture(targetedEvent);
     }
 #endif
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
 bool EventHandler::handleScrollGestureOnResizer(Node* eventTarget, const PlatformGestureEvent& gestureEvent)
 {
     if (gestureEvent.type() == PlatformEvent::GestureScrollBegin) {
         PaintLayer* layer = eventTarget->layoutObject() ? eventTarget->layoutObject()->enclosingLayer() : nullptr;
         IntPoint p = m_frame->view()->rootFrameToContents(gestureEvent.position());
         if (layer && layer->scrollableArea() && layer->scrollableArea()->isPointInResizeControl(p, ResizerForTouch)) {
             m_resizeScrollableArea = layer->scrollableArea();
             m_resizeScrollableArea->setInResizeMode(true);
             m_offsetFromResizeCorner = LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));
             return true;
         }
     } else if (gestureEvent.type() == PlatformEvent::GestureScrollUpdate) {
         if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
             m_resizeScrollableArea->resize(gestureEvent, m_offsetFromResizeCorner);
             return true;
         }
     } else if (gestureEvent.type() == PlatformEvent::GestureScrollEnd) {
         if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
             m_resizeScrollableArea->setInResizeMode(false);
             m_resizeScrollableArea = nullptr;
             return false;
         }
     }
 
     return false;
 }
 
-bool EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, LayoutObject* layoutObject)
+WebInputEventResult EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, LayoutObject* layoutObject)
 {
     ASSERT(gestureEvent.isScrollEvent());
 
-    if (!m_lastGestureScrollOverWidget)
-        return false;
-
-    if (!layoutObject || !layoutObject->isLayoutPart())
-        return false;
+    if (!m_lastGestureScrollOverWidget || !layoutObject || !layoutObject->isLayoutPart())
+        return WebInputEventResult::NotHandled;
 
     Widget* widget = toLayoutPart(layoutObject)->widget();
 
     if (!widget || !widget->isFrameView())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     return toFrameView(widget)->frame().eventHandler().handleGestureScrollEvent(gestureEvent);
 }
 
-bool EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
+WebInputEventResult EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
 {
     RefPtrWillBeRawPtr<Node> node = m_scrollGestureHandlingNode;
 
     if (node) {
         passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
             RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
                 0, 0, 0, 0, 0, gestureEvent.inertial(), /* isBeginning */
                 false, /* isEnding */ true, /* fromUserInput */ true);
             customizedScroll(*node.get(), *scrollState);
         }
     }
 
     clearGestureScrollState();
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
-bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
+WebInputEventResult EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
 {
     Document* document = m_frame->document();
     if (!document->layoutView())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     FrameView* view = m_frame->view();
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // If there's no layoutObject on the node, send the event to the nearest ancestor with a layoutObject.
     // Needed for <option> and <optgroup> elements so we can touch scroll <select>s
     while (m_scrollGestureHandlingNode && !m_scrollGestureHandlingNode->layoutObject())
         m_scrollGestureHandlingNode = m_scrollGestureHandlingNode->parentOrShadowHostNode();
 
     if (!m_scrollGestureHandlingNode) {
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
             m_scrollGestureHandlingNode = m_frame->document()->documentElement();
         else
-            return false;
+            return WebInputEventResult::NotHandled;
     }
     ASSERT(m_scrollGestureHandlingNode);
 
     passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
         m_currentScrollChain.clear();
         RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
             0, 0, 0, 0, 0, /* inInertialPhase */ false, /* isBeginning */
             true, /* isEnding */ false, /* fromUserInput */ true);
         customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
     } else {
         if (m_frame->isMainFrame())
             m_frame->host()->topControls().scrollBegin();
     }
-    return true;
+    return WebInputEventResult::HandledDefaultHandler;
 }
 
 void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)
 {
     if (didScrollX)
         m_accumulatedRootOverscroll.setWidth(0);
     if (didScrollY)
         m_accumulatedRootOverscroll.setHeight(0);
 }
 
@@ skipping 11 matching lines @@
 {
     FloatSize unusedDelta(scrollResult.unusedScrollDeltaX, scrollResult.unusedScrollDeltaY);
     unusedDelta = adjustOverscoll(unusedDelta);
     resetOverscroll(scrollResult.didScrollX, scrollResult.didScrollY);
     if (unusedDelta != FloatSize()) {
         m_accumulatedRootOverscroll += unusedDelta;
         m_frame->chromeClient().didOverscroll(unusedDelta, m_accumulatedRootOverscroll, position, velocity);
     }
 }
 
-bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
+WebInputEventResult EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     Node* node = m_scrollGestureHandlingNode.get();
     if (node) {
         LayoutObject* layoutObject = node->layoutObject();
         if (!layoutObject)
-            return false;
+            return WebInputEventResult::NotHandled;
 
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
         Node* stopNode = nullptr;
 
         // Try to send the event to the correct view.
-        if (passScrollGestureEventToWidget(gestureEvent, layoutObject)) {
+        WebInputEventResult result = passScrollGestureEventToWidget(gestureEvent, layoutObject);
+        if (result != WebInputEventResult::NotHandled) {
             if (gestureEvent.preventPropagation()
                 && !RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
                 // This is an optimization which doesn't apply with
                 // scroll customization enabled.
                 m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
             }
             // FIXME: we should allow simultaneous scrolling of nested
             // iframes along perpendicular axes. See crbug.com/466991.
             m_deltaConsumedForScrollSequence = true;
-            return true;
+            return result;
         }
 
         bool scrolled = false;
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
             RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
                 gestureEvent.deltaX(), gestureEvent.deltaY(),
                 0, gestureEvent.velocityX(), gestureEvent.velocityY(),
                 gestureEvent.inertial(), /* isBeginning */
                 false, /* isEnding */ false, /* fromUserInput */ true,
                 !gestureEvent.preventPropagation(), m_deltaConsumedForScrollSequence);
@@ skipping 24 matching lines @@
             bool verticalScroll = result.didScroll;
             scrolled = horizontalScroll || verticalScroll;
 
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
 
             resetOverscroll(horizontalScroll, verticalScroll);
         }
         if (scrolled) {
             setFrameWasScrolledByUser();
-            return true;
+            return WebInputEventResult::HandledDefaultHandler;
         }
     }
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // Try to scroll the frame view.
     ScrollResult scrollResult = m_frame->applyScrollDelta(delta, false);
     FloatPoint position = FloatPoint(gestureEvent.position().x(), gestureEvent.position().y());
     FloatSize velocity = FloatSize(gestureEvent.velocityX(), gestureEvent.velocityY());
     handleOverscroll(scrollResult, position, velocity);
     if (scrollResult.didScroll()) {
         setFrameWasScrolledByUser();
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 
-    return false;
+    return WebInputEventResult::NotHandled;
 }
 
 void EventHandler::clearGestureScrollState()
 {
     m_scrollGestureHandlingNode = nullptr;
     m_previousGestureScrolledNode = nullptr;
     m_deltaConsumedForScrollSequence = false;
     m_currentScrollChain.clear();
     m_accumulatedRootOverscroll = FloatSize();
 }
@@ skipping 317 matching lines @@
     }
 
     // Update the hit-test result to be a point-based result instead of a rect-based result.
     // FIXME: We should do this even when no candidate matches the node filter. crbug.com/398914
     if (adjusted) {
         hitTestResult->resolveRectBasedTest(adjustedNode, m_frame->view()->rootFrameToContents(adjustedPoint));
         gestureEvent->applyTouchAdjustment(adjustedPoint);
     }
 }
 
-bool EventHandler::sendContextMenuEvent(const PlatformMouseEvent& event, Node* overrideTargetNode)
+WebInputEventResult EventHandler::sendContextMenuEvent(const PlatformMouseEvent& event, Node* overrideTargetNode)
 {
     FrameView* v = m_frame->view();
     if (!v)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // Clear mouse press state to avoid initiating a drag while context menu is up.
     m_mousePressed = false;
     LayoutPoint positionInContents = v->rootFrameToContents(event.position());
     HitTestRequest request(HitTestRequest::Active);
     MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(request, positionInContents, event);
 
     selectionController().sendContextMenuEvent(mev, positionInContents);
 
     Node* targetNode = overrideTargetNode ? overrideTargetNode : mev.innerNode();
     return dispatchMouseEvent(EventTypeNames::contextmenu, targetNode, 0, event);
 }
 
-bool EventHandler::sendContextMenuEventForKey(Element* overrideTargetElement)
+WebInputEventResult EventHandler::sendContextMenuEventForKey(Element* overrideTargetElement)
 {
     FrameView* view = m_frame->view();
     if (!view)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     Document* doc = m_frame->document();
     if (!doc)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     // Clear mouse press state to avoid initiating a drag while context menu is up.
     m_mousePressed = false;
 
     static const int kContextMenuMargin = 1;
 
 #if OS(WIN)
     int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT);
 #else
     int rightAligned = 0;
@@ skipping 43 matching lines @@
     // This is required for web compatibility.
     PlatformEvent::Type eventType = PlatformEvent::MousePressed;
     if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
         eventType = PlatformEvent::MouseReleased;
 
     PlatformMouseEvent mouseEvent(locationInRootFrame, globalPosition, RightButton, eventType, 1, PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable, WTF::currentTime());
 
     return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
-bool EventHandler::sendContextMenuEventForGesture(const GestureEventWithHitTestResults& targetedEvent)
+WebInputEventResult EventHandler::sendContextMenuEventForGesture(const GestureEventWithHitTestResults& targetedEvent)
 {
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     unsigned modifiers = gestureEvent.modifiers();
 
     // Send MouseMoved event prior to handling (https://crbug.com/485290).
     PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
         NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
         static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch, gestureEvent.timestamp());
     dispatchMouseEvent(EventTypeNames::mousemove, targetedEvent.hitTestResult().innerNode(), 0, fakeMouseMove);
@@ skipping 167 matching lines @@
     if ((evt.modifiers() & (PlatformEvent::KeyModifiers & ~PlatformEvent::ShiftKey)) != accessKeyModifiers())
         return false;
     String key = evt.unmodifiedText();
     Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
     if (!elem)
         return false;
     elem->accessKeyAction(false);
     return true;
 }
 
-bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
+WebInputEventResult EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
 {
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     m_frame->chromeClient().setToolTip(String(), LTR);
 
     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
         capsLockStateMayHaveChanged();
 
 #if OS(WIN)
     if (panScrollInProgress()) {
         // If a key is pressed while the panScroll is in progress then we want to stop
         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
             stopAutoscroll();
 
         // If we were in panscroll mode, we swallow the key event
-        return true;
+        return WebInputEventResult::HandledDefaultHandler;
     }
 #endif
 
     // Check for cases where we are too early for events -- possible unmatched key up
     // from pressing return in the location bar.
     RefPtrWillBeRawPtr<Node> node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
-        return false;
+        return WebInputEventResult::NotHandled;
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
     // 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() == PlatformEvent::KeyDown)
         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
     // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
-    if (initialKeyEvent.type() == PlatformEvent::KeyUp || initialKeyEvent.type() == PlatformEvent::Char)
-        return !node->dispatchKeyEvent(initialKeyEvent);
+    if (initialKeyEvent.type() == PlatformEvent::KeyUp || initialKeyEvent.type() == PlatformEvent::Char) {
+        RefPtrWillBeRawPtr<KeyboardEvent> domEvent = KeyboardEvent::create(initialKeyEvent, m_frame->document()->domWindow());
+
+        bool dispatchResult = node->dispatchEvent(domEvent);
+        return eventToEventResult(domEvent, dispatchResult);
+    }
 
     PlatformKeyboardEvent keyDownEvent = initialKeyEvent;
     if (keyDownEvent.type() != PlatformEvent::RawKeyDown)
         keyDownEvent.disambiguateKeyDownEvent(PlatformEvent::RawKeyDown);
     RefPtrWillBeRawPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
     if (matchedAnAccessKey)
         keydown->setDefaultPrevented(true);
     keydown->setTarget(node);
 
     if (initialKeyEvent.type() == PlatformEvent::RawKeyDown) {
-        node->dispatchEvent(keydown);
+        bool dispatchResult = node->dispatchEvent(keydown);
         // If frame changed as a result of keydown dispatch, then return true to avoid sending a subsequent keypress message to the new frame.
         bool changedFocusedFrame = m_frame->page() && m_frame != m_frame->page()->focusController().focusedOrMainFrame();
-        return keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
+        if (changedFocusedFrame)
+            return WebInputEventResult::HandledDefaultHandler;
+        return eventToEventResult(keydown, dispatchResult);
     }
 
-    node->dispatchEvent(keydown);
+    bool dispatchResult = node->dispatchEvent(keydown);
     // 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();
-    bool keydownResult = keydown->defaultHandled() || keydown->defaultPrevented() || changedFocusedFrame;
-    if (keydownResult)
-        return keydownResult;
+    if (keydown->defaultPrevented())
+        return WebInputEventResult::HandledScript;
+    if (dispatchResult || changedFocusedFrame || keydown->defaultHandled())
+        return WebInputEventResult::HandledDefaultHandler;
 
     // 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 false;
+        return WebInputEventResult::NotHandled;
 
     PlatformKeyboardEvent keyPressEvent = initialKeyEvent;
     keyPressEvent.disambiguateKeyDownEvent(PlatformEvent::Char);
     if (keyPressEvent.text().isEmpty())
-        return keydownResult;
+        return WebInputEventResult::NotHandled;
     RefPtrWillBeRawPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
     keypress->setTarget(node);
-    if (keydownResult)
-        keypress->setDefaultPrevented(true);
-    node->dispatchEvent(keypress);
+    dispatchResult = node->dispatchEvent(keypress);
 
-    return keydownResult || keypress->defaultPrevented() || keypress->defaultHandled();
+    return eventToEventResult(keypress, dispatchResult);
 }
 
 static WebFocusType focusDirectionForKey(const AtomicString& keyIdentifier)
 {
     DEFINE_STATIC_LOCAL(AtomicString, Down, ("Down", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Up, ("Up", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Left, ("Left", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Right, ("Right", AtomicString::ConstructFromLiteral));
 
     WebFocusType retVal = WebFocusTypeNone;
@@ skipping 97 matching lines @@
 }
 
 void EventHandler::updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement)
 {
     // If inserting the dragged contents removed the drag source, we still want to fire dragend at the root editble element.
     if (dragState().m_dragSrc && !dragState().m_dragSrc->inDocument())
         dragState().m_dragSrc = rootEditableElement;
 }
 
 // returns if we should continue "default processing", i.e., whether eventhandler canceled
-bool EventHandler::dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent& event)
+WebInputEventResult EventHandler::dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent& event)
 {
     return dispatchDragEvent(eventType, dragState().m_dragSrc.get(), event, dragState().m_dragDataTransfer.get());
 }
 
 bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event, DragInitiator initiator)
 {
     ASSERT(event.event().type() == PlatformEvent::MouseMoved);
     // Callers must protect the reference to FrameView, since this function may dispatch DOM
     // events, causing page/FrameView to go away.
     ASSERT(m_frame);
@@ skipping 68 matching lines @@
     DragController& dragController = m_frame->page()->dragController();
     if (!dragController.populateDragDataTransfer(m_frame, dragState(), m_mouseDownPos))
         return false;
 
     // If dispatching dragstart brings about another mouse down -- one way
     // this will happen is if a DevTools user breaks within a dragstart
     // handler and then clicks on the suspended page -- the drag state is
     // reset. Hence, need to check if this particular drag operation can
     // continue even if dispatchEvent() indicates no (direct) cancellation.
     // Do that by checking if m_dragSrc is still set.
-    m_mouseDownMayStartDrag = !dispatchDragSrcEvent(EventTypeNames::dragstart, m_mouseDown)
+    m_mouseDownMayStartDrag = dispatchDragSrcEvent(EventTypeNames::dragstart, m_mouseDown) == WebInputEventResult::NotHandled
         && !m_frame->selection().isInPasswordField() && dragState().m_dragSrc;
 
     // Invalidate clipboard here against anymore pasteboard writing for security. The drag
     // image can still be changed as we drag, but not the pasteboard data.
     dragState().m_dragDataTransfer->setAccessPolicy(DataTransferImageWritable);
 
     if (m_mouseDownMayStartDrag) {
         // Dispatching the event could cause Page to go away. Make sure it's still valid before trying to use DragController.
         if (m_frame->page() && dragController.startDrag(m_frame, dragState(), event.event(), m_mouseDownPos))
             return true;
@@ skipping 280 matching lines @@
     // instance represents.
     RefPtrWillBeMember<TouchList> m_touches;
 
     using EventTargetSet = WillBeHeapHashSet<RefPtrWillBeMember<EventTarget>>;
     // Set of targets involved in m_touches.
     EventTargetSet m_targets;
 };
 
 } // namespace
 
-bool EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
+WebInputEventResult EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
     WillBeHeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
 {
     // Build up the lists to use for the 'touches', 'targetTouches' and
     // 'changedTouches' attributes in the JS event. See
     // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
     // lists fit together.
 
     // Holds the complete set of touches on the screen.
     RefPtrWillBeRawPtr<TouchList> touches = TouchList::create();
 
@@ skipping 51 matching lines @@
                 changedTouches[pointState].m_touches = TouchList::create();
             changedTouches[pointState].m_touches->append(touch);
             changedTouches[pointState].m_targets.add(touchInfo.touchTarget);
         }
     }
     if (allTouchReleased) {
         m_touchSequenceDocument.clear();
         m_touchSequenceUserGestureToken.clear();
     }
 
-    bool swallowedEvent = false;
+    WebInputEventResult swallowedEvent = WebInputEventResult::NotHandled;
 
     // Now iterate through the changedTouches list and m_targets within it, sending
     // TouchEvents to the targets as required.
     for (unsigned state = 0; state != PlatformTouchPoint::TouchStateEnd; ++state) {
         if (!changedTouches[state].m_touches)
             continue;
 
         const AtomicString& eventName(touchEventNameForTouchPointState(static_cast<PlatformTouchPoint::State>(state)));
         for (const auto& eventTarget : changedTouches[state].m_targets) {
             EventTarget* touchEventTarget = eventTarget.get();
             RefPtrWillBeRawPtr<TouchEvent> touchEvent = TouchEvent::create(
                 touches.get(), touchesByTarget.get(touchEventTarget), changedTouches[state].m_touches.get(),
                 eventName, touchEventTarget->toNode()->document().domWindow(),
                 event.modifiers(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
 
-            touchEventTarget->dispatchEvent(touchEvent.get());
-            swallowedEvent = swallowedEvent || touchEvent->defaultPrevented() || touchEvent->defaultHandled();
+            bool dispatchResult = touchEventTarget->dispatchEvent(touchEvent.get());
+            swallowedEvent = mergeEventResult(swallowedEvent, eventToEventResult(touchEvent, dispatchResult));
         }
     }
 
     return swallowedEvent;
 }
 
-bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
+WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
     const Vector<PlatformTouchPoint>& points = event.touchPoints();
 
     bool freshTouchEvents = true;
     bool allTouchReleased = true;
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
 
@@ skipping 18 matching lines @@
         gestureIndicator = adoptPtr(new UserGestureIndicator(m_touchSequenceUserGestureToken.release()));
     else
         gestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingUserGesture));
 
     m_touchSequenceUserGestureToken = gestureIndicator->currentToken();
 
     ASSERT(m_frame->view());
     if (m_touchSequenceDocument && (!m_touchSequenceDocument->frame() || !m_touchSequenceDocument->frame()->view())) {
         // If the active touch document has no frame or view, it's probably being destroyed
         // so we can't dispatch events.
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 
     // First do hit tests for any new touch points.
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
 
         // Touch events implicitly capture to the touched node, and don't change
         // active/hover states themselves (Gesture events do). So we only need
         // to hit-test on touchstart, and it can be read-only.
         if (point.state() == PlatformTouchPoint::TouchPressed) {
@@ skipping 42 matching lines @@
     m_touchPressed = !allTouchReleased;
 
     // If there's no document receiving touch events, or no handlers on the
     // document set to receive the events, then we can skip all the rest of
     // this work.
     if (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() || !m_touchSequenceDocument->frameHost()->eventHandlerRegistry().hasEventHandlers(EventHandlerRegistry::TouchEvent) || !m_touchSequenceDocument->frame()) {
         if (allTouchReleased) {
             m_touchSequenceDocument.clear();
             m_touchSequenceUserGestureToken.clear();
         }
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 
     // Compute and store the common info used by both PointerEvent and TouchEvent.
     WillBeHeapVector<TouchInfo> touchInfos(points.size());
 
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
         PlatformTouchPoint::State pointState = point.state();
         RefPtrWillBeRawPtr<EventTarget> touchTarget = nullptr;
 
@@ skipping 58 matching lines @@
         // Note that the disposition of any pointer events affects only the generation of touch
         // events. If all pointer events were handled (and hence no touch events were fired), that
         // is still equivalent to the touch events going unhandled because pointer event handler
         // don't block scroll gesture generation.
     }
 
     // TODO(crbug.com/507408): If PE handlers always call preventDefault, we won't see TEs until after
     // scrolling starts because the scrolling would suppress upcoming PEs. This sudden "break" in TE
     // suppression can make the visible TEs inconsistent (e.g. touchmove without a touchstart).
 
-    bool swallowedTouchEvent = dispatchTouchEvents(event, touchInfos, freshTouchEvents,
+    WebInputEventResult swallowedTouchEvent = dispatchTouchEvents(event, touchInfos, freshTouchEvents,
         allTouchReleased);
 
     if (!m_inPointerCanceledState) {
         // Check if we need to stop firing pointer events because of a touch action.
         // See: www.w3.org/TR/pointerevents/#declaring-candidate-regions-for-default-touch-behaviors
-        if (event.causesScrollingIfUncanceled() && !swallowedTouchEvent) {
+        if (event.causesScrollingIfUncanceled() && swallowedTouchEvent == WebInputEventResult::NotHandled) {
             m_inPointerCanceledState = true;
             sendPointerCancels(touchInfos);
         }
     } else if (allTouchReleased) {
         m_inPointerCanceledState = false;
     }
 
     return swallowedTouchEvent;
 }
 
@@ skipping 24 matching lines @@
     subframe->eventHandler().handleMouseMoveOrLeaveEvent(mev.event(), hoveredNode);
     return true;
 }
 
 bool EventHandler::passMouseReleaseEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)
 {
     subframe->eventHandler().handleMouseReleaseEvent(mev.event());
     return true;
 }
 
-bool EventHandler::passWheelEventToWidget(const PlatformWheelEvent& wheelEvent, Widget& widget)
+WebInputEventResult EventHandler::passWheelEventToWidget(const PlatformWheelEvent& wheelEvent, Widget& widget)
 {
     // If not a FrameView, then probably a plugin widget.  Those will receive
     // the event via an EventTargetNode dispatch when this returns false.
     if (!widget.isFrameView())
-        return false;
+        return WebInputEventResult::NotHandled;
 
     return toFrameView(&widget)->frame().eventHandler().handleWheelEvent(wheelEvent);
 }
 
 DataTransfer* EventHandler::createDraggingDataTransfer() const
 {
     return DataTransfer::create(DataTransfer::DragAndDrop, DataTransferWritable, DataObject::create());
 }
 
 void EventHandler::focusDocumentView()
 {
     Page* page = m_frame->page();
     if (!page)
         return;
     page->focusController().focusDocumentView(m_frame);
 }
 
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink