Enumerate the return value of dispatchEvent so it is clear.

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 349 matching lines @@
     // is most significant. The enumeration is ordered with smaller specified
     // numbers first. Examples of merged results are:
     // (HandledApplication, HandledSystem) -> HandledSystem
     // (NotHandled, HandledApplication) -> HandledApplication
     static_assert(static_cast<int>(WebInputEventResult::NotHandled) == 0, "WebInputEventResult not ordered");
     static_assert(static_cast<int>(WebInputEventResult::HandledSuppressed) < static_cast<int>(WebInputEventResult::HandledApplication), "WebInputEventResult not ordered");
     static_assert(static_cast<int>(WebInputEventResult::HandledApplication) < static_cast<int>(WebInputEventResult::HandledSystem), "WebInputEventResult not ordered");
     return static_cast<WebInputEventResult>(max(static_cast<int>(resultA), static_cast<int>(resultB)));
 }
 
-WebInputEventResult EventHandler::eventToEventResult(
-    PassRefPtrWillBeRawPtr<Event> event, bool result)
+WebInputEventResult EventHandler::eventDispatchResultToWebInputEventResult(
+    EventTarget::DispatchEventResult result)
 {
-    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 (!result)
-        return WebInputEventResult::HandledSuppressed;
-    return WebInputEventResult::NotHandled;
+    static_assert(static_cast<int>(WebInputEventResult::NotHandled) == static_cast<int>(EventTarget::DispatchEventResult::NotHandled), "WebInputEventResult does not match EventTarget::DispatchEventResult");
+    static_assert(static_cast<int>(WebInputEventResult::HandledApplication) == static_cast<int>(EventTarget::DispatchEventResult::HandledApplication), "WebInput EventResult does not match EventTarget::DispatchEventResult");
+    static_assert(static_cast<int>(WebInputEventResult::HandledSystem) == static_cast<int>(EventTarget::DispatchEventResult::HandledSystem), "WebInputEventResult does not match EventTarget::DispatchEventResult");
+    static_assert(static_cast<int>(WebInputEventResult::HandledSuppressed) == static_cast<int>(EventTarget::DispatchEventResult::HandledSuppressed), "WebInputEventResult does not match EventTarget::DispatchEventResult");
+    return static_cast<WebInputEventResult>(static_cast<int>(result));
 }
 
 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;
     }
 }
@@ skipping 945 matching lines @@
         // 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.
-            if (clickTargetNode->dispatchMouseEvent(mouseEvent,
-                EventTypeNames::click, m_clickCount)) {
-                clickEventResult = WebInputEventResult::HandledApplication;
-            }
+            clickEventResult = eventDispatchResultToWebInputEventResult(clickTargetNode->dispatchMouseEvent(mouseEvent,
+                EventTypeNames::click, m_clickCount));
         }
     }
 
     if (m_resizeScrollableArea) {
         m_resizeScrollableArea->setInResizeMode(false);
         m_resizeScrollableArea = nullptr;
     }
 
     if (eventResult == WebInputEventResult::NotHandled)
         eventResult = handleMouseReleaseEvent(mev);
@@ skipping 11 matching lines @@
     if (!view)
         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, event.timestamp(), dataTransfer, event.syntheticEventType());
 
-    bool dispatchResult = dragTarget->dispatchEvent(me.get());
-    return eventToEventResult(me, dispatchResult);
+    return eventDispatchResultToWebInputEventResult(dragTarget->dispatchEvent(me.get()));
 }
 
 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 216 matching lines @@
         m_nodeUnderMouse, mouseEvent, m_frame->document()->domWindow());
 }
 
 WebInputEventResult EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     updateMouseEventTargetNode(targetNode, mouseEvent);
     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);
+    return eventDispatchResultToWebInputEventResult(m_nodeUnderMouse->dispatchEvent(event));
 }
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
 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 WebInputEventResult::NotHandled;
 
-    WebInputEventResult result = m_pointerEventManager.sendMousePointerEvent(
+    return m_pointerEventManager.sendMousePointerEvent(
         m_nodeUnderMouse, mouseEventType, clickCount, mouseEvent, nullptr,
         m_frame->document()->domWindow());
-
-    return result;
 }
 
 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 WebInputEventResult::NotHandled;
     }
 
@@ skipping 147 matching lines @@
             if (Widget* widget = toLayoutPart(target)->widget()) {
                 WebInputEventResult result = passWheelEventToWidget(event, *widget);
                 if (result != WebInputEventResult::NotHandled) {
                     setFrameWasScrolledByUser();
                     return result;
                 }
             }
         }
 
         RefPtrWillBeRawPtr<Event> domEvent = WheelEvent::create(event, node->document().domWindow());
-        if (!node->dispatchEvent(domEvent)) {
+        EventTarget::DispatchEventResult domEventResult = node->dispatchEvent(domEvent);
+        if (domEventResult != EventTarget::DispatchEventResult::NotHandled) {
             setFrameWasScrolledByUser();
-            return eventToEventResult(domEvent, false);
+            return eventDispatchResultToWebInputEventResult(domEventResult);
         }
     }
 
     // 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 WebInputEventResult::NotHandled;
 
     // Wheel events which do not scroll are used to trigger zooming.
@@ skipping 109 matching lines @@
     if (scrollbar) {
         bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
         if (gestureEvent.type() == PlatformEvent::GestureTapDown && eventSwallowed)
             m_scrollbarHandlingScrollGesture = scrollbar;
         if (eventSwallowed)
             return WebInputEventResult::HandledSuppressed;
     }
 
     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);
+        if (gestureDomEvent.get()) {
+            EventTarget::DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);

[Rick Byers, 2016/02/22 15:16:14]

There used to be an ASSERT in the GestureEventDispatchMediator that enforced
that preventDefault wasn't supported for gesture events.  Can you preserve that
coverage by adding the ASSERT here (and any below)?

[dtapuska, 2016/02/23 19:14:40]

Done; I rolled this into a method.

+            if (gestureDomEventResult != EventTarget::DispatchEventResult::NotHandled)
+                return eventDispatchResultToWebInputEventResult(gestureDomEventResult);
+        }
     }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureTap:
         return handleGestureTap(targetedEvent);
     case PlatformEvent::GestureShowPress:
         return handleGestureShowPress();
     case PlatformEvent::GestureLongPress:
         return handleGestureLongPress(targetedEvent);
     case PlatformEvent::GestureLongTap:
@@ skipping 55 matching lines @@
         }
         if (eventSwallowed)
             return WebInputEventResult::HandledSuppressed;
     }
 
     if (eventTarget) {
         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);
+        if (gestureDomEvent.get()) {
+            EventTarget::DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
+            if (gestureDomEventResult != EventTarget::DispatchEventResult::NotHandled)
+                return eventDispatchResultToWebInputEventResult(gestureDomEventResult);
+        }
     }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureScrollBegin:
         return handleGestureScrollBegin(gestureEvent);
     case PlatformEvent::GestureScrollUpdate:
         return handleGestureScrollUpdate(gestureEvent);
     case PlatformEvent::GestureScrollEnd:
         return handleGestureScrollEnd(gestureEvent);
     case PlatformEvent::GestureFlingStart:
@@ skipping 1051 matching lines @@
     // 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) {
         RefPtrWillBeRawPtr<KeyboardEvent> domEvent = KeyboardEvent::create(initialKeyEvent, m_frame->document()->domWindow());
 
-        bool dispatchResult = node->dispatchEvent(domEvent);
-        return eventToEventResult(domEvent, dispatchResult);
+        return eventDispatchResultToWebInputEventResult(node->dispatchEvent(domEvent));
     }
 
     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) {
-        if (!node->dispatchEvent(keydown))
-            return 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();
-        if (changedFocusedFrame)
-            return WebInputEventResult::HandledSystem;
-        return WebInputEventResult::NotHandled;
-    }
-
-    if (!node->dispatchEvent(keydown))
-        return eventToEventResult(keydown, false);
+    EventTarget::DispatchEventResult dispatchResult = node->dispatchEvent(keydown);
+    if (dispatchResult != EventTarget::DispatchEventResult::NotHandled)
+        return eventDispatchResultToWebInputEventResult(dispatchResult);
     // If frame changed as a result of keydown dispatch, then return early to avoid sending a subsequent keypress message to the new frame.
     bool changedFocusedFrame = m_frame->page() && m_frame != m_frame->page()->focusController().focusedOrMainFrame();
     if (changedFocusedFrame)
         return WebInputEventResult::HandledSystem;
 
+    if (initialKeyEvent.type() == PlatformEvent::RawKeyDown)
+        return WebInputEventResult::NotHandled;
+
     // Focus may have changed during keydown handling, so refetch node.
     // But if we are dispatching a fake backward compatibility keypress, then we pretend that the keypress happened on the original node.
     node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
         return WebInputEventResult::NotHandled;
 
     PlatformKeyboardEvent keyPressEvent = initialKeyEvent;
     keyPressEvent.disambiguateKeyDownEvent(PlatformEvent::Char);
     if (keyPressEvent.text().isEmpty())
         return WebInputEventResult::NotHandled;
     RefPtrWillBeRawPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
     keypress->setTarget(node);
-    bool dispatchResult = node->dispatchEvent(keypress);
-    return eventToEventResult(keypress, dispatchResult);
+    return eventDispatchResultToWebInputEventResult(node->dispatchEvent(keypress));
 }
 
 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 553 matching lines @@
             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());
 
-            bool dispatchResult = touchEventTarget->dispatchEvent(touchEvent.get());
-            eventResult = mergeEventResult(eventResult, eventToEventResult(touchEvent, dispatchResult));
+            eventResult = mergeEventResult(eventResult, eventDispatchResultToWebInputEventResult(touchEventTarget->dispatchEvent(touchEvent.get())));
         }
     }
 
     return eventResult;
 }
 
 WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
@@ skipping 251 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink