Extract more of the mouse logic from EventHandler

third_party/WebKit/Source/core/input/GestureManager.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/GestureManager.h"
 
 #include "core/dom/Document.h"
 #include "core/editing/SelectionController.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/input/EventHandler.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 
 namespace blink {
 
 GestureManager::GestureManager(LocalFrame* frame,
                                ScrollManager* scrollManager,
+                               MouseEventManager* mouseEventManager,
                                PointerEventManager* pointerEventManager,
                                SelectionController* selectionController)
     : m_frame(frame),
       m_scrollManager(scrollManager),
+      m_mouseEventManager(mouseEventManager),
       m_pointerEventManager(pointerEventManager),
       m_selectionController(selectionController) {
   clear();
 }
 
 void GestureManager::clear() {
   m_suppressMouseEventsFromGestures = false;
   m_longTapShouldInvokeContextMenu = false;
   m_lastShowPressTimestamp = 0;
 }
 
 DEFINE_TRACE(GestureManager) {
   visitor->trace(m_frame);
+  visitor->trace(m_scrollManager);
+  visitor->trace(m_mouseEventManager);
+  visitor->trace(m_pointerEventManager);
   visitor->trace(m_selectionController);
-  visitor->trace(m_pointerEventManager);
-  visitor->trace(m_scrollManager);
 }
 
 HitTestRequest::HitTestRequestType GestureManager::getHitTypeForGestureType(
     PlatformEvent::EventType type) {
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent;
   switch (type) {
     case PlatformEvent::GestureShowPress:
     case PlatformEvent::GestureTapUnconfirmed:
       return hitType | HitTestRequest::Active;
     case PlatformEvent::GestureTapDownCancel:
@@ skipping 93 matching lines @@
 
   const unsigned modifiers = gestureEvent.getModifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
     PlatformMouseEvent fakeMouseMove(
         gestureEvent.position(), gestureEvent.globalPosition(),
         WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
         WebPointerProperties::PointerType::Mouse);
-    m_frame->eventHandler().dispatchMouseEvent(EventTypeNames::mousemove,
-                                               currentHitTest.innerNode(), 0,
-                                               fakeMouseMove);
+    m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+        currentHitTest.innerNode(), EventTypeNames::mousemove, fakeMouseMove);
   }
 
   // Do a new hit-test in case the mousemove event changed the DOM.
   // Note that if the original hit test wasn't over an element (eg. was over a scrollbar) we
   // don't want to re-hit-test because it may be in the wrong frame (and there's no way the page
   // could have seen the event anyway).
   // Also note that the position of the frame may have changed, so we need to recompute the content
   // co-ordinates (updating layout/style as hitTestResultAtPoint normally would).
   // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
   if (currentHitTest.innerNode()) {
     LocalFrame* mainFrame = m_frame->localFrameRoot();
     if (mainFrame && mainFrame->view())
       mainFrame->view()->updateLifecycleToCompositingCleanPlusScrolling();
     adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
   // Capture data for showUnhandledTapUIIfNeeded.
   Node* tappedNode = currentHitTest.innerNode();
   IntPoint tappedPosition = gestureEvent.position();
   Node* tappedNonTextNode = tappedNode;
 
   if (tappedNonTextNode && tappedNonTextNode->isTextNode())
     tappedNonTextNode = FlatTreeTraversal::parent(*tappedNonTextNode);
 
-  m_frame->eventHandler().setClickNode(tappedNonTextNode);
+  m_mouseEventManager->setClickNode(tappedNonTextNode);
 
   PlatformMouseEvent fakeMouseDown(
       gestureEvent.position(), gestureEvent.globalPosition(),
       WebPointerProperties::Button::Left, PlatformEvent::MousePressed,
       gestureEvent.tapCount(), static_cast<PlatformEvent::Modifiers>(
                                    modifiers | PlatformEvent::LeftButtonDown),
       PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
       WebPointerProperties::PointerType::Mouse);
 
   // TODO(mustaq): We suppress MEs plus all it's side effects. What would that
   // mean for for TEs?  What's the right balance here? crbug.com/617255
   WebInputEventResult mouseDownEventResult =
       WebInputEventResult::HandledSuppressed;
   if (!m_suppressMouseEventsFromGestures) {
-    mouseDownEventResult = m_frame->eventHandler().dispatchMouseEvent(
-        EventTypeNames::mousedown, currentHitTest.innerNode(),
-        gestureEvent.tapCount(), fakeMouseDown);
+    m_mouseEventManager->setClickCount(gestureEvent.tapCount());
+
+    mouseDownEventResult =
+        m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+            currentHitTest.innerNode(), EventTypeNames::mousedown,
+            fakeMouseDown);
     m_selectionController->initializeSelectionState();
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
-      mouseDownEventResult = m_frame->eventHandler().handleMouseFocus(
+      mouseDownEventResult = m_mouseEventManager->handleMouseFocus(
           currentHitTest,
           InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
-      mouseDownEventResult = m_frame->eventHandler().handleMousePressEvent(
+      mouseDownEventResult = m_mouseEventManager->handleMousePressEvent(
           MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
   }
 
   if (currentHitTest.innerNode()) {
     DCHECK(gestureEvent.type() == PlatformEvent::GestureTap);
     HitTestResult result = currentHitTest;
     result.setToShadowHostIfInUserAgentShadowRoot();
     m_frame->chromeClient().onMouseDown(result.innerNode());
   }
 
   // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
   if (currentHitTest.innerNode()) {
     LocalFrame* mainFrame = m_frame->localFrameRoot();
     if (mainFrame && mainFrame->view())
       mainFrame->view()->updateAllLifecyclePhases();
     adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
   PlatformMouseEvent fakeMouseUp(
       gestureEvent.position(), gestureEvent.globalPosition(),
       WebPointerProperties::Button::Left, PlatformEvent::MouseReleased,
       gestureEvent.tapCount(), static_cast<PlatformEvent::Modifiers>(modifiers),
       PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
       WebPointerProperties::PointerType::Mouse);
   WebInputEventResult mouseUpEventResult =
       m_suppressMouseEventsFromGestures
           ? WebInputEventResult::HandledSuppressed
-          : m_frame->eventHandler().dispatchMouseEvent(
-                EventTypeNames::mouseup, currentHitTest.innerNode(),
-                gestureEvent.tapCount(), fakeMouseUp);
+          : m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+                currentHitTest.innerNode(), EventTypeNames::mouseup,
+                fakeMouseUp);
 
   WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
   if (tappedNonTextNode) {
     if (currentHitTest.innerNode()) {
       // Updates distribution because a mouseup (or mousedown) event listener can make the
       // tree dirty at dispatchMouseEvent() invocation above.
       // Unless distribution is updated, commonAncestor would hit DCHECK.
       // Both tappedNonTextNode and currentHitTest.innerNode()) don't need to be updated
       // because commonAncestor() will exit early if their documents are different.
       tappedNonTextNode->updateDistribution();
       Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(
-          *tappedNonTextNode, EventHandler::parentForClickEvent);
-      clickEventResult = m_frame->eventHandler().dispatchMouseEvent(
-          EventTypeNames::click, clickTargetNode, gestureEvent.tapCount(),
-          fakeMouseUp);
+          *tappedNonTextNode, EventHandlingUtil::parentForClickEvent);
+      clickEventResult =
+          m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+              clickTargetNode, EventTypeNames::click, fakeMouseUp);
     }
-    m_frame->eventHandler().setClickNode(nullptr);
+    m_mouseEventManager->setClickNode(nullptr);
   }
 
   if (mouseUpEventResult == WebInputEventResult::NotHandled)
-    mouseUpEventResult = m_frame->eventHandler().handleMouseReleaseEvent(
+    mouseUpEventResult = m_mouseEventManager->handleMouseReleaseEvent(
         MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
-  m_frame->eventHandler().clearDragHeuristicState();
+  m_mouseEventManager->clearDragHeuristicState();
 
   WebInputEventResult eventResult = EventHandlingUtil::mergeEventResult(
       EventHandlingUtil::mergeEventResult(mouseDownEventResult,
                                           mouseUpEventResult),
       clickEventResult);
   if (eventResult == WebInputEventResult::NotHandled && tappedNode &&
       m_frame->page()) {
     bool domTreeChanged =
         preDispatchDomTreeVersion != m_frame->document()->domTreeVersion();
     bool styleChanged =
@@ skipping 19 matching lines @@
       m_frame->view()->rootFrameToContents(gestureEvent.position());
   HitTestResult hitTestResult =
       m_frame->eventHandler().hitTestResultAtPoint(hitTestPoint);
 
   m_longTapShouldInvokeContextMenu = false;
   bool hitTestContainsLinks = hitTestResult.URLElement() ||
                               !hitTestResult.absoluteImageURL().isNull() ||
                               !hitTestResult.absoluteMediaURL().isNull();
 
   if (!hitTestContainsLinks &&
-      m_frame->eventHandler().handleDragDropIfPossible(targetedEvent)) {
+      m_mouseEventManager->handleDragDropIfPossible(targetedEvent)) {
     m_longTapShouldInvokeContextMenu = true;
     return WebInputEventResult::HandledSystem;
   }
 
   if (m_selectionController->handleGestureLongPress(gestureEvent,
                                                     hitTestResult)) {
-    m_frame->eventHandler().focusDocumentView();
+    m_mouseEventManager->focusDocumentView();
     return WebInputEventResult::HandledSystem;
   }
 
   return sendContextMenuEventForGesture(targetedEvent);
 }
 
 WebInputEventResult GestureManager::handleGestureLongTap(
     const GestureEventWithHitTestResults& targetedEvent) {
 #if !OS(ANDROID)
   if (m_longTapShouldInvokeContextMenu) {
@@ skipping 15 matching lines @@
   unsigned modifiers = gestureEvent.getModifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
     // Send MouseMoved event prior to handling (https://crbug.com/485290).
     PlatformMouseEvent fakeMouseMove(
         gestureEvent.position(), gestureEvent.globalPosition(),
         WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
         PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
         WebPointerProperties::PointerType::Mouse);
-    m_frame->eventHandler().dispatchMouseEvent(
-        EventTypeNames::mousemove, targetedEvent.hitTestResult().innerNode(), 0,
+    m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+        targetedEvent.hitTestResult().innerNode(), EventTypeNames::mousemove,
         fakeMouseMove);
   }
 
   PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
   if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
     eventType = PlatformEvent::MouseReleased;
   PlatformMouseEvent mouseEvent(
       targetedEvent.event().position(), targetedEvent.event().globalPosition(),
       WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
       static_cast<PlatformEvent::Modifiers>(modifiers),
       PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(),
       WebPointerProperties::PointerType::Mouse);
 
   if (!m_suppressMouseEventsFromGestures && m_frame->view()) {
     HitTestRequest request(HitTestRequest::Active);
     LayoutPoint documentPoint =
         m_frame->view()->rootFrameToContents(targetedEvent.event().position());
-    MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(
-        request, documentPoint, mouseEvent);
+    MouseEventWithHitTestResults mev =
+        m_frame->document()->performMouseEventHitTest(request, documentPoint,
+                                                      mouseEvent);
 
     WebInputEventResult eventResult =
-        m_frame->eventHandler().dispatchMouseEvent(
-            EventTypeNames::mousedown, mev.innerNode(), /* clickCount */ 0,
-            mouseEvent);
+        m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
+            mev.innerNode(), EventTypeNames::mousedown, mouseEvent);
 
     if (eventResult == WebInputEventResult::NotHandled)
-      eventResult = m_frame->eventHandler().handleMouseFocus(
+      eventResult = m_mouseEventManager->handleMouseFocus(
           mev.hitTestResult(),
           InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
 
     if (eventResult == WebInputEventResult::NotHandled)
-      m_frame->eventHandler().handleMousePressEvent(mev);
+      m_mouseEventManager->handleMousePressEvent(mev);
   }
 
   return m_frame->eventHandler().sendContextMenuEvent(mouseEvent);
 }
 
 WebInputEventResult GestureManager::handleGestureShowPress() {
   m_lastShowPressTimestamp = WTF::monotonicallyIncreasingTime();
 
   FrameView* view = m_frame->view();
   if (!view)
@@ skipping 16 matching lines @@
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 double GestureManager::getLastShowPressTimestamp() const {
   return m_lastShowPressTimestamp;
 }
 
 }  // namespace blink