Create MouseEventManager and EventHandlingUtil

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 45 matching lines @@
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameSetElement.h"
 #include "core/html/HTMLInputElement.h"
+#include "core/input/EventHandlingUtil.h"
 #include "core/input/InputDeviceCapabilities.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTextControlSingleLine.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
@@ skipping 108 matching lines @@
     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
     , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
     , m_mouseDownMayStartAutoscroll(false)
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
-    , m_pointerEventManager(frame)
-    , m_scrollManager(frame)
-    , m_keyboardEventManager(frame, &m_scrollManager)
-    , m_gestureManager(frame, &m_scrollManager, &m_pointerEventManager, m_selectionController)
+    , m_scrollManager(new ScrollManager(frame))
+    , m_mouseEventManager(new MouseEventManager(frame))
+    , m_keyboardEventManager(new KeyboardEventManager(frame, m_scrollManager))
+    , m_pointerEventManager(new PointerEventManager(frame, m_mouseEventManager))
+    , m_gestureManager(new GestureManager(frame, m_scrollManager, m_pointerEventManager, m_selectionController))
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_mousePressNode);
+    visitor->trace(m_selectionController);
     visitor->trace(m_capturingMouseEventsNode);
     visitor->trace(m_nodeUnderMouse);
     visitor->trace(m_lastMouseMoveEventSubframe);
     visitor->trace(m_lastScrollbarUnderMouse);
     visitor->trace(m_clickNode);
     visitor->trace(m_dragTarget);
     visitor->trace(m_frameSetBeingResized);
+    visitor->trace(m_scrollManager);
+    visitor->trace(m_mouseEventManager);
+    visitor->trace(m_keyboardEventManager);
+    visitor->trace(m_pointerEventManager);
+    visitor->trace(m_gestureManager);
     visitor->trace(m_lastDeferredTapElement);
-    visitor->trace(m_selectionController);
-    visitor->trace(m_pointerEventManager);
-    visitor->trace(m_scrollManager);
-    visitor->trace(m_keyboardEventManager);
-    visitor->trace(m_gestureManager);
 }
 
 DragState& EventHandler::dragState()
 {
     DEFINE_STATIC_LOCAL(DragState, state, (new DragState));
     return state;
 }
 
 void EventHandler::clear()
 {
@@ skipping 10 matching lines @@
     m_dragTarget = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
     m_mousePositionIsUnknown = true;
     m_lastKnownMousePosition = IntPoint();
     m_lastKnownMouseGlobalPosition = IntPoint();
     m_lastMouseDownUserGestureToken.clear();
     m_mousePressNode = nullptr;
     m_mousePressed = false;
     m_capturesDragging = false;
     m_capturingMouseEventsNode = nullptr;
-    m_pointerEventManager.clear();
-    m_scrollManager.clear();
-    m_gestureManager.clear();
+    m_pointerEventManager->clear();
+    m_scrollManager->clear();
+    m_gestureManager->clear();
+    m_mouseEventManager->clear();
     m_mouseDownMayStartDrag = false;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
     m_dragStartPos = LayoutPoint();
     m_mouseDown = PlatformMouseEvent();
 }
 
-WebInputEventResult EventHandler::mergeEventResult(
-    WebInputEventResult resultA, WebInputEventResult resultB)
-{
-    // The ordering of the enumeration is specific. There are times that
-    // multiple events fire and we need to combine them into a single
-    // result code. The enumeration is based on the level of consumption that
-    // is most significant. The enumeration is ordered with smaller specified
-    // numbers first. Examples of merged results are:
-    // (HandledApplication, HandledSystem) -> HandledSystem
-    // (NotHandled, HandledApplication) -> HandledApplication
-    static_assert(static_cast<int>(WebInputEventResult::NotHandled) == 0, "WebInputEventResult not ordered");
-    static_assert(static_cast<int>(WebInputEventResult::HandledSuppressed) < static_cast<int>(WebInputEventResult::HandledApplication), "WebInputEventResult not ordered");
-    static_assert(static_cast<int>(WebInputEventResult::HandledApplication) < static_cast<int>(WebInputEventResult::HandledSystem), "WebInputEventResult not ordered");
-    return static_cast<WebInputEventResult>(max(static_cast<int>(resultA), static_cast<int>(resultB)));
-}
-
-WebInputEventResult EventHandler::toWebInputEventResult(
-    DispatchEventResult result)
-{
-    switch (result) {
-    case DispatchEventResult::NotCanceled:
-        return WebInputEventResult::NotHandled;
-    case DispatchEventResult::CanceledByEventHandler:
-        return WebInputEventResult::HandledApplication;
-    case DispatchEventResult::CanceledByDefaultEventHandler:
-        return WebInputEventResult::HandledSystem;
-    case DispatchEventResult::CanceledBeforeDispatch:
-        return WebInputEventResult::HandledSuppressed;
-    default:
-        ASSERT_NOT_REACHED();
-        return WebInputEventResult::HandledSystem;
-    }
-}
-
 void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)
 {
     if (nodeToBeRemoved.isShadowIncludingInclusiveAncestorOf(m_clickNode.get())) {
         // We don't dispatch click events if the mousedown node is removed
         // before a mouseup event. It is compatible with IE and Firefox.
         m_clickNode = nullptr;
     }
 }
 
 WebInputEventResult EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
@@ skipping 92 matching lines @@
         if (!parent)
             return WebInputEventResult::NotHandled;
 
         layoutObject = parent->layoutObject();
         if (!layoutObject || !layoutObject->isListBox())
             return WebInputEventResult::NotHandled;
     }
 
     m_mouseDownMayStartDrag = false;
 
-    if (m_mouseDownMayStartAutoscroll && !m_scrollManager.panScrollInProgress()) {
-        if (AutoscrollController* controller = m_scrollManager.autoscrollController()) {
+    if (m_mouseDownMayStartAutoscroll && !m_scrollManager->panScrollInProgress()) {
+        if (AutoscrollController* controller = m_scrollManager->autoscrollController()) {
             controller->startAutoscrollForSelection(layoutObject);
             m_mouseDownMayStartAutoscroll = false;
         }
     }
 
     selectionController().handleMouseDraggedEvent(event, m_mouseDownPos, m_dragStartPos, m_mousePressNode.get(), m_lastKnownMousePosition);
     return WebInputEventResult::HandledSystem;
 }
 
 void EventHandler::updateSelectionForMouseDrag()
 {
     selectionController().updateSelectionForMouseDrag(m_mousePressNode.get(), m_dragStartPos, m_lastKnownMousePosition);
 }
 
+// TODO(nzolghadr): Refactor the mouse related functions to MouseEventManager.
 WebInputEventResult EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
 {
-    AutoscrollController* controller = m_scrollManager.autoscrollController();
+    AutoscrollController* controller = m_scrollManager->autoscrollController();
     if (controller && controller->autoscrollInProgress())
-        m_scrollManager.stopAutoscroll();
+        m_scrollManager->stopAutoscroll();
 
     return selectionController().handleMouseReleaseEvent(event, m_dragStartPos) ? WebInputEventResult::HandledSystem : WebInputEventResult::NotHandled;
 }
 
 #if OS(WIN)
 
 void EventHandler::startPanScrolling(LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
         return;
-    AutoscrollController* controller = m_scrollManager.autoscrollController();
+    AutoscrollController* controller = m_scrollManager->autoscrollController();
     if (!controller)
         return;
     controller->startPanScrolling(toLayoutBox(layoutObject), lastKnownMousePosition());
     invalidateClick();
 }
 
 #endif // OS(WIN)
 
 HitTestResult EventHandler::hitTestResultAtPoint(const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType, const LayoutSize& padding)
 {
@@ skipping 30 matching lines @@
 
     m_frame->contentLayoutItem().hitTest(result);
     if (!request.readOnly())
         m_frame->document()->updateHoverActiveState(request, result.innerElement());
 
     return result;
 }
 
 void EventHandler::stopAutoscroll()
 {
-    m_scrollManager.stopAutoscroll();
+    m_scrollManager->stopAutoscroll();
 }
 
 // TODO(bokan): This should be merged with logicalScroll assuming
 // defaultSpaceEventHandler's chaining scroll can be done crossing frames.
 bool EventHandler::bubblingScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
-    return m_scrollManager.bubblingScroll(direction, granularity, startingNode, m_mousePressNode);
+    return m_scrollManager->bubblingScroll(direction, granularity, startingNode, m_mousePressNode);
 }
 
 IntPoint EventHandler::lastKnownMousePosition() const
 {
     return m_lastKnownMousePosition;
 }
 
 IntPoint EventHandler::dragDataTransferLocationForTesting()
 {
     if (dragState().m_dragDataTransfer)
@@ skipping 74 matching lines @@
     if (LocalFrame* frame = result.innerNodeFrame()) {
         OptionalCursor optionalCursor = frame->eventHandler().selectCursor(result);
         if (optionalCursor.isCursorChange()) {
             view->setCursor(optionalCursor.cursor());
         }
     }
 }
 
 OptionalCursor EventHandler::selectCursor(const HitTestResult& result)
 {
-    if (m_scrollManager.inResizeMode())
+    if (m_scrollManager->inResizeMode())
         return NoCursorChange;
 
     Page* page = m_frame->page();
     if (!page)
         return NoCursorChange;
-    if (m_scrollManager.panScrollInProgress())
+    if (m_scrollManager->panScrollInProgress())
         return NoCursorChange;
 
     Node* node = result.innerPossiblyPseudoNode();
     if (!node)
         return selectAutoCursor(result, node, iBeamCursor());
 
     LayoutObject* layoutObject = node->layoutObject();
     const ComputedStyle* style = layoutObject ? layoutObject->style() : nullptr;
 
     if (layoutObject) {
@@ skipping 212 matching lines @@
             m_capturingMouseEventsNode = mev.innerNode();
             m_eventHandlerWillResetCapturingMouseEventsNode = true;
         }
         invalidateClick();
         return result;
     }
 
 #if OS(WIN)
     // We store whether pan scrolling is in progress before calling stopAutoscroll()
     // because it will set m_autoscrollType to NoAutoscroll on return.
-    bool isPanScrollInProgress = m_scrollManager.panScrollInProgress();
-    m_scrollManager.stopAutoscroll();
+    bool isPanScrollInProgress = m_scrollManager->panScrollInProgress();
+    m_scrollManager->stopAutoscroll();
     if (isPanScrollInProgress) {
         // We invalidate the click when exiting pan scrolling so that we don't inadvertently navigate
         // away from the current page (e.g. the click was on a hyperlink). See <rdar://problem/6095023>.
         invalidateClick();
         return WebInputEventResult::HandledSuppressed;
     }
 #endif
 
     m_clickCount = mouseEvent.clickCount();
     m_clickNode = mev.innerNode()->isTextNode() ?  FlatTreeTraversal::parent(*mev.innerNode()) : mev.innerNode();
 
     if (!mouseEvent.fromTouch())
         m_frame->selection().setCaretBlinkingSuspended(true);
 
     WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mev.event());
 
     if (eventResult == WebInputEventResult::NotHandled && m_frame->view()) {
         FrameView* view = m_frame->view();
         PaintLayer* layer = mev.innerNode()->layoutObject() ? mev.innerNode()->layoutObject()->enclosingLayer() : nullptr;
         IntPoint p = view->rootFrameToContents(mouseEvent.position());
         if (layer && layer->getScrollableArea() && layer->getScrollableArea()->isPointInResizeControl(p, ResizerForPointer)) {
-            m_scrollManager.setResizeScrollableArea(layer, p);
+            m_scrollManager->setResizeScrollableArea(layer, p);
             return WebInputEventResult::HandledSystem;
         }
     }
 
     // m_selectionInitiationState is initialized after dispatching mousedown
     // event in order not to keep the selection by DOM APIs because we can't
     // give the user the chance to handle the selection by user action like
     // dragging if we keep the selection in case of mousedown. FireFox also has
     // the same behavior and it's more compatible with other browsers.
     selectionController().initializeSelectionState();
-    HitTestResult hitTestResult = hitTestResultInFrame(m_frame, documentPoint, HitTestRequest::ReadOnly);
+    HitTestResult hitTestResult = EventHandlingUtil::hitTestResultInFrame(m_frame, documentPoint, HitTestRequest::ReadOnly);
     InputDeviceCapabilities* sourceCapabilities = mouseEvent.getSyntheticEventType() == PlatformMouseEvent::FromTouch ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities() :
         InputDeviceCapabilities::doesntFireTouchEventsSourceCapabilities();
     if (eventResult == WebInputEventResult::NotHandled)
         eventResult = handleMouseFocus(hitTestResult, sourceCapabilities);
     m_capturesDragging = eventResult == WebInputEventResult::NotHandled || mev.scrollbar();
 
     // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
     // in case the scrollbar widget was destroyed when the mouse event was handled.
     if (mev.scrollbar()) {
         const bool wasLastScrollBar = mev.scrollbar() == m_lastScrollbarUnderMouse.get();
@@ skipping 122 matching lines @@
         hitType |= HitTestRequest::Active;
     } else if (onlyUpdateScrollbars) {
         // Mouse events should be treated as "read-only" if we're updating only scrollbars. This
         // means that :hover and :active freeze in the state they were in, rather than updating
         // for nodes the mouse moves while the window is not key (which will be the case if
         // onlyUpdateScrollbars is true).
         hitType |= HitTestRequest::ReadOnly;
     }
 
     // Treat any mouse move events as readonly if the user is currently touching the screen.
-    if (m_pointerEventManager.isAnyTouchActive())
+    if (m_pointerEventManager->isAnyTouchActive())
         hitType |= HitTestRequest::Active | HitTestRequest::ReadOnly;
     HitTestRequest request(hitType);
     MouseEventWithHitTestResults mev = MouseEventWithHitTestResults(mouseEvent, HitTestResult(request, LayoutPoint()));
 
     // We don't want to do a hit-test in forceLeave scenarios because there might actually be some other frame above this one at the specified co-ordinate.
     // So we must force the hit-test to fail, while still clearing hover/active state.
     if (forceLeave)
         m_frame->document()->updateHoverActiveState(request, 0);
     else
         mev = prepareMouseEvent(request, mouseEvent);
 
     if (hoveredNode)
         *hoveredNode = mev.hitTestResult();
 
     Scrollbar* scrollbar = nullptr;
 
-    if (m_scrollManager.inResizeMode()) {
-        m_scrollManager.resize(mev.event());
+    if (m_scrollManager->inResizeMode()) {
+        m_scrollManager->resize(mev.event());
     } else {
         if (!scrollbar)
             scrollbar = mev.scrollbar();
 
         updateLastScrollbarUnderMouse(scrollbar, !m_mousePressed);
         if (onlyUpdateScrollbars)
             return WebInputEventResult::HandledSuppressed;
     }
 
     WebInputEventResult eventResult = WebInputEventResult::NotHandled;
@@ skipping 136 matching lines @@
             m_clickNode->updateDistribution();
             mev.innerNode()->updateDistribution();
             clickTargetNode = mev.innerNode()->commonAncestor(
                 *m_clickNode, parentForClickEvent);
         }
         if (clickTargetNode) {
             // Dispatch mouseup directly w/o calling updateMouseEventTargetNodeAndSendEvents
             // because the mouseup dispatch above has already updated it
             // correctly. Moreover, clickTargetNode is different from
             // mev.innerNode at drag-release.
-            clickEventResult = toWebInputEventResult(clickTargetNode->dispatchMouseEvent(mev.event(),
-                !RuntimeEnabledFeatures::auxclickEnabled()
-                || (mev.event().pointerProperties().button == WebPointerProperties::Button::Left)
-                    ? EventTypeNames::click
-                    : EventTypeNames::auxclick,
-                m_clickCount));
+            clickEventResult = EventHandlingUtil::toWebInputEventResult(
+                clickTargetNode->dispatchMouseEvent(mev.event(),
+                    !RuntimeEnabledFeatures::auxclickEnabled()
+                    || (mev.event().pointerProperties().button == WebPointerProperties::Button::Left)
+                        ? EventTypeNames::click
+                        : EventTypeNames::auxclick,
+                    m_clickCount));
         }
     }
 
-    m_scrollManager.clearResizeScrollableArea(false);
+    m_scrollManager->clearResizeScrollableArea(false);
 
     if (eventResult == WebInputEventResult::NotHandled)
         eventResult = handleMouseReleaseEvent(mev);
     clearDragHeuristicState();
 
     invalidateClick();
 
-    return mergeEventResult(clickEventResult, eventResult);
+    return EventHandlingUtil::mergeEventResult(clickEventResult, eventResult);
 }
 
 WebInputEventResult EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     FrameView* view = m_frame->view();
 
     // FIXME: We might want to dispatch a dragleave even if the view is gone.
     if (!view)
         return WebInputEventResult::NotHandled;
 
     DragEvent* me = DragEvent::create(eventType,
         true, true, m_frame->document()->domWindow(),
         0, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
         event.movementDelta().x(), event.movementDelta().y(),
         event.getModifiers(),
         0, MouseEvent::platformModifiersToButtons(event.getModifiers()), nullptr, event.timestamp(), dataTransfer, event.getSyntheticEventType());
 
-    return toWebInputEventResult(dragTarget->dispatchEvent(me));
+    return EventHandlingUtil::toWebInputEventResult(dragTarget->dispatchEvent(me));
 }
 
 static bool targetIsFrame(Node* target, LocalFrame*& frame)
 {
     if (!isHTMLFrameElementBase(target))
         return false;
 
     // Cross-process drag and drop is not yet supported.
     if (toHTMLFrameElementBase(target)->contentFrame() && !toHTMLFrameElementBase(target)->contentFrame()->isLocalFrame())
         return false;
@@ skipping 49 matching lines @@
         return eventResult;
 
     HitTestRequest request(HitTestRequest::ReadOnly);
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
 
     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
     Node* newTarget = mev.innerNode();
     if (newTarget && newTarget->isTextNode())
         newTarget = FlatTreeTraversal::parent(*newTarget);
 
-    if (AutoscrollController* controller = m_scrollManager.autoscrollController())
+    if (AutoscrollController* controller = m_scrollManager->autoscrollController())
         controller->updateDragAndDrop(newTarget, event.position(), event.timestamp());
 
     if (m_dragTarget != newTarget) {
         // FIXME: this ordering was explicitly chosen to match WinIE. However,
         // it is sometimes incorrect when dragging within subframes, as seen with
         // LayoutTests/fast/events/drag-in-frames.html.
         //
         // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
         LocalFrame* targetFrame;
         if (targetIsFrame(newTarget, targetFrame)) {
@@ skipping 77 matching lines @@
     // Used to prevent mouseMoveEvent from initiating a drag before
     // the mouse is pressed again.
     m_mousePressed = false;
     m_capturesDragging = false;
     m_mouseDownMayStartDrag = false;
     m_mouseDownMayStartAutoscroll = false;
 }
 
 void EventHandler::clearDragState()
 {
-    m_scrollManager.stopAutoscroll();
+    m_scrollManager->stopAutoscroll();
     m_dragTarget = nullptr;
     m_capturingMouseEventsNode = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
 }
 
 void EventHandler::setCapturingMouseEventsNode(Node* n)
 {
     m_capturingMouseEventsNode = n;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
 }
 
 MouseEventWithHitTestResults EventHandler::prepareMouseEvent(const HitTestRequest& request, const PlatformMouseEvent& mev)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->document());
 
     return m_frame->document()->prepareMouseEvent(request, contentPointFromRootFrame(m_frame, mev.position()), mev);
 }
 
 Node* EventHandler::updateMouseEventTargetNode(Node* targetNode,
     const PlatformMouseEvent& mouseEvent)
 {
     Node* newNodeUnderMouse = targetNode;
 
     // If we're capturing, we always go right to that node.
-    if (EventTarget* mousePointerCapturingNode = m_pointerEventManager.getMouseCapturingNode()) {
+    if (EventTarget* mousePointerCapturingNode = m_pointerEventManager->getMouseCapturingNode()) {
         newNodeUnderMouse = mousePointerCapturingNode->toNode();
         DCHECK(newNodeUnderMouse);
     } else if (m_capturingMouseEventsNode) {
         newNodeUnderMouse = m_capturingMouseEventsNode.get();
     } else {
         // If the target node is a text node, dispatch on the parent node - rdar://4196646
         if (newNodeUnderMouse && newNodeUnderMouse->isTextNode())
             newNodeUnderMouse = FlatTreeTraversal::parent(*newNodeUnderMouse);
     }
     Node* lastNodeUnderMouse = m_nodeUnderMouse;
@@ skipping 32 matching lines @@
         m_lastScrollbarUnderMouse = nullptr;
     }
 
     return lastNodeUnderMouse;
 }
 
 void EventHandler::updateMouseEventTargetNodeAndSendEvents(Node* targetNode,
     const PlatformMouseEvent& mouseEvent, bool isFrameBoundaryTransition)
 {
     Node* lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
-    m_pointerEventManager.sendMouseAndPossiblyPointerBoundaryEvents(
+    m_pointerEventManager->sendMouseAndPossiblyPointerBoundaryEvents(
         lastNodeUnderMouse, m_nodeUnderMouse, mouseEvent,
         isFrameBoundaryTransition);
 }
 
 WebInputEventResult EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     updateMouseEventTargetNodeAndSendEvents(targetNode, mouseEvent);
-    if (!m_nodeUnderMouse)
-        return WebInputEventResult::NotHandled;
 
-    MouseEvent* event = MouseEvent::create(eventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
-    return toWebInputEventResult(m_nodeUnderMouse->dispatchEvent(event));
+    return m_mouseEventManager->dispatchMouseEvent(m_nodeUnderMouse, eventType,
+        mouseEvent, nullptr, clickCount);
 }
 
 bool EventHandler::isPointerEventActive(int pointerId)
 {
-    return m_pointerEventManager.isActive(pointerId);
+    return m_pointerEventManager->isActive(pointerId);
 }
 
 void EventHandler::setPointerCapture(int pointerId, EventTarget* target)
 {
     // TODO(crbug.com/591387): This functionality should be per page not per frame.
-    m_pointerEventManager.setPointerCapture(pointerId, target);
+    m_pointerEventManager->setPointerCapture(pointerId, target);
 }
 
 void EventHandler::releasePointerCapture(int pointerId, EventTarget* target)
 {
-    m_pointerEventManager.releasePointerCapture(pointerId, target);
+    m_pointerEventManager->releasePointerCapture(pointerId, target);
 }
 
 bool EventHandler::hasPointerCapture(int pointerId, const EventTarget* target) const
 {
-    return m_pointerEventManager.hasPointerCapture(pointerId, target);
+    return m_pointerEventManager->hasPointerCapture(pointerId, target);
 }
 
 bool EventHandler::hasProcessedPointerCapture(int pointerId, const EventTarget* target) const
 {
-    return m_pointerEventManager.hasProcessedPointerCapture(pointerId, target);
+    return m_pointerEventManager->hasProcessedPointerCapture(pointerId, target);
 }
 
 void EventHandler::elementRemoved(EventTarget* target)
 {
-    m_pointerEventManager.elementRemoved(target);
+    m_pointerEventManager->elementRemoved(target);
 }
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
 WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(mouseEventType == EventTypeNames::mousedown
         || mouseEventType == EventTypeNames::mousemove
         || mouseEventType == EventTypeNames::mouseup);
 
     Node* lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
 
     Node* newNodeUnderMouse = nullptr;
-    const auto& eventResult = m_pointerEventManager.sendMousePointerEvent(
+    const auto& eventResult = m_pointerEventManager->sendMousePointerEvent(
         m_nodeUnderMouse, mouseEventType, clickCount, mouseEvent,
         lastNodeUnderMouse, &newNodeUnderMouse);
     m_nodeUnderMouse = newNodeUnderMouse;
     return eventResult;
 }
 
 void EventHandler::setClickNode(Node* node)
 {
     m_clickNode = node;
 }
@@ skipping 114 matching lines @@
         node = FlatTreeTraversal::parent(*node);
 
     // If we're over the frame scrollbar, scroll the document.
     if (!node && result.scrollbar())
         node = doc->documentElement();
 
     LocalFrame* subframe = subframeForTargetNode(node);
     if (subframe) {
         WebInputEventResult result = subframe->eventHandler().handleWheelEvent(event);
         if (result != WebInputEventResult::NotHandled)
-            m_scrollManager.setFrameWasScrolledByUser();
+            m_scrollManager->setFrameWasScrolledByUser();
         return result;
     }
 
     if (node) {
         WheelEvent* domEvent = WheelEvent::create(event, node->document().domWindow());
         DispatchEventResult domEventResult = node->dispatchEvent(domEvent);
         if (domEventResult != DispatchEventResult::NotCanceled)
-            return toWebInputEventResult(domEventResult);
+            return EventHandlingUtil::toWebInputEventResult(domEventResult);
     }
 
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 {
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_frame->localFrameRoot());
 
@@ skipping 22 matching lines @@
 
     // update mouseout/leave/over/enter events before jumping directly to the inner most frame
     if (targetedEvent.event().type() == PlatformEvent::GestureTap)
         updateGestureTargetNodeForMouseEvent(targetedEvent);
 
     // Route to the correct frame.
     if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
         return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
-    return m_gestureManager.handleGestureEventInFrame(targetedEvent);
+    return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
-    return m_gestureManager.handleGestureEventInFrame(targetedEvent);
+    return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
 
-    return m_scrollManager.handleGestureScrollEvent(gestureEvent);
+    return m_scrollManager->handleGestureScrollEvent(gestureEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
 {
-    return m_scrollManager.handleGestureScrollEnd(gestureEvent);
+    return m_scrollManager->handleGestureScrollEnd(gestureEvent);
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
-    return m_scrollManager.isScrollbarHandlingGestures();
+    return m_scrollManager->isScrollbarHandlingGestures();
 }
 
 bool EventHandler::shouldApplyTouchAdjustment(const PlatformGestureEvent& event) const
 {
     if (m_frame->settings() && !m_frame->settings()->touchAdjustmentEnabled())
         return false;
     return !event.area().isEmpty();
 }
 
 bool EventHandler::bestClickableNodeForHitTestResult(const HitTestResult& result, IntPoint& targetPoint, Node*& targetNode)
@@ skipping 177 matching lines @@
 }
 
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
 {
     TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
     ASSERT(m_frame == m_frame->localFrameRoot());
     // Scrolling events get hit tested per frame (like wheel events do).
     ASSERT(!gestureEvent.isScrollEvent());
 
-    HitTestRequest::HitTestRequestType hitType = m_gestureManager.getHitTypeForGestureType(gestureEvent.type());
+    HitTestRequest::HitTestRequestType hitType = m_gestureManager->getHitTypeForGestureType(gestureEvent.type());
     double activeInterval = 0;
     bool shouldKeepActiveForMinInterval = false;
     if (readOnly) {
         hitType |= HitTestRequest::ReadOnly;
     } else if (gestureEvent.type() == PlatformEvent::GestureTap) {
         // If the Tap is received very shortly after ShowPress, we want to
         // delay clearing of the active state so that it's visible to the user
         // for at least a couple of frames.
-        activeInterval = WTF::monotonicallyIncreasingTime() - m_gestureManager.getLastShowPressTimestamp();
-        shouldKeepActiveForMinInterval = m_gestureManager.getLastShowPressTimestamp() && activeInterval < minimumActiveInterval;
+        activeInterval = WTF::monotonicallyIncreasingTime() - m_gestureManager->getLastShowPressTimestamp();
+        shouldKeepActiveForMinInterval = m_gestureManager->getLastShowPressTimestamp() && activeInterval < minimumActiveInterval;
         if (shouldKeepActiveForMinInterval)
             hitType |= HitTestRequest::ReadOnly;
     }
 
     GestureEventWithHitTestResults eventWithHitTestResults = hitTestResultForGestureEvent(gestureEvent, hitType);
     // Now apply hover/active state to the final target.
     HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
     if (!request.readOnly())
         updateGestureHoverActiveState(request, eventWithHitTestResults.hitTestResult().innerElement());
 
@@ skipping 27 matching lines @@
     applyTouchAdjustment(&adjustedEvent, &hitTestResult);
 
     // Do a new hit-test at the (adjusted) gesture co-ordinates. This is necessary because
     // rect-based hit testing and touch adjustment sometimes return a different node than
     // what a point-based hit test would return for the same point.
     // FIXME: Fix touch adjustment to avoid the need for a redundant hit test. http://crbug.com/398914
     if (shouldApplyTouchAdjustment(gestureEvent)) {
         LocalFrame* hitFrame = hitTestResult.innerNodeFrame();
         if (!hitFrame)
             hitFrame = m_frame;
-        hitTestResult = hitTestResultInFrame(hitFrame, hitFrame->view()->rootFrameToContents(adjustedEvent.position()), (hitType | HitTestRequest::ReadOnly) & ~HitTestRequest::ListBased);
+        hitTestResult = EventHandlingUtil::hitTestResultInFrame(hitFrame, hitFrame->view()->rootFrameToContents(adjustedEvent.position()), (hitType | HitTestRequest::ReadOnly) & ~HitTestRequest::ListBased);
     }
 
     // If we did a rect-based hit test it must be resolved to the best single node by now to
     // ensure consumers don't accidentally use one of the other candidates.
     ASSERT(!hitTestResult.isRectBasedTest());
 
     return GestureEventWithHitTestResults(adjustedEvent, hitTestResult);
 }
 
 void EventHandler::applyTouchAdjustment(PlatformGestureEvent* gestureEvent, HitTestResult* hitTestResult)
@@ skipping 207 matching lines @@
     return m_frame->page()->isCursorVisible();
 }
 
 void EventHandler::setResizingFrameSet(HTMLFrameSetElement* frameSet)
 {
     m_frameSetBeingResized = frameSet;
 }
 
 void EventHandler::resizeScrollableAreaDestroyed()
 {
-    m_scrollManager.clearResizeScrollableArea(true);
+    m_scrollManager->clearResizeScrollableArea(true);
 }
 
 void EventHandler::hoverTimerFired(TimerBase*)
 {
     TRACE_EVENT0("input", "EventHandler::hoverTimerFired");
     m_hoverTimer.stop();
 
     ASSERT(m_frame);
     ASSERT(m_frame->document());
 
@@ skipping 26 matching lines @@
 void EventHandler::notifyElementActivated()
 {
     // Since another element has been set to active, stop current timer and clear reference.
     if (m_activeIntervalTimer.isActive())
         m_activeIntervalTimer.stop();
     m_lastDeferredTapElement = nullptr;
 }
 
 bool EventHandler::handleAccessKey(const WebKeyboardEvent& evt)
 {
-    return m_keyboardEventManager.handleAccessKey(evt);
+    return m_keyboardEventManager->handleAccessKey(evt);
 }
 
 WebInputEventResult EventHandler::keyEvent(const WebKeyboardEvent& initialKeyEvent)
 {
-    return m_keyboardEventManager.keyEvent(initialKeyEvent);
+    return m_keyboardEventManager->keyEvent(initialKeyEvent);
 }
 
 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event)
 {
-    m_keyboardEventManager.defaultKeyboardEventHandler(event, m_mousePressNode);
+    m_keyboardEventManager->defaultKeyboardEventHandler(event, m_mousePressNode);
 }
 
 bool EventHandler::dragHysteresisExceeded(const IntPoint& dragLocationInRootFrame) const
 {
     FrameView* view = m_frame->view();
     if (!view)
         return false;
     IntPoint dragLocation = view->rootFrameToContents(dragLocationInRootFrame);
     IntSize delta = dragLocation - m_mouseDownPos;
 
@@ skipping 210 matching lines @@
 }
 
 void EventHandler::defaultTextInputEventHandler(TextEvent* event)
 {
     if (m_frame->editor().handleTextEvent(event))
         event->setDefaultHandled();
 }
 
 void EventHandler::capsLockStateMayHaveChanged()
 {
-    m_keyboardEventManager.capsLockStateMayHaveChanged();
+    m_keyboardEventManager->capsLockStateMayHaveChanged();
 }
 
 bool EventHandler::passMousePressEventToScrollbar(MouseEventWithHitTestResults& mev)
 {
     Scrollbar* scrollbar = mev.scrollbar();
     updateLastScrollbarUnderMouse(scrollbar, true);
 
     if (!scrollbar || !scrollbar->enabled())
         return false;
-    m_scrollManager.setFrameWasScrolledByUser();
+    m_scrollManager->setFrameWasScrolledByUser();
     scrollbar->mouseDown(mev.event());
     return true;
 }
 
 // If scrollbar (under mouse) is different from last, send a mouse exited. Set
 // last to scrollbar if setLast is true; else set last to 0.
 void EventHandler::updateLastScrollbarUnderMouse(Scrollbar* scrollbar, bool setLast)
 {
     if (m_lastScrollbarUnderMouse != scrollbar) {
         // Send mouse exited to the old scrollbar.
         if (m_lastScrollbarUnderMouse)
             m_lastScrollbarUnderMouse->mouseExited();
 
         // Send mouse entered if we're setting a new scrollbar.
         if (scrollbar && setLast)
             scrollbar->mouseEntered();
 
         m_lastScrollbarUnderMouse = setLast ? scrollbar : nullptr;
     }
 }
 
-HitTestResult EventHandler::hitTestResultInFrame(LocalFrame* frame, const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType)
-{
-    HitTestResult result(HitTestRequest(hitType), point);
-
-    if (!frame || frame->contentLayoutItem().isNull())
-        return result;
-    if (frame->view()) {
-        IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
-        if (!rect.contains(roundedIntPoint(point)))
-            return result;
-    }
-    frame->contentLayoutItem().hitTest(result);
-    return result;
-}
-
 WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
-    return m_pointerEventManager.handleTouchEvents(event);
+    return m_pointerEventManager->handleTouchEvents(event);
 }
 
 void EventHandler::setLastKnownMousePosition(const PlatformMouseEvent& event)
 {
     m_mousePositionIsUnknown = false;
     m_lastKnownMousePosition = event.position();
     m_lastKnownMouseGlobalPosition = event.globalPosition();
 }
 
 WebInputEventResult EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, LocalFrame* subframe)
@@ skipping 38 matching lines @@
 
 FrameHost* EventHandler::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 } // namespace blink