Set width=height=1 of mouse like pointer 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/frame/FrameView.h"
@@ skipping 147 matching lines @@
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
         return capturingTarget;
     return target;
 }
 
-void PointerEventManager::sendMouseAndPossiblyPointerNodeTransitionEvents(
+void PointerEventManager::sendMouseAndPossiblyPointerBoundaryEvents(
     Node* exitedNode,
     Node* enteredNode,
     const PlatformMouseEvent& mouseEvent,
     bool isFrameBoundaryTransition)
 {
-    // Pointer event type does not matter as it will be overridden in the sendNodeTransitionEvents
-    PointerEvent* pointerEvent =
-        m_pointerEventFactory.create(EventTypeNames::mouseout, mouseEvent,
+    // Mouse event type does not matter as this pointerevent will only be used
+    // to create boundary pointer events and its type will be overridden in
+    // |sendBoundaryEvents| function.
+    PointerEvent* dummyPointerEvent =
+        m_pointerEventFactory.create(EventTypeNames::mousedown, mouseEvent,
         nullptr, m_frame->document()->domWindow());
 
     // TODO(crbug/545647): This state should reset with pointercancel too.
     // This function also gets called for compat mouse events of touch at this
     // stage. So if the event is not frame boundary transition it is only a
     // compatibility mouse event and we do not need to change pointer event
     // behavior regarding preventMouseEvent state in that case.
-    if (isFrameBoundaryTransition && pointerEvent->buttons() == 0
-        && pointerEvent->isPrimary()) {
+    if (isFrameBoundaryTransition && dummyPointerEvent->buttons() == 0
+        && dummyPointerEvent->isPrimary()) {
         m_preventMouseEventForPointerType[toPointerTypeIndex(
             mouseEvent.pointerProperties().pointerType)] = false;
     }
 
-    processCaptureAndPositionOfPointerEvent(pointerEvent, enteredNode,
+    processCaptureAndPositionOfPointerEvent(dummyPointerEvent, enteredNode,
         exitedNode, mouseEvent, true, isFrameBoundaryTransition);
 }
 
-void PointerEventManager::sendNodeTransitionEvents(
+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)
@@ skipping 112 matching lines @@
         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)
-            sendNodeTransitionEvents(node.target, target, pointerEvent);
+            sendBoundaryEvents(node.target, target, pointerEvent);
     } else if (target) {
         m_nodeUnderPointer.add(pointerEvent->pointerId(),
             EventTargetAttributes(target, false));
         if (sendEvent)
-            sendNodeTransitionEvents(nullptr, target, pointerEvent);
+            sendBoundaryEvents(nullptr, target, pointerEvent);
     }
 }
 
 void PointerEventManager::blockTouchPointers()
 {
     if (m_inCanceledStateForPointerTypeTouch)
         return;
     m_inCanceledStateForPointerTypeTouch = true;
 
     Vector<int> touchPointerIds
@@ skipping 226 matching lines @@
     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.
-        sendNodeTransitionEvents(lastNodeUnderMouse, hitTestTarget,
+        sendBoundaryEvents(lastNodeUnderMouse, hitTestTarget,
             pointerEvent, mouseEvent, true);
     }
 }
 
 bool PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
     const PlatformMouseEvent& mouseEvent, bool sendMouseEvent)
 {
     int pointerId = pointerEvent->pointerId();
@@ skipping 10 matching lines @@
         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
-                sendNodeTransitionEvents(nodeUnderPointerAtt.target, nullptr,
+                sendBoundaryEvents(nodeUnderPointerAtt.target, nullptr,
                     pointerEvent);
             }
-            sendNodeTransitionEvents(nodeUnderPointerAtt.target, nullptr,
+            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()->inShadowIncludingDocument()) {
                 target = target->toNode()->ownerDocument();
             }
             dispatchPointerEvent(target,
                 m_pointerEventFactory.createPointerCaptureEvent(
                 pointerEvent, EventTypeNames::lostpointercapture));
         }
     }
 
     // Set pointerCaptureTarget from pendingPointerCaptureTarget. This does
-    // affect the behavior of sendNodeTransitionEvents function. So the
+    // 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
-                sendNodeTransitionEvents(nullptr, hitTestTarget, pointerEvent);
+                sendBoundaryEvents(nullptr, hitTestTarget, pointerEvent);
             }
-            sendNodeTransitionEvents(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
@@ skipping 67 matching lines @@
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink