Change mouse pointer event targets to the capturing node

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"
@@ skipping 18 matching lines @@
         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();
+        NOTREACHED();
         return emptyAtom;
     }
 }
 
 bool isInDocument(EventTarget* n)
 {
     return n && n->toNode() && n->toNode()->isConnected();
 }
 
 WebInputEventResult dispatchMouseEvent(
@@ skipping 153 matching lines @@
 
 void PointerEventManager::sendBoundaryEvents(
     EventTarget* exitedTarget,
     EventTarget* enteredTarget,
     PointerEvent* pointerEvent,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
     if (exitedTarget == enteredTarget)
         return;
 
-    if (EventTarget* capturingTarget = getCapturingNode(pointerEvent->pointerId())) {
-        if (capturingTarget == exitedTarget)
-            enteredTarget = nullptr;
-        else if (capturingTarget == enteredTarget)
-            exitedTarget = nullptr;
-        else
-            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);
@@ skipping 81 matching lines @@
         } else {
             dispatchMouseEvent(enteredAncestors[i-1].get(),
                 EventTypeNames::mouseenter, mouseEvent, exitedTarget,
                 0, !enteredNodeHasCapturingAncestor);
         }
     }
 }
 
 void PointerEventManager::setNodeUnderPointer(
     PointerEvent* pointerEvent,
-    EventTarget* target,
-    bool sendEvent)
+    EventTarget* target)
 {
     if (m_nodeUnderPointer.contains(pointerEvent->pointerId())) {
         EventTargetAttributes node = m_nodeUnderPointer.get(
             pointerEvent->pointerId());
         if (!target) {
             m_nodeUnderPointer.remove(pointerEvent->pointerId());
         } else if (target
             != m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
             m_nodeUnderPointer.set(pointerEvent->pointerId(),
                 EventTargetAttributes(target, false));
         }
-        if (sendEvent)
-            sendBoundaryEvents(node.target, target, pointerEvent);
+        sendBoundaryEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
-        if (sendEvent)
-            sendBoundaryEvents(nullptr, target, pointerEvent);
+        sendBoundaryEvents(nullptr, target, pointerEvent);
     }
 }
 
 void PointerEventManager::blockTouchPointers()
 {
     if (m_inCanceledStateForPointerTypeTouch)
         return;
     m_inCanceledStateForPointerTypeTouch = true;
 
     Vector<int> touchPointerIds
         = m_pointerEventFactory.getPointerIdsOfType(WebPointerProperties::PointerType::Touch);
 
     for (int pointerId : touchPointerIds) {
         PointerEvent* pointerEvent
             = m_pointerEventFactory.createPointerCancelEvent(
                 pointerId, WebPointerProperties::PointerType::Touch);
 
-        ASSERT(m_nodeUnderPointer.contains(pointerId));
+        DCHECK(m_nodeUnderPointer.contains(pointerId));
         EventTarget* target = m_nodeUnderPointer.get(pointerId).target;
 
         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);
@@ skipping 139 matching lines @@
         setPointerCapture(pointerEvent->pointerId(), target);
 
     WebInputEventResult result = dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent);
 
     if (pointerEvent->type() == EventTypeNames::pointerup
         || pointerEvent->type() == EventTypeNames::pointercancel) {
         releasePointerCapture(pointerEvent->pointerId());
 
-        // 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.
+        // Sending the leave/out events and lostpointercapture because the next
+        // touch event will have a different id.
         processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     Node* target, const AtomicString& mouseEventType,
     int clickCount, const PlatformMouseEvent& mouseEvent,
     Node* relatedTarget,
-    Node* lastNodeUnderMouse)
+    Node* lastNodeUnderMouse,
+    Node** newNodeUnderMouse)
 {
     PointerEvent* pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         relatedTarget, m_frame->document()->domWindow());
 
     // This is for when the mouse is released outside of the page.
     if (pointerEvent->type() == EventTypeNames::pointermove
         && !pointerEvent->buttons()
         && pointerEvent->isPrimary()) {
         m_preventMouseEventForPointerType[toPointerTypeIndex(
             mouseEvent.pointerProperties().pointerType)] = false;
     }
 
-    processCaptureAndPositionOfPointerEvent(pointerEvent, target,
+    EventTarget* pointerEventTarget = processCaptureAndPositionOfPointerEvent(pointerEvent, target,
         lastNodeUnderMouse, mouseEvent, true, true);
 
+    if (pointerEventTarget) {
+        // This is to prevent incorrect boundary events if capturing transition was
+        // delayed.
+        *newNodeUnderMouse = pointerEventTarget->toNode();
+        DCHECK(*newNodeUnderMouse);
+    }
+
     EventTarget* effectiveTarget =
-        getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId());
+        getEffectiveTargetForPointerEvent(pointerEventTarget, pointerEvent->pointerId());
 
     WebInputEventResult result =
         dispatchPointerEvent(effectiveTarget, pointerEvent);
 
     if (result != WebInputEventResult::NotHandled
         && pointerEvent->type() == EventTypeNames::pointerdown
         && pointerEvent->isPrimary()) {
         m_preventMouseEventForPointerType[toPointerTypeIndex(
             mouseEvent.pointerProperties().pointerType)] = true;
     }
@@ skipping 11 matching lines @@
                 }
             }
         }
         result = EventHandler::mergeEventResult(result,
             dispatchMouseEvent(mouseTarget, mouseEventType, mouseEvent,
             nullptr, clickCount));
     }
 
     if (pointerEvent->buttons() == 0) {
         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)
@@ 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();
 }
 
-void PointerEventManager::processCaptureAndPositionOfPointerEvent(
+bool PointerEventManager::getPointerCaptureState(int pointerId,
+    EventTarget** pointerCaptureTarget,
+    EventTarget** pendingPointerCaptureTarget)
+{
+    PointerCapturingMap::const_iterator it;
+
+    it = m_pointerCaptureTarget.find(pointerId);
+    EventTarget* pointerCaptureTargetTemp = (it != m_pointerCaptureTarget.end()) ? it->value : nullptr;
+    it = m_pendingPointerCaptureTarget.find(pointerId);
+    EventTarget* pendingPointercaptureTargetTemp = (it != m_pendingPointerCaptureTarget.end()) ? it->value : nullptr;
+
+    if (pointerCaptureTarget)
+        *pointerCaptureTarget = pointerCaptureTargetTemp;
+    if (pendingPointerCaptureTarget)
+        *pendingPointerCaptureTarget = pendingPointercaptureTargetTemp;
+
+    return pointerCaptureTargetTemp != pendingPointercaptureTargetTemp;
+}
+
+EventTarget* PointerEventManager::processCaptureAndPositionOfPointerEvent(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
     EventTarget* lastNodeUnderMouse,
     const PlatformMouseEvent& mouseEvent,
     bool sendMouseEvent, bool setPointerPosition)
 {
-    bool isCaptureChanged = false;
+    if (setPointerPosition) {
+        processPendingPointerCapture(pointerEvent);
 
-    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);
+        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 && !isCaptureChanged) {
+    if (sendMouseEvent) {
         // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
         sendBoundaryEvents(lastNodeUnderMouse, hitTestTarget,
             pointerEvent, mouseEvent, true);
     }
+    return hitTestTarget;
 }
 
-bool PointerEventManager::processPendingPointerCapture(
-    PointerEvent* pointerEvent,
-    EventTarget* hitTestTarget,
-    const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
+void PointerEventManager::processPendingPointerCapture(
+    PointerEvent* pointerEvent)
 {
-    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;
-    const EventTargetAttributes &nodeUnderPointerAtt =
-        m_nodeUnderPointer.contains(pointerId)
-        ? m_nodeUnderPointer.get(pointerId) : EventTargetAttributes();
-    const bool isCaptureChanged =
-        pointerCaptureTarget != pendingPointerCaptureTarget;
+    EventTarget* pointerCaptureTarget;
+    EventTarget* pendingPointerCaptureTarget;
+    const int pointerId = pointerEvent->pointerId();
+    const bool isCaptureChanged = getPointerCaptureState(
+        pointerId,
+        &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 (!isCaptureChanged)
+        return;
+
+    // We have to check whether the pointerCaptureTarget is null or not because
+    // we are checking whether it is still connected to its document or not.
+    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();
         }
-        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(
+        dispatchPointerEvent(target,
+            m_pointerEventFactory.createPointerCaptureEvent(
                 pointerEvent, EventTypeNames::lostpointercapture));
-        }
     }
+    // Note that If pendingPointerCaptureTarget is null dispatchPointerEvent
+    // automatically does nothing.
+    dispatchPointerEvent(pendingPointerCaptureTarget,
+        m_pointerEventFactory.createPointerCaptureEvent(
+            pointerEvent, EventTypeNames::gotpointercapture));
 
-    // 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));
-        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,
-                mouseEvent, sendMouseEvent);
-        }
-    }
-    return isCaptureChanged;
 }
 
 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 70 matching lines @@
         uint32_t firstId = m_touchIdsForCanceledPointerdowns.first();
         if (firstId > uniqueTouchEventId)
             return false;
         m_touchIdsForCanceledPointerdowns.takeFirst();
         if (firstId == uniqueTouchEventId)
             return true;
     }
     return false;
 }
 
+EventTarget* PointerEventManager::getMouseCapturingNode()
+{
+    return getCapturingNode(PointerEventFactory::s_mouseId);
+}
+
 DEFINE_TRACE(PointerEventManager)
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink