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();
+    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 if is a hack to work around this bug

[mustaq, 2016/03/10 19:28:19]

nit: remove "if"

[Navid Zolghadr, 2016/03/10 20:27:35]

Sure.

+    if (pointerType == EventTypeNames::pointerover && pointerId == 1) {
+        m_nodeUnderPointer.set(pointerId, EventTargetAttributes
+            (target, true));
+    }

[mustaq, 2016/03/10 19:28:19]

This deserves a comment: why not resetting the bit on pointerout (as you did
above).

[Navid Zolghadr, 2016/03/10 20:27:35]

Since it was a hack anyways and should be removed soon, I didn't bother fully
add it. Just that current tests didn't hit that case. Because usually when you
send an out you will follow it up with an over on another element and that will
override this. However, I can imagine scenarios that it is not the case. I added
the other scenario as well.

[mustaq, 2016/03/10 21:06:57]

This is significant enough to call for a test. I understand that a solution for
the separate-entry-state bug could affect the test expectations, but we would
see a before-after diff w/o much effort.

Also need to add a test for implicit release of capture when mouse button was
release off the page. Use eventSender.setMouseButtonState(), e.g. in
mouse-pointer-chorded-buttons.html.

+
     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.createPointerTransition(
             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.createPointerTransition(
                 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.createPointerTransition(
             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.createPointerTransition(
                 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);
     }
 }
@@ skipping 54 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.createPointerCapture(
+                    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.createPointerCapture(
+                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