Extract more of the mouse logic from EventHandler

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 129 matching lines @@
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target, int pointerId)
 {
     if (EventTarget* capturingTarget = getCapturingNode(pointerId))
         return capturingTarget;
     return target;
 }
 
-void PointerEventManager::sendMouseAndPossiblyPointerBoundaryEvents(
-    Node* exitedNode,
+void PointerEventManager::sendMouseAndPointerBoundaryEvents(
     Node* enteredNode,
-    const PlatformMouseEvent& mouseEvent,
-    bool isFrameBoundaryTransition)
+    const PlatformMouseEvent& 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,
         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 && dummyPointerEvent->buttons() == 0
-        && dummyPointerEvent->isPrimary()) {
+    if (dummyPointerEvent->buttons() == 0 && dummyPointerEvent->isPrimary()) {
         m_preventMouseEventForPointerType[toPointerTypeIndex(
             mouseEvent.pointerProperties().pointerType)] = false;
     }
 
     processCaptureAndPositionOfPointerEvent(dummyPointerEvent, enteredNode,
-        exitedNode, mouseEvent, true, isFrameBoundaryTransition);
+        mouseEvent, true);
 }
 
 void PointerEventManager::sendBoundaryEvents(
     EventTarget* exitedTarget,
     EventTarget* enteredTarget,
     PointerEvent* pointerEvent)
 {
     if (RuntimeEnabledFeatures::pointerEventV1SpecCapturingEnabled()) {
         if (exitedTarget == enteredTarget)
             return;
@@ skipping 213 matching lines @@
         processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     Node* target, const AtomicString& mouseEventType,
-    int clickCount, const PlatformMouseEvent& mouseEvent,
-    Node* lastNodeUnderMouse,
-    Node** newNodeUnderMouse)
+    const PlatformMouseEvent& mouseEvent)
 {
     PointerEvent* pointerEvent =
         m_pointerEventFactory.create(mouseEventType, mouseEvent,
         m_frame->document()->domWindow());
 
     // This is for when the mouse is released outside of the page.
     if (pointerEvent->type() == EventTypeNames::pointermove
         && !pointerEvent->buttons()) {
 
         releasePointerCapture(pointerEvent->pointerId());
         // Send got/lostpointercapture rightaway if necessary.
         processPendingPointerCapture(pointerEvent);
 
         if (pointerEvent->isPrimary()) {
             m_preventMouseEventForPointerType[toPointerTypeIndex(
                 mouseEvent.pointerProperties().pointerType)] = false;
         }
     }
 
-    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* pointerEventTarget = processCaptureAndPositionOfPointerEvent(
+        pointerEvent, target, mouseEvent, true);
 
     EventTarget* effectiveTarget =
         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;
     }
 
     if (pointerEvent->isPrimary() && !m_preventMouseEventForPointerType[toPointerTypeIndex(
         mouseEvent.pointerProperties().pointerType)]) {
         EventTarget* mouseTarget = effectiveTarget;
         // Event path could be null if pointer event is not dispatched and
         // that happens for example when pointer event feature is not enabled.
         if (!isInDocument(mouseTarget) && pointerEvent->hasEventPath()) {
             for (size_t i = 0; i < pointerEvent->eventPath().size(); i++) {
                 if (isInDocument(pointerEvent->eventPath()[i].node())) {
                     mouseTarget = pointerEvent->eventPath()[i].node();
                     break;
                 }
             }
         }
         result = EventHandlingUtil::mergeEventResult(result,
             m_mouseEventManager->dispatchMouseEvent(mouseTarget, mouseEventType,
-                mouseEvent, nullptr, clickCount));
+                mouseEvent, nullptr));
     }
 
     if (pointerEvent->type() == EventTypeNames::pointerup
         || pointerEvent->type() == EventTypeNames::pointercancel) {
 
         releasePointerCapture(pointerEvent->pointerId());
         // Send got/lostpointercapture rightaway if necessary.
         processPendingPointerCapture(pointerEvent);
 
         if (pointerEvent->isPrimary()) {
@@ skipping 42 matching lines @@
         *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 sendMouseEvent)
 {
-    if (setPointerPosition) {
-        processPendingPointerCapture(pointerEvent);
+    processPendingPointerCapture(pointerEvent);
 
-        if (!RuntimeEnabledFeatures::pointerEventV1SpecCapturingEnabled()) {
-            PointerCapturingMap::const_iterator it = m_pointerCaptureTarget.find(pointerEvent->pointerId());
-            if (EventTarget* pointercaptureTarget = (it != m_pointerCaptureTarget.end()) ? it->value : nullptr)
-                hitTestTarget = pointercaptureTarget;
-        }
+    if (!RuntimeEnabledFeatures::pointerEventV1SpecCapturingEnabled()) {
+        PointerCapturingMap::const_iterator it = m_pointerCaptureTarget.find(pointerEvent->pointerId());
+        if (EventTarget* pointercaptureTarget = (it != m_pointerCaptureTarget.end()) ? it->value : nullptr)
+            hitTestTarget = pointercaptureTarget;
+    }
 
-        setNodeUnderPointer(pointerEvent, hitTestTarget);
+    setNodeUnderPointer(pointerEvent, hitTestTarget);
+
+    if (sendMouseEvent) {
+        m_mouseEventManager->setNodeUnderMouse(
+            hitTestTarget ? hitTestTarget->toNode() : nullptr, mouseEvent);
     }
-    if (sendMouseEvent) {
-        // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
-        m_mouseEventManager->sendBoundaryEvents(lastNodeUnderMouse,
-            hitTestTarget, mouseEvent);
-    }
+
     return hitTestTarget;
 }
 
 void PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent)
 {
     EventTarget* pointerCaptureTarget;
     EventTarget* pendingPointerCaptureTarget;
     const int pointerId = pointerEvent->pointerId();
     const bool isCaptureChanged = getPointerCaptureState(
@@ skipping 137 matching lines @@
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
     visitor->trace(m_mouseEventManager);
 }
 
 
 } // namespace blink