Create MouseEventManager and EventHandlingUtil

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/input/PointerEventManager.h"
 
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandler.h"
+#include "core/input/EventHandlingUtil.h"
+#include "core/input/MouseEventManager.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/PlatformTouchEvent.h"
 
 namespace blink {
 
 namespace {
 
 size_t toPointerTypeIndex(WebPointerProperties::PointerType t) { return static_cast<size_t>(t); }
@@ skipping 15 matching lines @@
         NOTREACHED();
         return emptyAtom;
     }
 }
 
 bool isInDocument(EventTarget* n)
 {
     return n && n->toNode() && n->toNode()->isConnected();
 }
 
-WebInputEventResult dispatchMouseEvent(
-    EventTarget* target,
-    const AtomicString& mouseEventType,
-    const PlatformMouseEvent& mouseEvent,
-    EventTarget* relatedTarget,
-    int detail = 0,
-    bool checkForListener = false)
-{
-    if (target && target->toNode()
-        && (!checkForListener || target->hasEventListeners(mouseEventType))) {
-        Node* targetNode = target->toNode();
-        MouseEvent* event = MouseEvent::create(mouseEventType,
-            targetNode->document().domWindow(), mouseEvent, detail,
-            relatedTarget ? relatedTarget->toNode() : nullptr);
-        DispatchEventResult dispatchResult = target->dispatchEvent(event);
-        return EventHandler::toWebInputEventResult(dispatchResult);
-    }
-    return WebInputEventResult::NotHandled;
-}
-
-PlatformMouseEvent mouseEventWithRegion(Node* node, const PlatformMouseEvent& mouseEvent)
-{
-    if (!node->isElementNode())
-        return mouseEvent;
-
-    Element* element = toElement(node);
-    if (!element->isInCanvasSubtree())
-        return mouseEvent;
-
-    HTMLCanvasElement* canvas = Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*element);
-    // In this case, the event target is canvas and mouse rerouting doesn't happen.
-    if (canvas == element)
-        return mouseEvent;
-    String region = canvas->getIdFromControl(element);
-    PlatformMouseEvent newMouseEvent = mouseEvent;
-    newMouseEvent.setRegion(region);
-    return newMouseEvent;
-}
-
-void buildAncestorChain(
-    EventTarget* target,
-    HeapVector<Member<Node>, 20>* ancestors)
-{
-    if (!isInDocument(target))
-        return;
-    Node* targetNode = target->toNode();
-    DCHECK(targetNode);
-    targetNode->updateDistribution();
-    // Index 0 element in the ancestors arrays will be the corresponding
-    // target. So the root of their document will be their last element.
-    for (Node* node = targetNode; node; node = FlatTreeTraversal::parent(*node))
-        ancestors->append(node);
-}
-
-void buildAncestorChainsAndFindCommonAncestors(
-    EventTarget* exitedTarget, EventTarget* enteredTarget,
-    HeapVector<Member<Node>, 20>* exitedAncestorsOut,
-    HeapVector<Member<Node>, 20>* enteredAncestorsOut,
-    size_t* exitedAncestorsCommonParentIndexOut,
-    size_t* enteredAncestorsCommonParentIndexOut)
-{
-    DCHECK(exitedAncestorsOut);
-    DCHECK(enteredAncestorsOut);
-    DCHECK(exitedAncestorsCommonParentIndexOut);
-    DCHECK(enteredAncestorsCommonParentIndexOut);
-
-    buildAncestorChain(exitedTarget, exitedAncestorsOut);
-    buildAncestorChain(enteredTarget, enteredAncestorsOut);
-
-    *exitedAncestorsCommonParentIndexOut = exitedAncestorsOut->size();
-    *enteredAncestorsCommonParentIndexOut = enteredAncestorsOut->size();
-    while (*exitedAncestorsCommonParentIndexOut > 0
-        && *enteredAncestorsCommonParentIndexOut > 0) {
-        if ((*exitedAncestorsOut)[(*exitedAncestorsCommonParentIndexOut)-1]
-            != (*enteredAncestorsOut)[(*enteredAncestorsCommonParentIndexOut)-1])
-            break;
-        (*exitedAncestorsCommonParentIndexOut)--;
-        (*enteredAncestorsCommonParentIndexOut)--;
-    }
-}
-
 } // namespace
 
+PointerEventManager::PointerEventBoundaryEventDispatcher::PointerEventBoundaryEventDispatcher(
+    PointerEventManager* pointerEventManager,
+    PointerEvent* pointerEvent)
+    : m_pointerEventManager(pointerEventManager)
+    , m_pointerEvent(pointerEvent)
+{
+}
+
+void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatchOut(
+    EventTarget* target, EventTarget* relatedTarget)
+{
+    dispatch(target, relatedTarget, EventTypeNames::pointerout, false);
+}
+
+void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatchOver(
+    EventTarget* target, EventTarget* relatedTarget)
+{
+    dispatch(target, relatedTarget, EventTypeNames::pointerover, false);
+}
+
+void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatchLeave(
+    EventTarget* target, EventTarget* relatedTarget, bool checkForListener)
+{
+    dispatch(target, relatedTarget, EventTypeNames::pointerleave, checkForListener);
+}
+
+void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatchEnter(
+    EventTarget* target, EventTarget* relatedTarget, bool checkForListener)
+{
+    dispatch(target, relatedTarget, EventTypeNames::pointerenter, checkForListener);
+}
+
+void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatch(
+    EventTarget* target, EventTarget* relatedTarget, const AtomicString& type,
+    bool checkForListener)
+{
+    m_pointerEventManager->dispatchPointerEvent(target,
+        m_pointerEventManager->m_pointerEventFactory.createPointerBoundaryEvent(
+            m_pointerEvent, type, relatedTarget),
+        checkForListener);
+}
+
 WebInputEventResult PointerEventManager::dispatchPointerEvent(
     EventTarget* target,
     PointerEvent* pointerEvent,
     bool checkForListener)
 {
     if (!target)
         return WebInputEventResult::NotHandled;
 
     // Set whether node under pointer has received pointerover or not.
     const int pointerId = pointerEvent->pointerId();
@@ skipping 11 matching lines @@
     }
 
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
     if (!checkForListener || target->hasEventListeners(eventType)) {
         UseCounter::count(m_frame->document(), UseCounter::PointerEventDispatch);
         if (eventType == EventTypeNames::pointerdown)
             UseCounter::count(m_frame->document(), UseCounter::PointerEventDispatchPointerDown);
 
         DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
-        return EventHandler::toWebInputEventResult(dispatchResult);
+        return EventHandlingUtil::toWebInputEventResult(dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
         return capturingTarget;
     return target;
@@ skipping 23 matching lines @@
             mouseEvent.pointerProperties().pointerType)] = false;
     }
 
     processCaptureAndPositionOfPointerEvent(dummyPointerEvent, enteredNode,
         exitedNode, mouseEvent, true, isFrameBoundaryTransition);
 }
 
 void PointerEventManager::sendBoundaryEvents(
     EventTarget* exitedTarget,
     EventTarget* enteredTarget,
-    PointerEvent* pointerEvent,
-    const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
+    PointerEvent* pointerEvent)
 {
-    if (exitedTarget == enteredTarget)
-        return;
-
-    // Dispatch pointerout/mouseout events
-    if (isInDocument(exitedTarget)) {
-        if (!sendMouseEvent) {
-            dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerBoundaryEvent(
-                pointerEvent, EventTypeNames::pointerout, enteredTarget));
-        } else {
-            dispatchMouseEvent(exitedTarget,
-                EventTypeNames::mouseout,
-                mouseEventWithRegion(exitedTarget->toNode(), mouseEvent),
-                enteredTarget);
-        }
-    }
-
-    // Create lists of all exited/entered ancestors, locate the common ancestor
-    // Based on httparchive, in more than 97% cases the depth of DOM is less
-    // than 20.
-    HeapVector<Member<Node>, 20> exitedAncestors;
-    HeapVector<Member<Node>, 20> enteredAncestors;
-    size_t exitedAncestorsCommonParentIndex = 0;
-    size_t enteredAncestorsCommonParentIndex = 0;
-
-    // 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.
-
-    buildAncestorChainsAndFindCommonAncestors(
-        exitedTarget, enteredTarget,
-        &exitedAncestors, &enteredAncestors,
-        &exitedAncestorsCommonParentIndex, &enteredAncestorsCommonParentIndex);
-
-    bool exitedNodeHasCapturingAncestor = false;
-    for (size_t j = 0; j < exitedAncestors.size(); 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 < exitedAncestorsCommonParentIndex; j++) {
-        if (!sendMouseEvent) {
-            dispatchPointerEvent(exitedAncestors[j].get(),
-                m_pointerEventFactory.createPointerBoundaryEvent(
-                    pointerEvent, EventTypeNames::pointerleave, enteredTarget),
-                !exitedNodeHasCapturingAncestor);
-        } else {
-            dispatchMouseEvent(exitedAncestors[j].get(),
-                EventTypeNames::mouseleave,
-                mouseEventWithRegion(exitedTarget->toNode(), mouseEvent),
-                enteredTarget, 0, !exitedNodeHasCapturingAncestor);
-        }
-    }
-
-    // Dispatch pointerover/mouseover.
-    if (isInDocument(enteredTarget)) {
-        if (!sendMouseEvent) {
-            dispatchPointerEvent(enteredTarget, m_pointerEventFactory.createPointerBoundaryEvent(
-                pointerEvent, EventTypeNames::pointerover, exitedTarget));
-        } else {
-            dispatchMouseEvent(enteredTarget,
-                EventTypeNames::mouseover, mouseEvent, exitedTarget);
-        }
-    }
-
-    // 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 < enteredAncestors.size(); 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 = enteredAncestorsCommonParentIndex; i > 0; i--) {
-        if (!sendMouseEvent) {
-            dispatchPointerEvent(enteredAncestors[i-1].get(),
-                m_pointerEventFactory.createPointerBoundaryEvent(
-                    pointerEvent, EventTypeNames::pointerenter, exitedTarget),
-                !enteredNodeHasCapturingAncestor);
-        } else {
-            dispatchMouseEvent(enteredAncestors[i-1].get(),
-                EventTypeNames::mouseenter, mouseEvent, exitedTarget,
-                0, !enteredNodeHasCapturingAncestor);
-        }
-    }
+    PointerEventBoundaryEventDispatcher boundaryEventDispatcher(this, pointerEvent);

[mustaq, 2016/08/23 15:20:48]

Creating a new instance of boundaryEventDispatcher on every dispatch seems a bit
overkill. Move the pointer/mouse event parameter from constructors to dispatcher
methods? The number of parameters is not too many to be a concern here.

May be a templated BoundaryEventDispatcher is better?

[Navid Zolghadr, 2016/08/24 16:07:28]

I don't know how we should do this with a templated version. Note that if I add
tempate to the BoundaryEventDispatcher that will be a new class. So I cannot
expect any particular class in the function parameter.

I didn't quite understand the comment about how to solve the "creating new
instance every time" problem.

I'm going to make the PointerEventManager and MouseEventManager subclasses of
BoundaryEventDispatcher and hopefully that makes the code cleaner overall. I'll
post a patch for it.

[Navid Zolghadr, 2016/08/30 18:46:26]

I was looking into possibilities of creating this object in the constructor and
just keep the instance in the class. Here is what should happen in that case.
Before call to sendBoundaryEvents I should set some parameters in that object
(i.e. in this case the pointer event that is used to created the boundary events
as it is different every time). I also need to reset those parameters to null at
the end of this function to make sure there is no ref to those parameters by
mistake. So this reminds me of the pattern of RAII which needs this object
creation. I believe creating the object is cleaner but I agree that would cause
a little more memory use use every time.

+    EventHandlingUtil::sendBoundaryEvents(exitedTarget, enteredTarget, &boundaryEventDispatcher);
 }
 
 void PointerEventManager::setNodeUnderPointer(
     PointerEvent* pointerEvent,
     EventTarget* target)
 {
     if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
         EventTargetAttributes node = m_nodeUnderPointer.get(
             pointerEvent->pointerId());
         if (!target) {
@@ skipping 249 matching lines @@
         // Event path could be null if pointer event is not dispatched and
         // that happens for example when pointer event feature is not enabled.
         if (!isInDocument(mouseTarget) && pointerEvent->hasEventPath()) {
             for (size_t i = 0; i < pointerEvent->eventPath().size(); i++) {
                 if (isInDocument(pointerEvent->eventPath()[i].node())) {
                     mouseTarget = pointerEvent->eventPath()[i].node();
                     break;
                 }
             }
         }
-        result = EventHandler::mergeEventResult(result,
-            dispatchMouseEvent(mouseTarget, mouseEventType, mouseEvent,
-            nullptr, clickCount));
+        result = EventHandlingUtil::mergeEventResult(result,
+            m_mouseEventManager->dispatchMouseEvent(mouseTarget, mouseEventType, mouseEvent,
+                nullptr, clickCount));
     }
 
     if (pointerEvent->type() == EventTypeNames::pointerup
         || pointerEvent->type() == EventTypeNames::pointercancel) {
 
         releasePointerCapture(pointerEvent->pointerId());
         // Send got/lostpointercapture rightaway if necessary.
         processPendingPointerCapture(pointerEvent);
 
         if (pointerEvent->isPrimary()) {
             m_preventMouseEventForPointerType[toPointerTypeIndex(
                 mouseEvent.pointerProperties().pointerType)] = false;
         }
     }
 
     return result;
 }
 
-PointerEventManager::PointerEventManager(LocalFrame* frame)
-: m_frame(frame)
-, m_touchEventManager(frame)
+PointerEventManager::PointerEventManager(LocalFrame* frame,
+    MouseEventManager* mouseEventManager)
+    : m_frame(frame)
+    , m_touchEventManager(frame)
+    , m_mouseEventManager(mouseEventManager)
 {
     clear();
 }
 
 PointerEventManager::~PointerEventManager()
 {
 }
 
 void PointerEventManager::clear()
 {
@@ skipping 38 matching lines @@
         processPendingPointerCapture(pointerEvent);
 
         PointerCapturingMap::const_iterator it = m_pointerCaptureTarget.find(pointerEvent->pointerId());
         if (EventTarget* pointercaptureTarget = (it != m_pointerCaptureTarget.end()) ? it->value : nullptr)
             hitTestTarget = pointercaptureTarget;
 
         setNodeUnderPointer(pointerEvent, hitTestTarget);
     }
     if (sendMouseEvent) {
         // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
-        sendBoundaryEvents(lastNodeUnderMouse, hitTestTarget,
-            pointerEvent, mouseEvent, true);
+        m_mouseEventManager->sendBoundaryEvents(lastNodeUnderMouse,
+            hitTestTarget, mouseEvent);
     }
     return hitTestTarget;
 }
 
 void PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent)
 {
     EventTarget* pointerCaptureTarget;
     EventTarget* pendingPointerCaptureTarget;
     const int pointerId = pointerEvent->pointerId();
@@ skipping 132 matching lines @@
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink