Send node transition events for touch events

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 92 matching lines @@
 namespace blink {
 
 namespace {
 
 bool hasTouchHandlers(const EventHandlerRegistry& registry)
 {
     return registry.hasEventHandlers(EventHandlerRegistry::TouchEventBlocking)
         || registry.hasEventHandlers(EventHandlerRegistry::TouchEventPassive);
 }
 
-WebInputEventResult mergeEventResult(WebInputEventResult responseA, WebInputEventResult responseB)
-{
-    // The ordering of the enumeration is specific. There are times that
-    // multiple events fire and we need to combine them into a single
-    // result code. The enumeration is based on the level of consumption that
-    // 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>(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();
-}
-
 const AtomicString& touchEventNameForTouchPointState(PlatformTouchPoint::State state)
 {
     switch (state) {
     case PlatformTouchPoint::TouchReleased:
         return EventTypeNames::touchend;
     case PlatformTouchPoint::TouchCancelled:
         return EventTypeNames::touchcancel;
     case PlatformTouchPoint::TouchPressed:
         return EventTypeNames::touchstart;
     case PlatformTouchPoint::TouchMoved:
         return EventTypeNames::touchmove;
     case PlatformTouchPoint::TouchStationary:
         // Fall through to default
     default:
         ASSERT_NOT_REACHED();
         return emptyAtom;
     }
 }
 
-const AtomicString& pointerEventNameForTouchPointState(PlatformTouchPoint::State state)
-{
-    switch (state) {
-    case PlatformTouchPoint::TouchReleased:
-        return EventTypeNames::pointerup;
-    case PlatformTouchPoint::TouchCancelled:
-        return EventTypeNames::pointercancel;
-    case PlatformTouchPoint::TouchPressed:
-        return EventTypeNames::pointerdown;
-    case PlatformTouchPoint::TouchMoved:
-        return EventTypeNames::pointermove;
-    case PlatformTouchPoint::TouchStationary:
-        // Fall through to default
-    default:
-        ASSERT_NOT_REACHED();
-        return emptyAtom;
-    }
-}
-
-const AtomicString& pointerEventNameForMouseEventName(const AtomicString& mouseEventName)
-{
-#define RETURN_CORRESPONDING_PE_NAME(eventSuffix) \
-    if (mouseEventName == EventTypeNames::mouse##eventSuffix) {\
-        return EventTypeNames::pointer##eventSuffix;\
-    }
-
-    RETURN_CORRESPONDING_PE_NAME(down);
-    RETURN_CORRESPONDING_PE_NAME(enter);
-    RETURN_CORRESPONDING_PE_NAME(leave);
-    RETURN_CORRESPONDING_PE_NAME(move);
-    RETURN_CORRESPONDING_PE_NAME(out);
-    RETURN_CORRESPONDING_PE_NAME(over);
-    RETURN_CORRESPONDING_PE_NAME(up);
-
-#undef RETURN_CORRESPONDING_PE_NAME
-
-    ASSERT_NOT_REACHED();
-    return emptyAtom;
-}
-
 } // namespace
 
 using namespace HTMLNames;
 
 // The link drag hysteresis is much larger than the others because there
 // needs to be enough space to cancel the link press without starting a link drag,
 // and because dragging links is rare.
 static const int LinkDragHysteresis = 40;
 static const int ImageDragHysteresis = 5;
 static const int TextDragHysteresis = 3;
@@ skipping 109 matching lines @@
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
     , m_resizeScrollableArea(nullptr)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_accumulatedRootOverscroll(FloatSize())
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_touchPressed(false)
-    , m_preventMouseEventForPointerTypeMouse(false)
     , m_inPointerCanceledState(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
 {
 }
 
@@ skipping 16 matching lines @@
     visitor->trace(m_dragTarget);
     visitor->trace(m_frameSetBeingResized);
     visitor->trace(m_previousWheelScrolledNode);
     visitor->trace(m_scrollbarHandlingScrollGesture);
     visitor->trace(m_targetForTouchID);
     visitor->trace(m_touchSequenceDocument);
     visitor->trace(m_scrollGestureHandlingNode);
     visitor->trace(m_previousGestureScrolledNode);
     visitor->trace(m_lastDeferredTapElement);
     visitor->trace(m_selectionController);
+    visitor->trace(m_pointerEventManager);
 #endif
 }
 
 DragState& EventHandler::dragState()
 {
     DEFINE_STATIC_LOCAL(Persistent<DragState>, state, (new DragState()));
     return *state;
 }
 
 void EventHandler::clear()
@@ skipping 21 matching lines @@
     m_capturingMouseEventsNode = nullptr;
     m_previousWheelScrolledNode = nullptr;
     m_targetForTouchID.clear();
     m_touchSequenceDocument.clear();
     m_touchSequenceUserGestureToken.clear();
     clearGestureScrollState();
     m_lastGestureScrollOverWidget = false;
     m_scrollbarHandlingScrollGesture = nullptr;
     m_touchPressed = false;
     m_pointerEventManager.clear();
-    m_preventMouseEventForPointerTypeMouse = false;
     m_inPointerCanceledState = false;
     m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
     m_longTapShouldInvokeContextMenu = false;
     m_dragStartPos = LayoutPoint();
     m_offsetFromResizeCorner = LayoutSize();
     m_mouseDown = PlatformMouseEvent();
 }
 
+WebInputEventResult EventHandler::mergeEventResult(
+    WebInputEventResult resultA, WebInputEventResult resultB)
+{
+    // The ordering of the enumeration is specific. There are times that
+    // multiple events fire and we need to combine them into a single
+    // result code. The enumeration is based on the level of consumption that
+    // 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)
+{
+    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;
+}
+
 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;
     }
 }
 
 WebInputEventResult EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
@@ skipping 703 matching lines @@
             return scrollableArea;
     }
 
     return nullptr;
 }
 
 WebInputEventResult EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
-    conditionallyEnableMouseEventForPointerTypeMouse(event);
+    m_pointerEventManager.conditionallyEnableMouseEventForPointerTypeMouse(
+        event.modifiers());
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
     HitTestResult hoveredNode = HitTestResult();
     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);
+    m_pointerEventManager.conditionallyEnableMouseEventForPointerTypeMouse(
+        event.modifiers());
 
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     handleMouseMoveOrLeaveEvent(event, 0, false, true);
 }
 
 WebInputEventResult EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode, bool onlyUpdateScrollbars, bool forceLeave)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->view());
 
@@ skipping 163 matching lines @@
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
     LocalFrame* subframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
     if (m_eventHandlerWillResetCapturingMouseEventsNode)
         m_capturingMouseEventsNode = nullptr;
     if (subframe)
         return passMouseReleaseEventToSubframe(mev, subframe);
 
     WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(EventTypeNames::mouseup, mev.innerNode(), m_clickCount, mouseEvent);
 
     // TODO(crbug/545647): This state should reset with pointercancel too.
-    m_preventMouseEventForPointerTypeMouse = false;
+    m_pointerEventManager.conditionallyEnableMouseEventForPointerTypeMouse(
+        PlatformEvent::NoModifiers);
 
     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
 
     WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
     if (m_clickCount > 0 && !contextMenuEvent && mev.innerNode() && m_clickNode && mev.innerNode()->canParticipateInFlatTree() && m_clickNode->canParticipateInFlatTree()) {
@@ skipping 265 matching lines @@
         // The mouse has moved between layers.
         if (ScrollableArea* scrollableAreaForNodeUnderMouse = associatedScrollableArea(layerForNodeUnderMouse))
             scrollableAreaForNodeUnderMouse->mouseEnteredContentArea();
     }
 
     if (lastNodeUnderMouse && lastNodeUnderMouse->document() != m_frame->document()) {
         lastNodeUnderMouse = nullptr;
         m_lastScrollbarUnderMouse = nullptr;
     }
 
-    if (lastNodeUnderMouse != m_nodeUnderMouse)
-        sendNodeTransitionEvents(lastNodeUnderMouse.get(), m_nodeUnderMouse.get(), mouseEvent);
-}
-
-WebInputEventResult EventHandler::dispatchPointerEvent(EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
-{
-    if (!RuntimeEnabledFeatures::pointerEventEnabled())
-        return WebInputEventResult::NotHandled;
-
-    bool dispatchResult = target->dispatchEvent(pointerEvent.get());
-    return eventToEventResult(pointerEvent, dispatchResult);
-}
-
-void EventHandler::sendNodeTransitionEvents(Node* exitedNode, Node* enteredNode,
-    const PlatformMouseEvent& mouseEvent)
-{
-    ASSERT(exitedNode != enteredNode);
-
-    // Dispatch pointerout/mouseout events
-    if (isNodeInDocument(exitedNode)) {
-        sendPointerAndMouseTransitionEvents(exitedNode, EventTypeNames::mouseout, mouseEvent, enteredNode, false);
-    }
-
-    // A note on mouseenter and mouseleave: These are non-bubbling events, and they are dispatched if there
-    // is a capturing event handler on an ancestor or a normal event handler on the element itself. This special
-    // handling is necessary to avoid O(n^2) capturing event handler checks.
-    //
-    //   Note, however, that this optimization can possibly cause some unanswered/missing/redundant mouseenter or
-    // mouseleave events in certain contrived eventhandling scenarios, e.g., when:
-    // - the mouseleave handler for a node sets the only capturing-mouseleave-listener in its ancestor, or
-    // - DOM mods in any mouseenter/mouseleave handler changes the common ancestor of exited & entered nodes, etc.
-    // We think the spec specifies a "frozen" state to avoid such corner cases (check the discussion on "candidate event
-    // listeners" at http://www.w3.org/TR/uievents), but our code below preserves one such behavior from past only to
-    // match Firefox and IE behavior.
-    //
-    // TODO(mustaq): Confirm spec conformance, double-check with other browsers.
-
-    // Create lists of all exited/entered ancestors, locate the common ancestor & capturing listeners.
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> exitedAncestors;
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> enteredAncestors;
-    if (isNodeInDocument(exitedNode)) {
-        exitedNode->updateDistribution();
-        for (Node* node = exitedNode; node; node = FlatTreeTraversal::parent(*node)) {
-            exitedAncestors.append(node);
-        }
-    }
-    if (isNodeInDocument(enteredNode)) {
-        enteredNode->updateDistribution();
-        for (Node* node = enteredNode; node; node = FlatTreeTraversal::parent(*node)) {
-            enteredAncestors.append(node);
-        }
-    }
-
-    size_t numExitedAncestors = exitedAncestors.size();
-    size_t numEnteredAncestors = enteredAncestors.size();
-
-    size_t exitedAncestorIndex = numExitedAncestors;
-    size_t enteredAncestorIndex = numEnteredAncestors;
-    for (size_t j = 0; j < numExitedAncestors; j++) {
-        for (size_t i = 0; i < numEnteredAncestors; i++) {
-            if (exitedAncestors[j] == enteredAncestors[i]) {
-                exitedAncestorIndex = j;
-                enteredAncestorIndex = i;
-                break;
-            }
-        }
-        if (exitedAncestorIndex < numExitedAncestors)
-            break;
-    }
-
-    bool exitedNodeHasCapturingAncestor = false;
-    for (size_t j = 0; j < numExitedAncestors; j++) {
-        if (exitedAncestors[j]->hasCapturingEventListeners(EventTypeNames::mouseleave)
-            || (RuntimeEnabledFeatures::pointerEventEnabled()
-            && exitedAncestors[j]->hasCapturingEventListeners(EventTypeNames::pointerleave)))
-            exitedNodeHasCapturingAncestor = true;
-    }
-
-    // Dispatch pointerleave/mouseleave events, in child-to-parent order.
-    for (size_t j = 0; j < exitedAncestorIndex; j++) {
-        sendPointerAndMouseTransitionEvents(exitedAncestors[j].get(), EventTypeNames::mouseleave, mouseEvent, enteredNode, !exitedNodeHasCapturingAncestor);
-    }
-
-    // Dispatch pointerover/mouseover.
-    if (isNodeInDocument(enteredNode)) {
-        sendPointerAndMouseTransitionEvents(enteredNode, EventTypeNames::mouseover, mouseEvent, exitedNode, false);
-    }
-
-    // Defer locating capturing pointeenter/mouseenter listener until /after/ dispatching the leave events because
-    // the leave handlers might set a capturing enter handler.
-    bool enteredNodeHasCapturingAncestor = false;
-    for (size_t i = 0; i < numEnteredAncestors; i++) {
-        if (enteredAncestors[i]->hasCapturingEventListeners(EventTypeNames::mouseenter)
-            || (RuntimeEnabledFeatures::pointerEventEnabled()
-            && enteredAncestors[i]->hasCapturingEventListeners(EventTypeNames::pointerenter)))
-            enteredNodeHasCapturingAncestor = true;
-    }
-
-    // Dispatch pointerenter/mouseenter events, in parent-to-child order.
-    for (size_t i = enteredAncestorIndex; i > 0; i--) {
-        sendPointerAndMouseTransitionEvents(enteredAncestors[i-1].get(), EventTypeNames::mouseenter, mouseEvent, exitedNode, !enteredNodeHasCapturingAncestor);
-    }
+    m_pointerEventManager.sendNodeTransitionEvents(lastNodeUnderMouse,
+        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);
 }
 
-EventTarget* EventHandler::getEffectiveTargetForPointerEvent(
-    EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
-{
-    EventTarget* capturingNode = m_pointerEventManager.getCapturingNode(pointerEvent.get());
-    if (capturingNode)
-        target = capturingNode;
-    return target;
-}
-
-void EventHandler::sendPointerAndMouseTransitionEvents(Node* target, const AtomicString& mouseEventType,
-    const PlatformMouseEvent& mouseEvent, Node* relatedTarget, bool checkForListener)
-{
-    ASSERT(mouseEventType == EventTypeNames::mouseenter
-        || mouseEventType == EventTypeNames::mouseleave
-        || mouseEventType == EventTypeNames::mouseover
-        || mouseEventType == EventTypeNames::mouseout);
-
-    AtomicString pointerEventType = pointerEventNameForMouseEventName(mouseEventType);
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
-        mouseEvent, relatedTarget, m_frame->document()->domWindow());
-
-    // Suppress these events if the target is not the capturing element
-    if (target != getEffectiveTargetForPointerEvent(target, pointerEvent))
-        return;
-
-    if (!checkForListener || target->hasEventListeners(pointerEventType))
-        dispatchPointerEvent(target, pointerEvent);
-
-    if (!checkForListener || target->hasEventListeners(mouseEventType))
-        target->dispatchMouseEvent(mouseEvent, mouseEventType, 0, relatedTarget);
-}
-
 // 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;
 
-    AtomicString pointerEventType = pointerEventNameForMouseEventName(mouseEventType);
-    unsigned short pointerButtonsPressed = MouseEvent::platformModifiersToButtons(mouseEvent.modifiers());
-
-    // Make sure chorded buttons fire pointermove instead of pointerup/pointerdown.
-    if ((pointerEventType == EventTypeNames::pointerdown && (pointerButtonsPressed & ~MouseEvent::buttonToButtons(mouseEvent.button())) != 0)
-        || (pointerEventType == EventTypeNames::pointerup && pointerButtonsPressed != 0))
-        pointerEventType = EventTypeNames::pointermove;
-
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
-        mouseEvent, nullptr, m_frame->document()->domWindow());
-
-    EventTarget* target = getEffectiveTargetForPointerEvent(m_nodeUnderMouse.get(), pointerEvent);
-    WebInputEventResult result = dispatchPointerEvent(target, pointerEvent);
-
-    if (result != WebInputEventResult::NotHandled && pointerEventType == EventTypeNames::pointerdown)
-        m_preventMouseEventForPointerTypeMouse = true;
-
-    if (!m_preventMouseEventForPointerTypeMouse) {
-        RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
-        bool dispatchResult = target->dispatchEvent(event);
-        result = mergeEventResult(result, eventToEventResult(event, dispatchResult));
-    }
+    WebInputEventResult result = 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 1894 matching lines @@
 void EventHandler::dispatchPointerEvents(const PlatformTouchEvent& event,
     WillBeHeapVector<TouchInfo>& touchInfos)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     // Iterate through the touch points, sending PointerEvents to the targets as required.
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& touchPoint = touchInfo.point;
-        const PlatformTouchPoint::State pointState = touchPoint.state();
 
 
-        if (pointState == PlatformTouchPoint::TouchStationary || !touchInfo.knownTarget)
+        if (touchPoint.state() == PlatformTouchPoint::TouchStationary
+            || !touchInfo.knownTarget)
             continue;
 
-        bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
-            || pointState == PlatformTouchPoint::TouchCancelled;
-
-        RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(
-            pointerEventNameForTouchPointState(pointState),
-            touchPoint, event.modifiers(),
+        WebInputEventResult result =
+            m_pointerEventManager.sendTouchPointerEvent(
+            touchInfo.touchTarget, touchPoint, event.modifiers(),
             touchInfo.adjustedRadius.width(), touchInfo.adjustedRadius.height(),
             touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y());
-
-        // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
-        touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
-
-        touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
-
-        // Remove the released/cancelled id at the end to correctly determine primary id above.
-        if (pointerReleasedOrCancelled)
-            m_pointerEventManager.remove(pointerEvent);
+        touchInfo.consumed = result != WebInputEventResult::NotHandled;
     }
 }
 
 void EventHandler::sendPointerCancels(WillBeHeapVector<TouchInfo>& touchInfos)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const PlatformTouchPoint::State pointState = point.state();
 
         if (pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled)
             continue;
 
-        RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.createPointerCancel(point);
-
-        // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
-        touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
-
-        m_pointerEventManager.remove(pointerEvent);
+        m_pointerEventManager.sendTouchCancelPointerEvent(
+            touchInfo.touchTarget,
+            point);
     }
 }
 
 namespace {
 
 // Defining this class type local to dispatchTouchEvents() and annotating
 // it with STACK_ALLOCATED(), runs into MSVC(VS 2013)'s C4822 warning
 // that the local class doesn't provide a local definition for 'operator new'.
 // Which it intentionally doesn't and shouldn't.
 //
@@ skipping 307 matching lines @@
     return eventResult;
 }
 
 void EventHandler::setLastKnownMousePosition(const PlatformMouseEvent& event)
 {
     m_mousePositionIsUnknown = false;
     m_lastKnownMousePosition = event.position();
     m_lastKnownMouseGlobalPosition = event.globalPosition();
 }
 
-void EventHandler::conditionallyEnableMouseEventForPointerTypeMouse(const PlatformMouseEvent& event)
-{
-    if (event.button() == NoButton)
-        m_preventMouseEventForPointerTypeMouse = false;
-}
-
 WebInputEventResult EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)
 {
     selectionController().passMousePressEventToSubframe(mev);
     WebInputEventResult result = subframe->eventHandler().handleMousePressEvent(mev.event());
     if (result != WebInputEventResult::NotHandled)
         return result;
     return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult EventHandler::passMouseMoveEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe, HitTestResult* hoveredNode)
@@ skipping 40 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