Separate mouse transition events from pointerevent

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 28 matching lines @@
 WebInputEventResult dispatchMouseEvent(
     PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     const AtomicString& mouseEventType,
     const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<EventTarget> prpRelatedTarget,
     int detail = 0,
     bool checkForListener = false)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     RefPtrWillBeRawPtr<EventTarget> relatedTarget = prpRelatedTarget;
-    if (target->toNode()
+    if (target && target->toNode()
         && (!checkForListener || target->hasEventListeners(mouseEventType))) {
         RefPtrWillBeRawPtr<Node> targetNode = target->toNode();
         RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType,
             targetNode->document().domWindow(), mouseEvent, detail,
             relatedTarget ? relatedTarget->toNode() : nullptr);
         DispatchEventResult dispatchResult = target->dispatchEvent(event);
         return EventHandler::toWebInputEventResult(dispatchResult);
     }
     return WebInputEventResult::NotHandled;
 }
 
 } // namespace
 
 WebInputEventResult PointerEventManager::dispatchPointerEvent(
     PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     bool checkForListener)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
 
+    if (!target)
+        return WebInputEventResult::NotHandled;
+
     // Set whether node under pointer has received pointerover or not.
     const int pointerId = pointerEvent->pointerId();
     const AtomicString& eventType = pointerEvent->type();
     if ((eventType == EventTypeNames::pointerout
         || eventType == EventTypeNames::pointerover)
         && m_nodeUnderPointer.contains(pointerId)) {
         RefPtrWillBeRawPtr<EventTarget> targetUnderPointer =
             m_nodeUnderPointer.get(pointerId).target;
         if (targetUnderPointer == target) {
             m_nodeUnderPointer.set(pointerId, EventTargetAttributes
                 (targetUnderPointer,
                 eventType == EventTypeNames::pointerover));
         }
     }
 
-    // TODO(crbug.com/587955): The following is a hack to work around this bug
-    if (pointerId == 1) {
-        if (eventType == EventTypeNames::pointerover) {
-            m_nodeUnderPointer.set(pointerId, EventTargetAttributes
-                (target, true));
-        }
-        if (eventType == 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(eventType)) {
         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))
         return capturingTarget;
     return target;
 }
 
 // Sends node transition events (pointer|mouse)(out|leave|over|enter) to the corresponding targets

[mustaq, 2016/03/22 15:28:43]

Nuke this line, we have this in the header.

[Navid Zolghadr, 2016/03/22 18:00:24]

Done.

 void PointerEventManager::sendNodeTransitionEvents(
     PassRefPtrWillBeRawPtr<Node> prpExitedNode,
     PassRefPtrWillBeRawPtr<Node> prpEnteredNode,
     const PlatformMouseEvent& mouseEvent,
-    PassRefPtrWillBeRawPtr<AbstractView> view)
+    PassRefPtrWillBeRawPtr<AbstractView> view,
+    bool isFrameBoundaryTransition)
 {
     RefPtrWillBeRawPtr<Node> exitedNode = prpExitedNode;
     RefPtrWillBeRawPtr<Node> enteredNode = prpEnteredNode;
+
+    // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(EventTypeNames::mouseout, mouseEvent,
         nullptr, view);
-    processPendingPointerCapture(pointerEvent, enteredNode, mouseEvent, true);
 
-    // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
-    sendNodeTransitionEvents(exitedNode, enteredNode, pointerEvent, mouseEvent,
-        true);
+    // TODO(crbug/545647): This state should reset with pointercancel too.
+    if (isFrameBoundaryTransition && pointerEvent->buttons() == 0) {
+        m_preventMouseEventForPointerTypeMouse = false;
+    }
+
+    prepareForFiringPointerEvent(pointerEvent, enteredNode,
+        exitedNode, mouseEvent, true, isFrameBoundaryTransition);
 }
 
 void PointerEventManager::sendNodeTransitionEvents(
     PassRefPtrWillBeRawPtr<EventTarget> prpExitedTarget,
     PassRefPtrWillBeRawPtr<EventTarget> prpEnteredTarget,
     PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
     RefPtrWillBeRawPtr<EventTarget> exitedTarget = prpExitedTarget;
     RefPtrWillBeRawPtr<EventTarget> enteredTarget = prpEnteredTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+
     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)) {
-        dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerTransitionEvent(
-            pointerEvent, EventTypeNames::pointerout, enteredTarget));
-        if (sendMouseEvent) {
+        if (!sendMouseEvent) {
+            dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerTransitionEvent(
+                pointerEvent, EventTypeNames::pointerout, enteredTarget));
+        } else {
             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;
     if (isInDocument(exitedTarget)) {
         RefPtrWillBeRawPtr<Node> exitedNode = exitedTarget->toNode();
@@ skipping 43 matching lines @@
     bool exitedNodeHasCapturingAncestor = false;
     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.createPointerTransitionEvent(
-                pointerEvent, EventTypeNames::pointerleave, enteredTarget),
-            !exitedNodeHasCapturingAncestor);
-        if (sendMouseEvent) {
+        if (!sendMouseEvent) {
+            dispatchPointerEvent(exitedAncestors[j].get(),
+                m_pointerEventFactory.createPointerTransitionEvent(
+                    pointerEvent, EventTypeNames::pointerleave, enteredTarget),
+                !exitedNodeHasCapturingAncestor);
+        } else {
             dispatchMouseEvent(exitedAncestors[j].get(),
                 EventTypeNames::mouseleave, mouseEvent, enteredTarget,
                 0, !exitedNodeHasCapturingAncestor);
         }
     }
 
     // Dispatch pointerover/mouseover.
     if (isInDocument(enteredTarget)) {
-        dispatchPointerEvent(enteredTarget, m_pointerEventFactory.createPointerTransitionEvent(
-            pointerEvent, EventTypeNames::pointerover, exitedTarget));
-        if (sendMouseEvent) {
+        if (!sendMouseEvent) {
+            dispatchPointerEvent(enteredTarget, m_pointerEventFactory.createPointerTransitionEvent(
+                pointerEvent, EventTypeNames::pointerover, exitedTarget));
+        } else {
             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.createPointerTransitionEvent(
-                pointerEvent, EventTypeNames::pointerenter, exitedTarget),
-            !enteredNodeHasCapturingAncestor);
-        if (sendMouseEvent) {
+        if (!sendMouseEvent) {
+            dispatchPointerEvent(enteredAncestors[i-1].get(),
+                m_pointerEventFactory.createPointerTransitionEvent(
+                    pointerEvent, EventTypeNames::pointerenter, exitedTarget),
+                !enteredNodeHasCapturingAncestor);
+        } else {
             dispatchMouseEvent(enteredAncestors[i-1].get(),
                 EventTypeNames::mouseenter, mouseEvent, exitedTarget,
                 0, !enteredNodeHasCapturingAncestor);
         }
     }
 }
 
 void PointerEventManager::setNodeUnderPointer(
     PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
-    PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
+    PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
+    bool sendEvent)
 {
     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 if (target
             != m_nodeUnderPointer.get(pointerEvent->pointerId()).target) {
             m_nodeUnderPointer.set(pointerEvent->pointerId(),
                 EventTargetAttributes(target, false));
         }
-        sendNodeTransitionEvents(node.target, target, pointerEvent);
+        if (sendEvent)
+            sendNodeTransitionEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
-        sendNodeTransitionEvents(nullptr, target, pointerEvent);
+        if (sendEvent)
+            sendNodeTransitionEvents(nullptr, target, pointerEvent);
     }
 }
 
 void PointerEventManager::sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget> prpTarget, const PlatformTouchPoint& point)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancelEvent(point);
 
-    processPendingPointerCapture(pointerEvent, target);
+
+    prepareForFiringPointerEvent(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);
 
     removePointer(pointerEvent);
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
     PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
     const double width, const double height,
     const double clientX, const double clientY)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
 
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(
         pointerEventNameForTouchPointState(touchPoint.state()),
         touchPoint, modifiers, width, height, clientX, clientY);
 
-    processPendingPointerCapture(pointerEvent, target);
-
-    setNodeUnderPointer(pointerEvent, target);
+    prepareForFiringPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     WebInputEventResult result = dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
     if (touchPoint.state() == PlatformTouchPoint::TouchReleased
         || touchPoint.state() == PlatformTouchPoint::TouchCancelled) {
         setNodeUnderPointer(pointerEvent, nullptr);
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     PassRefPtrWillBeRawPtr<Node> prpTarget, const AtomicString& mouseEventType,
     int clickCount, const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<Node> relatedTarget,
-    PassRefPtrWillBeRawPtr<AbstractView> view)
+    PassRefPtrWillBeRawPtr<AbstractView> view,
+    PassRefPtrWillBeRawPtr<Node> lastNodeUnderMouse)
 {
     RefPtrWillBeRawPtr<Node> target = prpTarget;
+
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         relatedTarget, view);
 
-    processPendingPointerCapture(pointerEvent, target, mouseEvent, true);
+    if (pointerEvent->type() == EventTypeNames::pointermove
+        && !pointerEvent->buttons()) {
+        m_preventMouseEventForPointerTypeMouse = false;

[mustaq, 2016/03/22 15:28:43]

Resetting m_preventMouseEventForPointerTypeMouse twice in the same function
looks a bit hacky to me. Please try to consolidate them. The idea is simple: if
buttons==0, mouse-blocking is gone. The transition events are never blocked.

[Navid Zolghadr, 2016/03/22 18:00:24]

Following our discussion offline, this is still needed to handle the release
mouse outside of the page. I will add the comment explaining this here.

+    }
 
-    // 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);
+    prepareForFiringPointerEvent(pointerEvent, target,
+        lastNodeUnderMouse, mouseEvent, true, true);

[mustaq, 2016/03/22 15:28:43]

I guess this is okay to pass the PassRefPtr lastNodeUnderMouse as a parameter
here since you are using it only once. If I am wrong here, please follow OilPan
team's guidance for the body of the first sendNodeTransitionEvents() above (in a
past CL IIRC). Otherwise, simplify the sendNodeTransitionEvents() body like
this.

[Navid Zolghadr, 2016/03/22 18:00:24]

I believe you are right. I remember I was told that when it is only being
forwarded to another function it is okay to pass PassRefPtr. I will simplify
that function as well.

 
     RefPtrWillBeRawPtr<EventTarget> effectiveTarget =
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId());
 
     WebInputEventResult result =
         dispatchPointerEvent(effectiveTarget, pointerEvent);
 
     if (result != WebInputEventResult::NotHandled
         && pointerEvent->type() == EventTypeNames::pointerdown)
         m_preventMouseEventForPointerTypeMouse = true;
 
     if (!m_preventMouseEventForPointerTypeMouse) {
         result = EventHandler::mergeEventResult(result,
             dispatchMouseEvent(effectiveTarget, mouseEventType, mouseEvent,
             nullptr, clickCount));
     }
 
-    if (pointerEvent->buttons() == 0)
+    if (pointerEvent->buttons() == 0) {
         releasePointerCapture(pointerEvent->pointerId());
+        m_preventMouseEventForPointerTypeMouse = false;
+    }
 
     return result;
 }
 
 PointerEventManager::PointerEventManager()
 {
     clear();
 }
 
 PointerEventManager::~PointerEventManager()
 {
 }
 
 void PointerEventManager::clear()
 {
     m_preventMouseEventForPointerTypeMouse = false;
     m_pointerEventFactory.clear();
     m_nodeUnderPointer.clear();
 }
 
-void PointerEventManager::conditionallyEnableMouseEventForPointerTypeMouse(
-    unsigned modifiers)
+void PointerEventManager::prepareForFiringPointerEvent(

[mustaq, 2016/03/22 15:28:43]

Please consider a more specific name here. Also add a description in the header
file.

[Navid Zolghadr, 2016/03/22 18:00:24]

I used processCaptureAndPositionOfPointerEvent. Is it more clear?

[mustaq, 2016/03/23 18:49:07]

Yes, thanks. Is |updateCaptureAndPosition| better? Your call.

+    const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
+    const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
+    const PassRefPtrWillBeRawPtr<EventTarget> lastNodeUnderMouse,
+    const PlatformMouseEvent& mouseEvent,
+    bool sendMouseEvent, bool isFrameBoundaryTransition)
 {
-
-    if (MouseEvent::platformModifiersToButtons(modifiers) ==
-        static_cast<unsigned short>(MouseEvent::Buttons::None))
-        m_preventMouseEventForPointerTypeMouse = false;
+    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
+    RefPtrWillBeRawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
+    bool isCaptureChanged = processPendingPointerCapture(pointerEvent,
+        hitTestTarget, mouseEvent, sendMouseEvent);
+    if (isFrameBoundaryTransition) {
+        // 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.
+        sendNodeTransitionEvents(lastNodeUnderMouse, hitTestTarget,
+            pointerEvent, mouseEvent, true);
+    }
 }
 
-void PointerEventManager::processPendingPointerCapture(
+bool PointerEventManager::processPendingPointerCapture(
     const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
     RefPtrWillBeRawPtr<EventTarget> hitTestTarget = prpHitTestTarget;
     int pointerId = pointerEvent->pointerId();
     const RefPtrWillBeRawPtr<EventTarget> pointerCaptureTarget =
         m_pointerCaptureTarget.contains(pointerId)
         ? m_pointerCaptureTarget.get(pointerId) : nullptr;
     const RefPtrWillBeRawPtr<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;
 
-    if (pointerCaptureTarget != pendingPointerCaptureTarget) {
-        if (pendingPointerCaptureTarget != nodeUnderPointerAtt.target
+    if (isCaptureChanged) {
+        if ((hitTestTarget != nodeUnderPointerAtt.target
+            || pendingPointerCaptureTarget != nodeUnderPointerAtt.target)
             && nodeUnderPointerAtt.hasRecievedOverEvent) {
+            if (sendMouseEvent) {
+                // Send pointer event transitions as the line after this if
+                // block sends the mouse events
+                sendNodeTransitionEvents(nodeUnderPointerAtt.target, nullptr,
+                    pointerEvent);
+            }
             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));
-            }
+            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 for sending transition events
     // are important.
     if (pendingPointerCaptureTarget)
         m_pointerCaptureTarget.set(pointerId, pendingPointerCaptureTarget);
     else
         m_pointerCaptureTarget.remove(pointerId);
 
-    if (pointerCaptureTarget != pendingPointerCaptureTarget) {
-        if (pendingPointerCaptureTarget) {
-            dispatchPointerEvent(pendingPointerCaptureTarget,
-                m_pointerEventFactory.createPointerCaptureEvent(
-                pointerEvent, EventTypeNames::gotpointercapture));
-        }
+    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
+                sendNodeTransitionEvents(nullptr, hitTestTarget, pointerEvent);
+            }
             sendNodeTransitionEvents(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 53 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink