Send node transition events for touch events

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

 // Copyright 2015 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/events/PointerEventManager.h"
+#include "core/dom/shadow/ComposedTreeTraversal.h"
 
 namespace blink {
 
 namespace {
 
 inline int toInt(WebPointerProperties::PointerType t) { return static_cast<int>(t); }
 
 const char* pointerTypeNameForWebPointPointerType(WebPointerProperties::PointerType type)
 {
     switch (type) {
     case WebPointerProperties::PointerType::Unknown:
         return "";
     case WebPointerProperties::PointerType::Touch:
         return "touch";
     case WebPointerProperties::PointerType::Pen:
         return "pen";
     case WebPointerProperties::PointerType::Mouse:
         return "mouse";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
+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;
+    }
+}
+
+bool isInDocument(EventTarget *n)
+{
+    return n && n->toNode() && n->toNode()->inDocument();
+}
+
+void sendPointerEventToTarget(EventTarget *target,
+    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent)
+{
+    if (isInDocument(target))
+        target->dispatchEvent(pointerevent);
+}
+
 } // namespace
 
 const PointerEventManager::MappedId PointerEventManager::s_invalidId = 0;
 
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
 const PointerEventManager::MappedId PointerEventManager::s_mouseId = 1;
 
 EventTarget* PointerEventManager::getCapturingNode(PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
 {
     // TODO(nzolghadr): Add APIs to set the capturing nodes and return the correct node here
@@ skipping 43 matching lines @@
     pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
         && type != EventTypeNames::pointerleave && type != EventTypeNames::pointercancel);
 
     pointerEventInit.setView(view);
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
-PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(const AtomicString& type,
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(
+    const AtomicString& type,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
     const double width, const double height,
     const double clientX, const double clientY)
 {
     const PlatformTouchPoint::State pointState = touchPoint.state();
 
     bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
         || pointState == PlatformTouchPoint::TouchCancelled;
 
     bool isEnterOrLeave = false;
@@ skipping 16 matching lines @@
         touchPoint.force(), pointerEventInit.buttons()));
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
     pointerEventInit.setBubbles(!isEnterOrLeave);
     pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
-
-PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::createPointerCancel(const PlatformTouchPoint& touchPoint)
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(
+    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent,
+    const AtomicString& type,
+    PassRefPtrWillBeRawPtr<EventTarget> relatedTarget)
 {
     PointerEventInit pointerEventInit;
 
+    pointerEventInit.setPointerId(pointerevent->pointerId());
+    pointerEventInit.setPointerType(pointerevent->pointerType());
+    pointerEventInit.setIsPrimary(pointerevent->isPrimary());
+    pointerEventInit.setWidth(pointerevent->width());
+    pointerEventInit.setHeight(pointerevent->height());
+    pointerEventInit.setTiltX(pointerevent->tiltX());
+    pointerEventInit.setTiltY(pointerevent->tiltY());
+    pointerEventInit.setScreenX(pointerevent->screenX());
+    pointerEventInit.setScreenY(pointerevent->screenY());
+    pointerEventInit.setClientX(pointerevent->clientX());
+    pointerEventInit.setClientY(pointerevent->clientY());
+    pointerEventInit.setButton(pointerevent->button());
+    pointerEventInit.setButtons(pointerevent->buttons());
+    pointerEventInit.setPressure(pointerevent->pressure());
+
+    pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave);
+    pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave
+        && type != EventTypeNames::pointercancel);
+
+    return PointerEvent::create(type, pointerEventInit);
+}
+
+void PointerEventManager::sendNodeTransitionEvents(

[mustaq, 2016/02/08 17:01:34]

This duplication looks bad. All you need here is a PE-only version of
EventHandler::sendNodeTransitionEvents(), right? We need a better way to address
this.

[Navid Zolghadr, 2016/02/10 16:25:29]

Done.

+    EventTarget* exitedTarget, EventTarget* enteredTarget,
+    PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
+{
+    if (exitedTarget == enteredTarget)
+        return;
+
+    if (!RuntimeEnabledFeatures::pointerEventEnabled())
+        return;
+
+    // Create lists of all exited/entered ancestors, locate the common ancestor
+    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> exitedAncestors;
+    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> enteredAncestors;
+    if (isInDocument(exitedTarget)) {
+        Node* exitedNode = exitedTarget->toNode();
+        exitedNode->updateDistribution();
+        for (Node* node = exitedNode; node; node = ComposedTreeTraversal::parent(*node))
+            exitedAncestors.append(node);
+    }
+    if (isInDocument(enteredTarget)) {
+        Node* enteredNode = enteredTarget->toNode();
+        enteredNode->updateDistribution();
+        for (Node* node = enteredNode; node; node = ComposedTreeTraversal::parent(*node))
+            enteredAncestors.append(node);
+    }
+
+    size_t exitedAncestorIndex = exitedAncestors.size();
+    size_t enteredAncestorIndex = enteredAncestors.size();
+    if (!exitedAncestors.isEmpty() && !enteredAncestors.isEmpty()) {
+        for (size_t i = exitedAncestors.size(), j = enteredAncestors.size(); i>0 && j>0; j--, i--) {
+            if (exitedAncestors[i-1] == enteredAncestors[j-1]) {
+                exitedAncestorIndex = i-1;
+                enteredAncestorIndex = j-1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    // Dispatch pointerout
+    sendPointerEventToTarget(exitedTarget,
+        create(pointerEvent, EventTypeNames::pointerout, enteredTarget));
+
+    // Dispatch pointerleave events, in child-to-parent order
+    for (size_t i = 0; i < exitedAncestorIndex; i++) {
+        sendPointerEventToTarget(exitedAncestors[i].get(),
+            create(pointerEvent, EventTypeNames::pointerleave, enteredTarget));
+    }
+
+    // Dispatch pointerover
+    sendPointerEventToTarget(enteredTarget,
+        create(pointerEvent, EventTypeNames::pointerover, exitedTarget));
+
+    // Dispatch pointerenter events, in parent-to-child order.
+    for (size_t j = enteredAncestorIndex; j > 0; j--) {
+        sendPointerEventToTarget(enteredAncestors[j-1].get(),
+            create(pointerEvent, EventTypeNames::pointerenter, exitedTarget));
+    }
+}
+
+void PointerEventManager::setNodeUnderPointer(
+    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent, EventTarget* target)
+{
+    if (m_nodeUnderPointer.contains(pointerevent->pointerId())) {
+        sendNodeTransitionEvents(m_nodeUnderPointer.get(
+            pointerevent->pointerId()), target, pointerevent);
+        if (!target)
+            m_nodeUnderPointer.remove(pointerevent->pointerId());
+        else
+            m_nodeUnderPointer.set(pointerevent->pointerId(), target);
+    } else if (target) {
+        sendNodeTransitionEvents(nullptr, target, pointerevent);
+        m_nodeUnderPointer.add(pointerevent->pointerId(), target);
+    }
+}
+
+void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> target,
+    const PlatformTouchPoint& point)
+{
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
+        createPointerCancel(point);
+
+    // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
+    target->dispatchEvent(pointerEvent.get());
+
+    remove(pointerEvent);
+    setNodeUnderPointer(pointerEvent, nullptr);
+}
+
+bool PointerEventManager::sendTouchPointerEvent(
+    PassRefPtrWillBeRawPtr<EventTarget> target,
+    const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
+    const double width, const double height,
+    const double clientX, const double clientY)
+{
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = create(
+        pointerEventNameForTouchPointState(touchPoint.state()),
+        touchPoint, modifiers, width, height, clientX, clientY);
+
+    setNodeUnderPointer(pointerEvent, target);
+
+    // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
+    target->dispatchEvent(pointerEvent.get());
+
+    if (touchPoint.state() == PlatformTouchPoint::TouchReleased
+        || touchPoint.state() == PlatformTouchPoint::TouchCancelled) {
+        remove(pointerEvent);
+        setNodeUnderPointer(pointerEvent, nullptr);
+    }
+
+    return pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
+}
+
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::createPointerCancel(
+    const PlatformTouchPoint& touchPoint)
+{
+    PointerEventInit pointerEventInit;
+
     setIdAndType(pointerEventInit, touchPoint.pointerProperties());
 
     pointerEventInit.setBubbles(true);
     pointerEventInit.setCancelable(false);
 
     return PointerEvent::create(EventTypeNames::pointercancel, pointerEventInit);
 }
 
 PointerEventManager::PointerEventManager()
 {
     clear();
 }
 
 PointerEventManager::~PointerEventManager()
 {
     clear();
 }
 
+DEFINE_TRACE(PointerEventManager)
+{
+    visitor->trace(m_nodeUnderPointer);
+}
+
 void PointerEventManager::clear()
 {
     for (int type = 0; type <= toInt(WebPointerProperties::PointerType::LastEntry); type++) {
         m_primaryId[type] = PointerEventManager::s_invalidId;
         m_idCount[type] = 0;
     }
     m_idMapping.clear();
     m_idReverseMapping.clear();
+    m_nodeUnderPointer.clear();
 
     // Always add mouse pointer in initialization and never remove it.
     // No need to add it to m_idMapping as it is not going to be used with the existing APIs
     m_primaryId[toInt(WebPointerProperties::PointerType::Mouse)] = s_mouseId;
     m_idReverseMapping.add(s_mouseId, IncomingId(toInt(WebPointerProperties::PointerType::Mouse), 0));
 
     m_currentId = PointerEventManager::s_mouseId+1;
 }
 
 PointerEventManager::MappedId PointerEventManager::add(const IncomingId p)
@@ skipping 36 matching lines @@
     if (!m_idReverseMapping.contains(mappedId))
         return false;
 
     IncomingId p = m_idReverseMapping.get(mappedId);
     int type = p.first;
     return m_primaryId[type] == mappedId;
 }
 
 
 } // namespace blink