Canvas2d: fix event.region being null on mouseleave/out 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/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
+#include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandler.h"
 
 namespace blink {
 
 namespace {
 
 const AtomicString& pointerEventNameForTouchPointState(PlatformTouchPoint::TouchState state)
 {
     switch (state) {
     case PlatformTouchPoint::TouchReleased:
@@ skipping 102 matching lines @@
     // compatibility mouse event and we do not need to change pointer event
     // behavior regarding preventMouseEvent state in that case.
     if (isFrameBoundaryTransition && pointerEvent->buttons() == 0) {
         m_preventMouseEventForPointerTypeMouse = false;
     }
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, enteredNode,
         exitedNode, mouseEvent, true, isFrameBoundaryTransition);
 }
 
+PlatformMouseEvent PointerEventManager::mouseEventWithRegion(Node* node, const PlatformMouseEvent& mouseEvent)
+{
+    if (!node->isElementNode())
+        return mouseEvent;
+
+    Element* element = toElement(node);
+    if (!element->isInCanvasSubtree())
+        return mouseEvent;
+
+    HTMLCanvasElement* canvas = Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*element);
+    // In this case, the event target is canvas and mouse rerouting doesn't happen.
+    if (canvas == element)
+        return mouseEvent;
+    String region = canvas->getIdFromControl(element);
+    PlatformMouseEvent newMouseEvent = mouseEvent;
+    newMouseEvent.setRegion(region);
+    return newMouseEvent;
+}
+
 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)) {
         if (!sendMouseEvent) {
             dispatchPointerEvent(exitedTarget, m_pointerEventFactory.createPointerTransitionEvent(
                 pointerEvent, EventTypeNames::pointerout, enteredTarget));
         } else {
             dispatchMouseEvent(exitedTarget,
-                EventTypeNames::mouseout, mouseEvent, enteredTarget);
+                EventTypeNames::mouseout,
+                mouseEventWithRegion(exitedTarget->toNode(), 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();
         exitedNode->updateDistribution();
         for (RefPtrWillBeRawPtr<Node> node = exitedNode; node; node = FlatTreeTraversal::parent(*node))
@@ skipping 48 matching lines @@
 
     // Dispatch pointerleave/mouseleave events, in child-to-parent order.
     for (size_t j = 0; j < exitedAncestorIndex; j++) {
         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);
+                EventTypeNames::mouseleave,
+                mouseEventWithRegion(exitedTarget->toNode(), mouseEvent),
+                enteredTarget, 0, !exitedNodeHasCapturingAncestor);
         }
     }
 
     // Dispatch pointerover/mouseover.
     if (isInDocument(enteredTarget)) {
         if (!sendMouseEvent) {
             dispatchPointerEvent(enteredTarget, m_pointerEventFactory.createPointerTransitionEvent(
                 pointerEvent, EventTypeNames::pointerover, exitedTarget));
         } else {
             dispatchMouseEvent(enteredTarget,
@@ skipping 329 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink