Send got/lostpointercapture immediately if possible

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/ExecutionContextTask.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/TouchActionUtil.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/PlatformTouchEvent.h"
@@ skipping 341 matching lines @@
 
         processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
         // TODO(nzolghadr): This event follows implicit TE capture. The actual target
         // would depend on PE capturing. Perhaps need to split TE/PE event path upstream?
         // crbug.com/579553.
         dispatchPointerEvent(
             getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
             pointerEvent);
 
-        releasePointerCapture(pointerEvent->pointerId());
+        modifyPendingPointerCapture(pointerEvent->pointerId(), nullptr);
 
         // Sending the leave/out events and lostpointercapture
         // because the next touch event will have a different id. So delayed
         // sending of lostpointercapture won't work here.
         processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
         removePointer(pointerEvent);
     }
 }
 
@@ skipping 125 matching lines @@
     // Setting the implicit capture for touch
     if (pointerEvent->type() == EventTypeNames::pointerdown)
         setPointerCapture(pointerEvent->pointerId(), target);
 
     WebInputEventResult result = dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent);
 
     if (pointerEvent->type() == EventTypeNames::pointerup
         || pointerEvent->type() == EventTypeNames::pointercancel) {
-        releasePointerCapture(pointerEvent->pointerId());
+        modifyPendingPointerCapture(pointerEvent->pointerId(), nullptr);
 
         // Sending the leave/out events and lostpointercapture
         // because the next touch event will have a different id. So delayed
         // sending of lostpointercapture won't work here.
         processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
         removePointer(pointerEvent);
     }
 
     return result;
@@ skipping 45 matching lines @@
                     break;
                 }
             }
         }
         result = EventHandler::mergeEventResult(result,
             dispatchMouseEvent(mouseTarget, mouseEventType, mouseEvent,
             nullptr, clickCount));
     }
 
     if (pointerEvent->buttons() == 0) {
-        releasePointerCapture(pointerEvent->pointerId());
+        modifyPendingPointerCapture(pointerEvent->pointerId(), nullptr);
         if (pointerEvent->isPrimary()) {
             m_preventMouseEventForPointerType[toPointerTypeIndex(
                 mouseEvent.pointerProperties().pointerType)] = false;
         }
     }
 
     return result;
 }
 
 PointerEventManager::PointerEventManager(LocalFrame* frame)
@@ skipping 13 matching lines @@
         entry = false;
     m_touchEventManager.clear();
     m_inCanceledStateForPointerTypeTouch = false;
     m_pointerEventFactory.clear();
     m_touchIdsForCanceledPointerdowns.clear();
     m_nodeUnderPointer.clear();
     m_pointerCaptureTarget.clear();
     m_pendingPointerCaptureTarget.clear();
 }
 
+bool PointerEventManager::getPointerCaptureState(int pointerId,
+    EventTarget** pointerCaptureTarget,
+    EventTarget** pendingPointerCaptureTarget)
+{
+    PointerCapturingMap::iterator it;
+
+    it = m_pointerCaptureTarget.find(pointerId);
+    EventTarget* pct =
+        (it != m_pointerCaptureTarget.end()) ? it->value : nullptr;
+    it = m_pendingPointerCaptureTarget.find(pointerId);
+    EventTarget* ppct =
+        (it != m_pendingPointerCaptureTarget.end()) ? it->value : nullptr;
+
+    if (pointerCaptureTarget)
+        *pointerCaptureTarget = pct;
+    if (pendingPointerCaptureTarget)
+        *pendingPointerCaptureTarget = ppct;
+
+    return pct != ppct;
+}
+
 void PointerEventManager::processCaptureAndPositionOfPointerEvent(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
     EventTarget* lastNodeUnderMouse,
     const PlatformMouseEvent& mouseEvent,
     bool sendMouseEvent, bool setPointerPosition)
 {
     bool isCaptureChanged = false;
 
     if (setPointerPosition) {
         isCaptureChanged = processPendingPointerCapture(pointerEvent,
             hitTestTarget, mouseEvent, sendMouseEvent);
         // If there was a change in capturing processPendingPointerCapture has
         // already taken care of transition events. So we don't need to send the
         // transition events here.
         setNodeUnderPointer(pointerEvent, hitTestTarget, !isCaptureChanged);
     }
     if (sendMouseEvent && !isCaptureChanged) {
         // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
         sendBoundaryEvents(lastNodeUnderMouse, hitTestTarget,
             pointerEvent, mouseEvent, true);
     }
 }
 
+void PointerEventManager::immediatelyProcessPendingPointerCapture(int pointerId)
+{
+    EventTarget* pointerCaptureTarget;
+    EventTarget* pendingPointerCaptureTarget;
+    const bool isCaptureChanged = getPointerCaptureState(pointerId,
+        &pointerCaptureTarget, &pendingPointerCaptureTarget);
+
+    if (!isCaptureChanged)
+        return;
+
+    if (pointerCaptureTarget) {
+        // Re-target lostpointercapture to the document when the element is
+        // no longer participating in the tree.
+        EventTarget* target = pointerCaptureTarget;
+        if (target->toNode()
+            && !target->toNode()->isConnected()) {
+            target = target->toNode()->ownerDocument();
+        }
+        dispatchPointerEvent(target,
+            m_pointerEventFactory.createPointerCaptureEvent(
+                pointerId, EventTypeNames::lostpointercapture));
+    }
+    dispatchPointerEvent(pendingPointerCaptureTarget,
+        m_pointerEventFactory.createPointerCaptureEvent(
+            pointerId, EventTypeNames::gotpointercapture));
+
+    // Setting |m_pointerCaptureTarget| comes at the end to prevent the infinite
+    // loop if js calls set/releasepointercapture in got/lostpointercapture
+    // handlers.
+    if (pendingPointerCaptureTarget)
+        m_pointerCaptureTarget.set(pointerId, pendingPointerCaptureTarget);
+    else
+        m_pointerCaptureTarget.remove(pointerId);
+}
+
+// TODO(nzolghadr): This function should be merged with |immediatelyProcessPendingPointerCapture|
+// when we stop hit-testing while a pointer is captured.

[mustaq, 2016/07/18 20:31:40]

Please add in the TODO comment that firing of boundary events /during/ capture
or release is delayed except for PEs-while-in-jank case.

This is important because the outcome of consecutive setPointerCapture calls
would be jank-dependent, would feel buggy for completely lost enter/leaves
during the jank.

 bool PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
     int pointerId = pointerEvent->pointerId();
-    EventTarget* pointerCaptureTarget =
-        m_pointerCaptureTarget.contains(pointerId)
-        ? m_pointerCaptureTarget.get(pointerId) : nullptr;
-    EventTarget* pendingPointerCaptureTarget =
-        m_pendingPointerCaptureTarget.contains(pointerId)
-        ? m_pendingPointerCaptureTarget.get(pointerId) : nullptr;
+    EventTarget* pointerCaptureTarget;
+    EventTarget* pendingPointerCaptureTarget;
+    const bool isCaptureChanged = getPointerCaptureState(pointerId,
+        &pointerCaptureTarget, &pendingPointerCaptureTarget);
     const EventTargetAttributes &nodeUnderPointerAtt =
         m_nodeUnderPointer.contains(pointerId)
         ? m_nodeUnderPointer.get(pointerId) : EventTargetAttributes();
-    const bool isCaptureChanged =
-        pointerCaptureTarget != pendingPointerCaptureTarget;
 
     if (isCaptureChanged) {
         if ((hitTestTarget != nodeUnderPointerAtt.target
             || (pendingPointerCaptureTarget
             && pendingPointerCaptureTarget != nodeUnderPointerAtt.target))
             && nodeUnderPointerAtt.hasRecievedOverEvent) {
             if (sendMouseEvent) {
                 // Send pointer event transitions as the line after this if
                 // block sends the mouse events
                 sendBoundaryEvents(nodeUnderPointerAtt.target, nullptr,
                     pointerEvent);
             }
             sendBoundaryEvents(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;
             if (target->toNode()
                 && !target->toNode()->isConnected()) {
                 target = target->toNode()->ownerDocument();
             }
             dispatchPointerEvent(target,
                 m_pointerEventFactory.createPointerCaptureEvent(
-                pointerEvent, EventTypeNames::lostpointercapture));
+                    pointerId, EventTypeNames::lostpointercapture));
         }
     }
 
     // Set pointerCaptureTarget from pendingPointerCaptureTarget. This does
     // affect the behavior of sendBoundaryEvents function. So the
     // 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);
 
     if (isCaptureChanged) {
         dispatchPointerEvent(pendingPointerCaptureTarget,
             m_pointerEventFactory.createPointerCaptureEvent(
-            pointerEvent, EventTypeNames::gotpointercapture));
+                pointerId, EventTypeNames::gotpointercapture));
         if ((pendingPointerCaptureTarget == hitTestTarget
             || !pendingPointerCaptureTarget)
             && (nodeUnderPointerAtt.target != hitTestTarget
             || !nodeUnderPointerAtt.hasRecievedOverEvent)) {
             if (sendMouseEvent) {
                 // Send pointer event transitions as the line after this if
                 // block sends the mouse events
                 sendBoundaryEvents(nullptr, hitTestTarget, pointerEvent);
             }
             sendBoundaryEvents(nullptr, hitTestTarget, pointerEvent,
@@ skipping 36 matching lines @@
 }
 
 void PointerEventManager::elementRemoved(EventTarget* target)
 {
     removeTargetFromPointerCapturingMapping(m_pendingPointerCaptureTarget, target);
 }
 
 void PointerEventManager::setPointerCapture(int pointerId, EventTarget* target)
 {
     UseCounter::count(m_frame->document(), UseCounter::PointerEventSetCapture);
-    if (m_pointerEventFactory.isActiveButtonsState(pointerId))
-        m_pendingPointerCaptureTarget.set(pointerId, target);
+    if (m_pointerEventFactory.isActiveButtonsState(pointerId)) {
+        modifyPendingPointerCapture(pointerId, target);
+    }
 }
 
 void PointerEventManager::releasePointerCapture(int pointerId, EventTarget* target)
 {
     // Only the element that is going to get the next pointer event can release
     // the capture. Note that this might be different from
     // |m_pointercaptureTarget|. |m_pointercaptureTarget| holds the element
     // that had the capture until now and has been receiving the pointerevents
     // but |m_pendingPointerCaptureTarget| indicated the element that gets the
     // very next pointer event. They will be the same if there was no change in
     // capturing of a particular |pointerId|. See crbug.com/614481.
     if (m_pendingPointerCaptureTarget.get(pointerId) == target)
-        releasePointerCapture(pointerId);
+        modifyPendingPointerCapture(pointerId, nullptr);
 }
 
-void PointerEventManager::releasePointerCapture(int pointerId)
+void PointerEventManager::modifyPendingPointerCapture(
+    int pointerId, EventTarget* target)
 {
-    m_pendingPointerCaptureTarget.remove(pointerId);
+    bool wasCaptureStationary = !getPointerCaptureState(pointerId, nullptr, nullptr);
+
+    if (target)
+        m_pendingPointerCaptureTarget.set(pointerId, target);
+    else
+        m_pendingPointerCaptureTarget.remove(pointerId);
+
+    // Only queue the processing pending pointer capture if the pending
+    // capture target and capture target were the same to prevent infinite
+    // got/lostpointercapture event sequence.
+    // See https://github.com/w3c/pointerevents/issues/32.
+    if (wasCaptureStationary) {
+        m_frame->document()->postTask(
+            BLINK_FROM_HERE,
+            createSameThreadTask(
+                &PointerEventManager::immediatelyProcessPendingPointerCapture,
+                wrapWeakPersistent(this), pointerId));
+    }
 }
 
 bool PointerEventManager::isActive(const int pointerId) const
 {
     return m_pointerEventFactory.isActive(pointerId);
 }
 
 bool PointerEventManager::isAnyTouchActive() const
 {
     return m_touchEventManager.isAnyTouchActive();
@@ skipping 19 matching lines @@
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink