Firing got/lost pointer capture events

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/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/input/EventHandler.h"
 
@@ skipping 51 matching lines @@
 
 WebInputEventResult PointerEventManager::dispatchPointerEvent(
     PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     bool checkForListener)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
 
     // Set whether node under pointer has received pointerover or not.
-    int pointerId = pointerEvent->pointerId();
-    if ((pointerEvent->type() == EventTypeNames::pointerout
-        || pointerEvent->type() == EventTypeNames::pointerover)
+    const int pointerId = pointerEvent->pointerId();
+    const AtomicString& pointerType = pointerEvent->type();

[Rick Byers, 2016/03/14 19:19:15]

nit: maybe call this 'eventType'?  'pointerType' suggests mouse/touch etc.

[Navid Zolghadr, 2016/03/14 19:31:20]

Done.

+    if ((pointerType == EventTypeNames::pointerout
+        || pointerType == EventTypeNames::pointerover)
         && m_nodeUnderPointer.contains(pointerId)) {
         RefPtrWillBeRawPtr<EventTarget> targetUnderPointer =
             m_nodeUnderPointer.get(pointerId).target;
         if (targetUnderPointer == target) {
             m_nodeUnderPointer.set(pointerId, EventTargetAttributes
                 (targetUnderPointer,
-                pointerEvent->type() == EventTypeNames::pointerover));
+                pointerType == EventTypeNames::pointerover));
         }
     }
+
+    // TODO(crbug.com/587955): The following is a hack to work around this bug
+    if (pointerId == 1) {
+        if (pointerType == EventTypeNames::pointerover) {
+            m_nodeUnderPointer.set(pointerId, EventTargetAttributes
+                (target, true));
+        }
+        if (pointerType == EventTypeNames::pointerout
+            && m_nodeUnderPointer.get(pointerId).target == target) {
+            m_nodeUnderPointer.set(pointerId, EventTargetAttributes
+                (target, false));
+        }
+    }
+
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
-    if (!checkForListener || target->hasEventListeners(pointerEvent->type())) {
+    if (!checkForListener || target->hasEventListeners(pointerType)) {
         DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
         return EventHandler::toWebInputEventResult(dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
 PassRefPtrWillBeRawPtr<EventTarget> PointerEventManager::getEffectiveTargetForPointerEvent(
     PassRefPtrWillBeRawPtr<EventTarget> target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
@@ skipping 36 matching lines @@
         if (capturingTarget == exitedTarget)
             enteredTarget = nullptr;
         else if (capturingTarget == enteredTarget)
             exitedTarget = nullptr;
         else
             return;
     }
 
     // Dispatch pointerout/mouseout events
     if (isInDocument(exitedTarget)) {
-        dispatchPointerEvent(exitedTarget, m_pointerEventFactory.create(
+        dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerTransitionEvent(
             pointerEvent, EventTypeNames::pointerout, enteredTarget));
         if (sendMouseEvent) {
             dispatchMouseEvent(exitedTarget,
                 EventTypeNames::mouseout, mouseEvent, enteredTarget);
         }
     }
 
     // Create lists of all exited/entered ancestors, locate the common ancestor
     WillBeHeapVector<RefPtrWillBeMember<Node>, 32> exitedAncestors;
     WillBeHeapVector<RefPtrWillBeMember<Node>, 32> enteredAncestors;
@@ skipping 46 matching lines @@
     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 < exitedAncestorIndex; j++) {
         dispatchPointerEvent(exitedAncestors[j].get(),
-            m_pointerEventFactory.create(
+            m_pointerEventFactory.createPointerTransitionEvent(
                 pointerEvent, EventTypeNames::pointerleave, enteredTarget),
             !exitedNodeHasCapturingAncestor);
         if (sendMouseEvent) {
             dispatchMouseEvent(exitedAncestors[j].get(),
                 EventTypeNames::mouseleave, mouseEvent, enteredTarget,
                 0, !exitedNodeHasCapturingAncestor);
         }
     }
 
     // Dispatch pointerover/mouseover.
     if (isInDocument(enteredTarget)) {
-        dispatchPointerEvent(enteredTarget, m_pointerEventFactory.create(
+        dispatchPointerEvent(enteredTarget, m_pointerEventFactory.createPointerTransitionEvent(
             pointerEvent, EventTypeNames::pointerover, exitedTarget));
         if (sendMouseEvent) {
             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 = enteredAncestorIndex; i > 0; i--) {
         dispatchPointerEvent(enteredAncestors[i-1].get(),
-            m_pointerEventFactory.create(
+            m_pointerEventFactory.createPointerTransitionEvent(
                 pointerEvent, EventTypeNames::pointerenter, exitedTarget),
             !enteredNodeHasCapturingAncestor);
         if (sendMouseEvent) {
             dispatchMouseEvent(enteredAncestors[i-1].get(),
                 EventTypeNames::mouseenter, mouseEvent, exitedTarget,
                 0, !enteredNodeHasCapturingAncestor);
         }
     }
 }
 
 void PointerEventManager::setNodeUnderPointer(
     PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
 {
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
         EventTargetAttributes node = m_nodeUnderPointer.get(
             pointerEvent->pointerId());
         if (!target) {
             m_nodeUnderPointer.remove(pointerEvent->pointerId());
-        } else {
+        } else if (target
+            != m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
             m_nodeUnderPointer.set(pointerEvent->pointerId(),
                 EventTargetAttributes(target, false));
         }
         sendNodeTransitionEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
         sendNodeTransitionEvents(nullptr, target, pointerEvent);
     }
 }
 
 void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> prpTarget, const PlatformTouchPoint& point)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancel(point);
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancelEvent(point);
 
     processPendingPointerCapture(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
     setNodeUnderPointer(pointerEvent, nullptr);
 
@@ skipping 39 matching lines @@
 {
     RefPtrWillBeRawPtr<Node> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         relatedTarget, view);
 
     processPendingPointerCapture(pointerEvent, target, mouseEvent, true);
 
     // TODO(crbug.com/587955): We should call setNodeUnderPointer here but it causes sending
     // transition events that should be first removed from EventHandler.
+    // setNodeUnderPointer(pointerEvent, target);
 
     RefPtrWillBeRawPtr<EventTarget> effectiveTarget =
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId());
 
     WebInputEventResult result =
         dispatchPointerEvent(effectiveTarget, pointerEvent);
 
     if (result != WebInputEventResult::NotHandled
         && pointerEvent->type() == EventTypeNames::pointerdown)
         m_preventMouseEventForPointerTypeMouse = true;
@@ skipping 33 matching lines @@
     if (MouseEvent::platformModifiersToButtons(modifiers) ==
         static_cast<unsigned short>(MouseEvent::Buttons::None))
         m_preventMouseEventForPointerTypeMouse = false;
 }
 
 void PointerEventManager::processPendingPointerCapture(
     const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
-    // TODO(nzolghadr): Process sending got/lostpointercapture
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     RefPtrWillBeRawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
     int pointerId = pointerEvent->pointerId();
-    bool hasPointerCaptureTarget = m_pointerCaptureTarget.contains(pointerId);
-    bool hasPendingPointerCaptureTarget = m_pendingPointerCaptureTarget.contains(pointerId);
     const RefPtrWillBeRawPtr<EventTarget> pointerCaptureTarget =
-        hasPointerCaptureTarget ? m_pointerCaptureTarget.get(pointerId) : nullptr;
+        m_pointerCaptureTarget.contains(pointerId)
+        ? m_pointerCaptureTarget.get(pointerId) : nullptr;
     const RefPtrWillBeRawPtr<EventTarget> pendingPointerCaptureTarget =
-        hasPendingPointerCaptureTarget ? m_pendingPointerCaptureTarget.get(pointerId) : nullptr;
+        m_pendingPointerCaptureTarget.contains(pointerId)
+        ? m_pendingPointerCaptureTarget.get(pointerId) : nullptr;
+    const EventTargetAttributes &nodeUnderPointerAtt =
+        m_nodeUnderPointer.contains(pointerId)
+        ? m_nodeUnderPointer.get(pointerId) : EventTargetAttributes();
 
-    if (hasPendingPointerCaptureTarget
-        && (pointerCaptureTarget != pendingPointerCaptureTarget)) {
-        if (!hasPointerCaptureTarget
-            && pendingPointerCaptureTarget != hitTestTarget
-            && m_nodeUnderPointer.contains(pointerId)
-            && m_nodeUnderPointer.get(pointerId).hasRecievedOverEvent) {
-            sendNodeTransitionEvents(hitTestTarget, nullptr, pointerEvent,
-                mouseEvent, sendMouseEvent);
+    if (pointerCaptureTarget != pendingPointerCaptureTarget) {
+        if (pendingPointerCaptureTarget != nodeUnderPointerAtt.target
+            && nodeUnderPointerAtt.hasRecievedOverEvent) {
+            sendNodeTransitionEvents(nodeUnderPointerAtt.target, nullptr,
+                pointerEvent, mouseEvent, sendMouseEvent);
+        }
+        if (pointerCaptureTarget) {
+            // Re-target lostpointercapture to the document when the element is
+            // no longer participating in the tree.
+            EventTarget* target = pointerCaptureTarget.get();
+            if (target->toNode()
+                && !target->toNode()->inDocument()) {
+                target = target->toNode()->ownerDocument();
+            }
+            if (target) {
+                dispatchPointerEvent(target,
+                    m_pointerEventFactory.createPointerCaptureEvent(
+                    pointerEvent, EventTypeNames::lostpointercapture));
+            }
         }
     }
 
     // Set pointerCaptureTarget from pendingPointerCaptureTarget. This does
     // affect the behavior of sendNodeTransitionEvents function. So the
-    // ordering of the surrounding blocks of code is important.
-    if (!hasPendingPointerCaptureTarget)
+    // ordering of the surrounding blocks of code for sending transition events
+    // are important.
+    if (pendingPointerCaptureTarget)
+        m_pointerCaptureTarget.set(pointerId, pendingPointerCaptureTarget);
+    else
         m_pointerCaptureTarget.remove(pointerId);
-    else
-        m_pointerCaptureTarget.set(pointerId, m_pendingPointerCaptureTarget.get(pointerId));
 
-    if (hasPointerCaptureTarget && (pointerCaptureTarget != pendingPointerCaptureTarget)) {
-        if (!hasPendingPointerCaptureTarget && pointerCaptureTarget != hitTestTarget) {
+    if (pointerCaptureTarget != pendingPointerCaptureTarget) {
+        if (pendingPointerCaptureTarget) {
+            dispatchPointerEvent(pendingPointerCaptureTarget,
+                m_pointerEventFactory.createPointerCaptureEvent(
+                pointerEvent, EventTypeNames::gotpointercapture));
+        }
+        if ((pendingPointerCaptureTarget == hitTestTarget
+            || !pendingPointerCaptureTarget)
+            && (nodeUnderPointerAtt.target != hitTestTarget
+            || !nodeUnderPointerAtt.hasRecievedOverEvent)) {
             sendNodeTransitionEvents(nullptr, hitTestTarget, pointerEvent,
                 mouseEvent, sendMouseEvent);
         }
     }
-
 }
 
 void PointerEventManager::removeTargetFromPointerCapturingMapping(
     PointerCapturingMap& map, const EventTarget* target)
 {
     // We could have kept a reverse mapping to make this deletion possibly
     // faster but it adds some code complication which might not be worth of
     // the performance improvement considering there might not be a lot of
     // active pointer or pointer captures at the same time.
     PointerCapturingMap tmp = map;
@@ skipping 17 matching lines @@
     if (m_pointerEventFactory.remove(pointerEvent)) {
         int pointerId = pointerEvent->pointerId();
         m_pendingPointerCaptureTarget.remove(pointerId);
         m_pointerCaptureTarget.remove(pointerId);
         m_nodeUnderPointer.remove(pointerId);
     }
 }
 
 void PointerEventManager::elementRemoved(EventTarget* target)
 {
-    removeTargetFromPointerCapturingMapping(m_pointerCaptureTarget, target);
     removeTargetFromPointerCapturingMapping(m_pendingPointerCaptureTarget, target);
-    // TODO(nzolghadr): Process sending lostpointercapture to the document
 }
 
 void PointerEventManager::setPointerCapture(int pointerId, EventTarget* target)
 {
     if (m_pointerEventFactory.isActiveButtonsState(pointerId))
         m_pendingPointerCaptureTarget.set(pointerId, target);
 }
 
 void PointerEventManager::releasePointerCapture(int pointerId, EventTarget* target)
 {
@@ skipping 15 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink