third_party/WebKit/Source/core/input/EventHandler.cpp - Issue 1463823003: Return a enumeration of the state of handling of InputEvents.

Unified Diff: third_party/WebKit/Source/core/input/EventHandler.cpp

Issue 1463823003: Return a enumeration of the state of handling of InputEvents. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Add 4th result type Created 5 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« no previous file with comments | « third_party/WebKit/Source/core/input/EventHandler.h ('k') | third_party/WebKit/Source/core/page/DragController.cpp » ('j') | third_party/WebKit/public/platform/WebInputEventResult.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

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

diff --git a/third_party/WebKit/Source/core/input/EventHandler.cpp b/third_party/WebKit/Source/core/input/EventHandler.cpp

index ff2da3c7ddce57cf5d8692c008262b125df98929..da8325ed3df59705856f094a8dceff155234f7dd 100644

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

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

@@ -42,6 +42,7 @@

#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"

@@ -103,6 +104,26 @@ namespace blink {

namespace {

+WebInputEventResult mergeEventResult(WebInputEventResult responseA, WebInputEventResult responseB)

+ return static_cast<WebInputEventResult>(max(static_cast<int>(responseA), static_cast<int>(responseB)));

+WebInputEventResult eventToEventResult(PassRefPtrWillBeRawPtr<Event> event, bool res)

+ if (event->defaultPrevented())

+ return WebInputEventResult::HandledApplication;

+ if (event->defaultHandled())

+ return WebInputEventResult::HandledSystem;

+ // 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::HandledSuppressed;

+ return WebInputEventResult::NotHandled;

bool isNodeInDocument(Node* n)

{

return n && n->inDocument();

@@ -400,7 +421,7 @@ void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)

}

-bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)

+WebInputEventResult EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)

{

TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");

@@ -413,7 +434,7 @@ bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& eve

if (FrameView* frameView = m_frame->view()) {

if (frameView->isPointInScrollbarCorner(event.event().position()))

- return false;

+ return WebInputEventResult::NotHandled;

}

bool singleClick = event.event().clickCount() <= 1;

@@ -428,7 +449,7 @@ bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& eve

if (event.event().shiftKey() && singleClick) {

m_svgPan = true;

m_frame->document()->accessSVGExtensions().startPan(m_frame->view()->rootFrameToContents(event.event().position()));

- return true;

+ return WebInputEventResult::HandledSystem;

}

@@ -455,10 +476,10 @@ bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& eve

m_mouseDownMayStartAutoscroll = selectionController().mouseDownMayStartSelect()

|| (m_mousePressNode && m_mousePressNode->layoutBox() && m_mousePressNode->layoutBox()->canBeProgramaticallyScrolled());

- return swallowEvent;

+ return swallowEvent ? WebInputEventResult::HandledSystem : WebInputEventResult::NotHandled;

}

-bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)

+WebInputEventResult EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)

{

TRACE_EVENT0("blink", "EventHandler::handleMouseDraggedEvent");

@@ -480,24 +501,24 @@ bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& e

m_mousePressed = false;

if (!m_mousePressed)

- return false;

+ return WebInputEventResult::NotHandled;

if (handleDrag(event, DragInitiator::Mouse))

- return true;

+ return WebInputEventResult::HandledSystem;

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;

@@ -510,7 +531,7 @@ bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& e

}

selectionController().handleMouseDraggedEvent(event, m_mouseDownPos, m_dragStartPos, m_mousePressNode.get(), m_lastKnownMousePosition);

- return true;

+ return WebInputEventResult::HandledSystem;

}

void EventHandler::updateSelectionForMouseDrag()

@@ -518,7 +539,7 @@ 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())

@@ -531,7 +552,7 @@ bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& e

m_mouseDownMayStartDrag = false;

m_mouseDownMayStartAutoscroll = false;

- return selectionController().handleMouseReleaseEvent(event, m_dragStartPos);

+ return selectionController().handleMouseReleaseEvent(event, m_dragStartPos) ? WebInputEventResult::HandledSystem : WebInputEventResult::NotHandled;

}

#if OS(WIN)

@@ -948,7 +969,7 @@ static LayoutPoint contentPointFromRootFrame(LocalFrame* frame, const IntPoint&

return view ? view->rootFrameToContents(pointInRootFrame) : pointInRootFrame;

}

-bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

+WebInputEventResult EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

{

TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");

@@ -971,7 +992,7 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

m_mouseDownPos = view->rootFrameToContents(mouseEvent.position());

} else {

invalidateClick();

- return false;

+ return WebInputEventResult::NotHandled;

}

HitTestRequest request(HitTestRequest::Active);

@@ -982,13 +1003,14 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& 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())) {

+ if (subframe) {

+ WebInputEventResult result = 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();

@@ -997,7 +1019,7 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

m_eventHandlerWillResetCapturingMouseEventsNode = true;

}

invalidateClick();

- return true;

+ return result;

}

#if OS(WIN)

@@ -1009,7 +1031,7 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

// 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::HandledSuppressed;

}

#endif

@@ -1024,13 +1046,13 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

m_resizeScrollableArea->setInResizeMode(true);

m_offsetFromResizeCorner = LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));

invalidateClick();

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

m_frame->selection().setCaretBlinkingSuspended(true);

- bool swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mouseEvent);

+ WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mouseEvent);

// m_selectionInitiationState is initialized after dispatching mousedown

// event in order not to keep the selection by DOM APIs Because we can't

@@ -1041,8 +1063,9 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

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 (eventResult == WebInputEventResult::NotHandled)

+ eventResult = handleMouseFocus(MouseEventWithHitTestResults(mouseEvent, hitTestResult), sourceCapabilities);

+ m_capturesDragging = eventResult == 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.

@@ -1054,7 +1077,7 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

m_lastScrollbarUnderMouse = nullptr;

}

- if (swallowEvent) {

+ if (eventResult != WebInputEventResult::NotHandled) {

// scrollbars should get events anyway, even disabled controls might be scrollable

passMousePressEventToScrollbar(mev);

} else {

@@ -1064,9 +1087,9 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

}

if (passMousePressEventToScrollbar(mev))

- swallowEvent = true;

+ eventResult = WebInputEventResult::HandledSystem;

else

- swallowEvent = handleMousePressEvent(mev);

+ eventResult = handleMousePressEvent(mev);

}

if (mev.hitTestResult().innerNode() && mouseEvent.button() == LeftButton) {

@@ -1076,7 +1099,7 @@ bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)

m_frame->chromeClient().onMouseDown(result.innerNode());

}

- return swallowEvent;

+ return eventResult;

}

static PaintLayer* layerForNode(Node* node)

@@ -1105,7 +1128,7 @@ ScrollableArea* EventHandler::associatedScrollableArea(const PaintLayer* layer)

return nullptr;

}

-bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)

+WebInputEventResult EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)

{

TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");

@@ -1114,7 +1137,7 @@ bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& 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)

@@ -1144,7 +1167,7 @@ void EventHandler::handleMouseLeaveEvent(const PlatformMouseEvent& event)

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());

@@ -1160,7 +1183,7 @@ bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEv

if (m_svgPan) {

m_frame->document()->accessSVGExtensions().updatePan(m_frame->view()->rootFrameToContents(m_lastKnownMousePosition));

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

if (m_frameSetBeingResized)

@@ -1169,7 +1192,7 @@ bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEv

// Send events right to a scrollbar if the mouse is pressed.

if (m_lastScrollbarUnderMouse && m_mousePressed) {

m_lastScrollbarUnderMouse->mouseMoved(mouseEvent);

- return true;

+ return WebInputEventResult::HandledSystem;

}

// Mouse events simulated from touch should not hit-test again.

@@ -1212,10 +1235,10 @@ bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEv

updateLastScrollbarUnderMouse(scrollbar, !m_mousePressed);

if (onlyUpdateScrollbars)

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

- bool swallowEvent = false;

+ WebInputEventResult eventResult = WebInputEventResult::NotHandled;

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.

@@ -1229,7 +1252,7 @@ bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEv

// Event dispatch in updateMouseEventTargetNode may have caused the subframe of the target

// node to be detached from its FrameView, in which case the event should not be passed.

if (newSubframe->view())

- swallowEvent |= passMouseMoveEventToSubframe(mev, newSubframe.get(), hoveredNode);

+ eventResult = passMouseMoveEventToSubframe(mev, newSubframe.get(), hoveredNode);

} else {

if (scrollbar && !m_mousePressed)

scrollbar->mouseMoved(mouseEvent); // Handle hover effects on platforms that support visual feedback on scrollbar hovering.

@@ -1243,15 +1266,14 @@ bool EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEv

m_lastMouseMoveEventSubframe = newSubframe;

- if (swallowEvent)

- return true;

- swallowEvent = updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove, mev.innerNode(), 0, mouseEvent);

+ if (eventResult != WebInputEventResult::NotHandled)

+ return eventResult;

- if (!swallowEvent)

- swallowEvent = handleMouseDraggedEvent(mev);

+ eventResult = updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove, mev.innerNode(), 0, mouseEvent);

+ if (eventResult != WebInputEventResult::NotHandled)

+ return eventResult;

- return swallowEvent;

+ return handleMouseDraggedEvent(mev);

}

void EventHandler::invalidateClick()

@@ -1270,7 +1292,7 @@ static ContainerNode* parentForClickEvent(const Node& node)

return ComposedTreeTraversal::parent(node);

}

-bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)

+WebInputEventResult EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)

{

TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");

@@ -1296,7 +1318,7 @@ bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)

if (m_svgPan) {

m_svgPan = false;

m_frame->document()->accessSVGExtensions().updatePan(m_frame->view()->rootFrameToContents(m_lastKnownMousePosition));

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

if (m_frameSetBeingResized)

@@ -1317,10 +1339,10 @@ bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& 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;

+ if (subframe)

+ return passMouseReleaseEventToSubframe(mev, subframe);

- 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;

@@ -1332,7 +1354,6 @@ bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)

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.

@@ -1357,22 +1378,21 @@ bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)

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(),

@@ -1381,8 +1401,8 @@ bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTa

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)

@@ -1437,12 +1457,12 @@ static bool findDropZone(Node* target, DataTransfer* dataTransfer)

return false;

}

-bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)

+WebInputEventResult EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)

{

- bool accept = false;

+ WebInputEventResult eventResult = WebInputEventResult::NotHandled;

if (!m_frame->view())

- return false;

+ return eventResult;

HitTestRequest request(HitTestRequest::ReadOnly);

MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);

@@ -1464,21 +1484,21 @@ bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransf

LocalFrame* targetFrame;

if (targetIsFrame(newTarget.get(), targetFrame)) {

if (targetFrame)

- accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);

+ eventResult = 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);

+ eventResult = dispatchDragEvent(EventTypeNames::dragenter, newTarget.get(), event, dataTransfer);

+ if (eventResult == WebInputEventResult::NotHandled && findDropZone(newTarget.get(), dataTransfer))

+ eventResult = WebInputEventResult::HandledSystem;

}

if (targetIsFrame(m_dragTarget.get(), targetFrame)) {

if (targetFrame)

- accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);

+ eventResult = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);

} else if (m_dragTarget) {

dispatchDragEvent(EventTypeNames::dragleave, m_dragTarget.get(), event, dataTransfer);

}

@@ -1492,22 +1512,22 @@ bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, DataTransf

LocalFrame* targetFrame;

if (targetIsFrame(newTarget.get(), targetFrame)) {

if (targetFrame)

- accept = targetFrame->eventHandler().updateDragAndDrop(event, dataTransfer);

+ eventResult = 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);

+ eventResult = dispatchDragEvent(EventTypeNames::dragover, newTarget.get(), event, dataTransfer);

+ if (eventResult == WebInputEventResult::NotHandled && findDropZone(newTarget.get(), dataTransfer))

+ eventResult = WebInputEventResult::HandledSystem;

m_shouldOnlyFireDragOverEvent = false;

}

m_dragTarget = newTarget;

- return accept;

+ return eventResult;

}

void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, DataTransfer* dataTransfer)

@@ -1524,18 +1544,18 @@ void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, DataTransf

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()

@@ -1612,16 +1632,17 @@ void EventHandler::updateMouseEventTargetNode(Node* targetNode, const PlatformMo

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,

@@ -1727,14 +1748,19 @@ void EventHandler::sendMouseEventsForNodeTransition(Node* exitedNode, Node* ente

}

-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

@@ -1742,29 +1768,31 @@ bool EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mous

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.

@@ -1775,7 +1803,7 @@ bool EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targeted

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;

}

@@ -1791,14 +1819,14 @@ bool EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targeted

// |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::HandledSystem;

if (Page* page = m_frame->page()) {

// If focus shift is blocked, we eat the event. Note we should never

@@ -1806,20 +1834,20 @@ bool EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targeted

// default behavior).

if (element) {

if (slideFocusOnShadowHostIfNecessary(*element))

- return true;

+ return WebInputEventResult::HandledSystem;

if (!page->focusController().setFocusedElement(element, m_frame, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeMouse, sourceCapabilities)))

- return true;

+ return WebInputEventResult::HandledSystem;

} 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::HandledSystem;

}

- return false;

+ return WebInputEventResult::NotHandled;

}

bool EventHandler::slideFocusOnShadowHostIfNecessary(const Element& element)

@@ -1880,24 +1908,18 @@ ScrollResult scrollAreaWithWheelEvent(const PlatformWheelEvent& event, Scrollabl

} // 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());

@@ -1920,33 +1942,41 @@ bool EventHandler::handleWheelEvent(const PlatformWheelEvent& event)

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::HandledSystem;

+ }

- return false;

-#undef RETURN_WHEEL_EVENT_HANDLED

+ return WebInputEventResult::NotHandled;

}

void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)

@@ -1977,27 +2007,27 @@ void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEv

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());

@@ -2014,7 +2044,7 @@ bool EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)

return handleGestureEvent(targetedEvent);

}

-bool EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)

+WebInputEventResult EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)

{

TRACE_EVENT0("input", "EventHandler::handleGestureEvent");

@@ -2037,7 +2067,7 @@ bool EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targ

return handleGestureEventInFrame(targetedEvent);

}

-bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)

+WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)

{

ASSERT(!targetedEvent.event().isScrollEvent());

@@ -2050,11 +2080,16 @@ bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResult

if (gestureEvent.type() == PlatformEvent::GestureTapDown && eventSwallowed)

m_scrollbarHandlingScrollGesture = scrollbar;

if (eventSwallowed)

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

- if (eventTarget && eventTarget->dispatchGestureEvent(gestureEvent))

- return true;

+ if (eventTarget) {

+ RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);

+ // TODO(dtapuska): dispatchEvent is inverted for Gesture Events

+ // crbug.com/560357

+ if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))

+ return eventToEventResult(gestureDomEvent, false);

+ }

switch (gestureEvent.type()) {

case PlatformEvent::GestureTap:

@@ -2078,10 +2113,10 @@ bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResult

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");

@@ -2095,7 +2130,7 @@ bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureE

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());

@@ -2121,15 +2156,18 @@ bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureE

m_scrollbarHandlingScrollGesture = nullptr;

}

if (eventSwallowed)

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

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::HandledSuppressed;

+ RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);

+ // TODO(dtapuska): dispatchEvent is inverted for Gesture Events

+ // crbug.com/560357

+ if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))

+ return eventToEventResult(gestureDomEvent, false);

}

switch (gestureEvent.type()) {

@@ -2143,14 +2181,14 @@ bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureE

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();

@@ -2200,11 +2238,11 @@ bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& target

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()) {

@@ -2226,9 +2264,9 @@ bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& target

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

@@ -2243,21 +2281,21 @@ bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& target

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 eventResult = mergeEventResult(mergeEventResult(swallowMouseDownEvent, swallowMouseUpEvent), swallowClickEvent);

+ if (eventResult == 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;

+ return eventResult;

}

-bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)

+WebInputEventResult EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)

{

const PlatformGestureEvent& gestureEvent = targetedEvent.event();

IntPoint adjustedPoint = gestureEvent.position();

@@ -2286,7 +2324,7 @@ bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults&

RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());

if (handleDrag(mev, DragInitiator::Touch)) {

m_longTapShouldInvokeContextMenu = true;

- return true;

+ return WebInputEventResult::HandledSystem;

}

@@ -2295,13 +2333,13 @@ bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults&

RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());

if (selectionController().handleGestureLongPress(gestureEvent, result)) {

focusDocumentView();

- return true;

+ return WebInputEventResult::HandledSystem;

}

return sendContextMenuEventForGesture(targetedEvent);

}

-bool EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)

+WebInputEventResult EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)

{

#if !OS(ANDROID)

if (m_longTapShouldInvokeContextMenu) {

@@ -2309,7 +2347,7 @@ bool EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& ta

return sendContextMenuEventForGesture(targetedEvent);

}

#endif

- return false;

+ return WebInputEventResult::NotHandled;

}

bool EventHandler::handleScrollGestureOnResizer(Node* eventTarget, const PlatformGestureEvent& gestureEvent)

@@ -2339,25 +2377,22 @@ bool EventHandler::handleScrollGestureOnResizer(Node* eventTarget, const Platfor

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;

@@ -2372,18 +2407,18 @@ bool EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEve

}

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

@@ -2394,7 +2429,7 @@ bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureE

if (RuntimeEnabledFeatures::scrollCustomizationEnabled())

m_scrollGestureHandlingNode = m_frame->document()->documentElement();

else

- return false;

+ return WebInputEventResult::NotHandled;

}

ASSERT(m_scrollGestureHandlingNode);

@@ -2409,7 +2444,7 @@ bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureE

if (m_frame->isMainFrame())

m_frame->host()->topControls().scrollBegin();

}

- return true;

+ return WebInputEventResult::HandledSystem;

}

void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)

@@ -2441,26 +2476,27 @@ void EventHandler::handleOverscroll(const ScrollResult& scrollResult, const Floa

}

-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

@@ -2470,7 +2506,7 @@ bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gesture

// 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;

@@ -2515,12 +2551,12 @@ bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gesture

}

if (scrolled) {

setFrameWasScrolledByUser();

- return true;

+ return WebInputEventResult::HandledSystem;

}

if (RuntimeEnabledFeatures::scrollCustomizationEnabled())

- return false;

+ return WebInputEventResult::NotHandled;

// Try to scroll the frame view.

ScrollResult scrollResult = m_frame->applyScrollDelta(delta, false);

@@ -2529,10 +2565,10 @@ bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gesture

handleOverscroll(scrollResult, position, velocity);

if (scrollResult.didScroll()) {

setFrameWasScrolledByUser();

- return true;

+ return WebInputEventResult::HandledSystem;

}

- return false;

+ return WebInputEventResult::NotHandled;

}

void EventHandler::clearGestureScrollState()

@@ -2870,11 +2906,11 @@ void EventHandler::applyTouchAdjustment(PlatformGestureEvent* gestureEvent, HitT

}

-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;

@@ -2888,15 +2924,15 @@ bool EventHandler::sendContextMenuEvent(const PlatformMouseEvent& event, Node* o

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;

@@ -2960,7 +2996,7 @@ bool EventHandler::sendContextMenuEventForKey(Element* overrideTargetElement)

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();

@@ -3148,7 +3184,7 @@ bool EventHandler::handleAccessKey(const PlatformKeyboardEvent& evt)

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);

@@ -3163,7 +3199,7 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)

stopAutoscroll();

// If we were in panscroll mode, we swallow the key event

- return true;

+ return WebInputEventResult::HandledSuppressed;

}

#endif

@@ -3171,7 +3207,7 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)

// from pressing return in the location bar.

RefPtrWillBeRawPtr<Node> node = eventTargetNodeForDocument(m_frame->document());

if (!node)

- return false;

+ return WebInputEventResult::NotHandled;

UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);

@@ -3185,8 +3221,12 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)

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)

@@ -3197,36 +3237,36 @@ bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)

keydown->setTarget(node);

if (initialKeyEvent.type() == PlatformEvent::RawKeyDown) {

- node->dispatchEvent(keydown);

+ if (!node->dispatchEvent(keydown))

+ eventToEventResult(keydown, false);

// 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::HandledSystem;

+ return WebInputEventResult::NotHandled;

}

- node->dispatchEvent(keydown);

+ if (!node->dispatchEvent(keydown))

+ return eventToEventResult(keydown, false);

// 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 (changedFocusedFrame)

+ return WebInputEventResult::HandledSystem;

// 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);

- return keydownResult || keypress->defaultPrevented() || keypress->defaultHandled();

+ bool dispatchResult = node->dispatchEvent(keypress);

+ return eventToEventResult(keypress, dispatchResult);

}

static WebFocusType focusDirectionForKey(const AtomicString& keyIdentifier)

@@ -3344,7 +3384,7 @@ void EventHandler::updateDragStateAfterEditDragIfNeeded(Element* rootEditableEle

}

// 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());

}

@@ -3433,7 +3473,7 @@ bool EventHandler::tryStartDrag(const MouseEventWithHitTestResults& event)

// 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

@@ -3734,7 +3774,7 @@ public:

} // 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

@@ -3806,7 +3846,7 @@ bool EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,

m_touchSequenceUserGestureToken.clear();

}

- bool swallowedEvent = false;

+ WebInputEventResult eventResult = WebInputEventResult::NotHandled;

// Now iterate through the changedTouches list and m_targets within it, sending

// TouchEvents to the targets as required.

@@ -3822,15 +3862,15 @@ bool EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,

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());

+ eventResult = mergeEventResult(eventResult, eventToEventResult(touchEvent, dispatchResult));

}

- return swallowedEvent;

+ return eventResult;

}

-bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

+WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

{

TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");

@@ -3869,7 +3909,7 @@ bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

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.

@@ -3932,7 +3972,7 @@ bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

m_touchSequenceDocument.clear();

m_touchSequenceUserGestureToken.clear();

}

- return false;

+ return WebInputEventResult::NotHandled;

}

// Compute and store the common info used by both PointerEvent and TouchEvent.

@@ -4011,13 +4051,13 @@ bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

// 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 eventResult = 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() && eventResult == WebInputEventResult::NotHandled) {

m_inPointerCanceledState = true;

sendPointerCancels(touchInfos);

}

@@ -4025,7 +4065,7 @@ bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

m_inPointerCanceledState = false;

}

- return swallowedTouchEvent;

+ return eventResult;

}

void EventHandler::setLastKnownMousePosition(const PlatformMouseEvent& event)

@@ -4041,33 +4081,39 @@ void EventHandler::conditionallyEnableMouseEventForPointerTypeMouse(const Platfo

m_preventMouseEventForPointerTypeMouse = false;

}

-bool EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)

+WebInputEventResult EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)

{

selectionController().passMousePressEventToSubframe(mev);

- subframe->eventHandler().handleMousePressEvent(mev.event());

- return true;

+ WebInputEventResult result = subframe->eventHandler().handleMousePressEvent(mev.event());

+ if (result != WebInputEventResult::NotHandled)

+ return result;

+ return WebInputEventResult::HandledSystem;

}

-bool EventHandler::passMouseMoveEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe, HitTestResult* hoveredNode)

+WebInputEventResult EventHandler::passMouseMoveEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe, HitTestResult* hoveredNode)

{

if (m_mouseDownMayStartDrag)

- return false;

- subframe->eventHandler().handleMouseMoveOrLeaveEvent(mev.event(), hoveredNode);

- return true;

+ return WebInputEventResult::HandledSuppressed;

+ WebInputEventResult result = subframe->eventHandler().handleMouseMoveOrLeaveEvent(mev.event(), hoveredNode);

+ if (result != WebInputEventResult::NotHandled)

+ return result;

+ return WebInputEventResult::HandledSystem;

}

-bool EventHandler::passMouseReleaseEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)

+WebInputEventResult EventHandler::passMouseReleaseEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)

{

- subframe->eventHandler().handleMouseReleaseEvent(mev.event());

- return true;

+ WebInputEventResult result = subframe->eventHandler().handleMouseReleaseEvent(mev.event());

+ if (result != WebInputEventResult::NotHandled)

+ return result;

+ return WebInputEventResult::HandledSystem;

}

-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);

}