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 34 matching lines @@
       return emptyAtom;
   }
 }
 
 bool isInDocument(EventTarget* n) {
   return n && n->toNode() && n->toNode()->isConnected();
 }
 
 }  // namespace
 
+PointerEventManager::PointerEventManager(LocalFrame* frame,
+                                         MouseEventManager* mouseEventManager)
+    : m_frame(frame),
+      m_touchEventManager(new TouchEventManager(frame)),
+      m_mouseEventManager(mouseEventManager) {
+  clear();
+}
+
+void PointerEventManager::clear() {
+  for (auto& entry : m_preventMouseEventForPointerType)
+    entry = false;
+  m_touchEventManager->clear();
+  m_inCanceledStateForPointerTypeTouch = false;
+  m_pointerEventFactory.clear();
+  m_touchIdsForCanceledPointerdowns.clear();
+  m_nodeUnderPointer.clear();
+  m_pointerCaptureTarget.clear();
+  m_pendingPointerCaptureTarget.clear();
+}
+
+DEFINE_TRACE(PointerEventManager) {
+  visitor->trace(m_frame);
+  visitor->trace(m_nodeUnderPointer);
+  visitor->trace(m_pointerCaptureTarget);
+  visitor->trace(m_pendingPointerCaptureTarget);
+  visitor->trace(m_touchEventManager);
+  visitor->trace(m_mouseEventManager);
+}
+
 PointerEventManager::PointerEventBoundaryEventDispatcher::
     PointerEventBoundaryEventDispatcher(
         PointerEventManager* pointerEventManager,
         PointerEvent* pointerEvent)
     : m_pointerEventManager(pointerEventManager),
       m_pointerEvent(pointerEvent) {}
 
 void PointerEventManager::PointerEventBoundaryEventDispatcher::dispatchOut(
     EventTarget* target,
     EventTarget* relatedTarget) {
@@ skipping 81 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;
     if (EventTarget* capturingTarget =
             getCapturingNode(pointerEvent->pointerId())) {
@@ skipping 212 matching lines @@
 
     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);
-  }
+      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));
+        result, m_mouseEventManager->dispatchMouseEvent(
+                    mouseTarget, mouseEventType, 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()) {
       m_preventMouseEventForPointerType[toPointerTypeIndex(
           mouseEvent.pointerProperties().pointerType)] = false;
     }
   }
 
   return result;
 }
 
-PointerEventManager::PointerEventManager(LocalFrame* frame,
-                                         MouseEventManager* mouseEventManager)
-    : m_frame(frame),
-      m_touchEventManager(new TouchEventManager(frame)),
-      m_mouseEventManager(mouseEventManager) {
-  clear();
-}
-
-void PointerEventManager::clear() {
-  for (auto& entry : m_preventMouseEventForPointerType)
-    entry = false;
-  m_touchEventManager->clear();
-  m_inCanceledStateForPointerTypeTouch = false;
-  m_pointerEventFactory.clear();
-  m_touchIdsForCanceledPointerdowns.clear();
-  m_nodeUnderPointer.clear();
-  m_pointerCaptureTarget.clear();
-  m_pendingPointerCaptureTarget.clear();
-}
-
 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) {
-  if (setPointerPosition) {
-    processPendingPointerCapture(pointerEvent);
+    bool sendMouseEvent) {
+  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) {
-    // lastNodeUnderMouse is needed here because it is still stored in EventHandler.
-    m_mouseEventManager->sendBoundaryEvents(lastNodeUnderMouse, hitTestTarget,
-                                            mouseEvent);
+    m_mouseEventManager->setNodeUnderMouse(
+        hitTestTarget ? hitTestTarget->toNode() : nullptr, mouseEvent);
   }
   return hitTestTarget;
 }
 
 void PointerEventManager::processPendingPointerCapture(
     PointerEvent* pointerEvent) {
   EventTarget* pointerCaptureTarget;
   EventTarget* pendingPointerCaptureTarget;
   const int pointerId = pointerEvent->pointerId();
   const bool isCaptureChanged = getPointerCaptureState(
@@ skipping 117 matching lines @@
     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);
-  visitor->trace(m_mouseEventManager);
-}
-
 }  // namespace blink