Add ScrollManager class

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 38 matching lines @@
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
-#include "core/frame/TopControls.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/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"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
 #include "core/page/TouchAdjustment.h"
-#include "core/page/scrolling/OverscrollController.h"
-#include "core/page/scrolling/RootScroller.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/CursorData.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "platform/PlatformTouchEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 38 matching lines @@
 // we'd like to EventHandler::handleMousePressEvent to pass the event to the widget and thus the
 // event target node can't still be the shadow node.
 bool shouldRefetchEventTarget(const MouseEventWithHitTestResults& mev)
 {
     Node* targetNode = mev.innerNode();
     if (!targetNode || !targetNode->parentNode())
         return true;
     return targetNode->isShadowRoot() && isHTMLInputElement(toShadowRoot(targetNode)->host());
 }
 
-// TODO(bokan): This method can go away once all scrolls happen through the
-// scroll customization path.
-void computeScrollChainForSingleNode(Node& node, std::deque<int>& scrollChain)
-{
-    scrollChain.clear();
-
-    ASSERT(node.layoutObject());
-    Element* element = toElement(&node);
-
-    scrollChain.push_front(DOMNodeIds::idForNode(element));
-}
-
-void recomputeScrollChain(const LocalFrame& frame, const Node& startNode,
-    std::deque<int>& scrollChain)
-{
-    scrollChain.clear();
-
-    ASSERT(startNode.layoutObject());
-    LayoutBox* curBox = startNode.layoutObject()->enclosingBox();
-
-    // Scrolling propagates along the containing block chain.
-    while (curBox && !curBox->isLayoutView()) {
-        Node* curNode = curBox->node();
-        // FIXME: this should reject more elements, as part of crbug.com/410974.
-        if (curNode && curNode->isElementNode()) {
-            Element* curElement = toElement(curNode);
-            if (curElement == frame.document()->scrollingElement())
-                break;
-            scrollChain.push_front(DOMNodeIds::idForNode(curElement));
-        }
-        curBox = curBox->containingBlock();
-    }
-    // TODO(tdresser): this should sometimes be excluded, as part of crbug.com/410974.
-    // We need to ensure that the scrollingElement is always part of
-    // the scroll chain. In quirks mode, when the scrollingElement is
-    // the body, some elements may use the documentElement as their
-    // containingBlock, so we ensure the scrollingElement is added
-    // here.
-    scrollChain.push_front(DOMNodeIds::idForNode(frame.document()->scrollingElement()));
-}
-
 } // namespace
 
 using namespace HTMLNames;
 
 // The link drag hysteresis is much larger than the others because there
 // needs to be enough space to cancel the link press without starting a link drag,
 // and because dragging links is rare.
 static const int LinkDragHysteresis = 40;
 static const int ImageDragHysteresis = 5;
 static const int TextDragHysteresis = 3;
@@ skipping 45 matching lines @@
     : m_frame(frame)
     , m_mousePressed(false)
     , m_capturesDragging(false)
     , m_mouseDownMayStartDrag(false)
     , m_selectionController(SelectionController::create(*frame))
     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
     , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
     , m_mouseDownMayStartAutoscroll(false)
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
-    , m_resizeScrollableArea(nullptr)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_pointerEventManager(frame)
-    , m_scrollGestureHandlingNode(nullptr)
-    , m_lastGestureScrollOverWidget(false)
+    , m_scrollManager(frame)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
-    , m_deltaConsumedForScrollSequence(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_mousePressNode);
-    visitor->trace(m_resizeScrollableArea);
     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_scrollbarHandlingScrollGesture);
-    visitor->trace(m_scrollGestureHandlingNode);
-    visitor->trace(m_previousGestureScrolledNode);
     visitor->trace(m_lastDeferredTapElement);
     visitor->trace(m_selectionController);
     visitor->trace(m_pointerEventManager);
+    visitor->trace(m_scrollManager);
 }
 
 DragState& EventHandler::dragState()
 {
     DEFINE_STATIC_LOCAL(DragState, state, (new DragState));
     return state;
 }
 
 void EventHandler::clear()
 {
     m_hoverTimer.stop();
     m_cursorUpdateTimer.stop();
     m_fakeMouseMoveEventTimer.stop();
     m_activeIntervalTimer.stop();
-    m_resizeScrollableArea = nullptr;
     m_nodeUnderMouse = nullptr;
     m_lastMouseMoveEventSubframe = nullptr;
     m_lastScrollbarUnderMouse = nullptr;
     m_clickCount = 0;
     m_clickNode = nullptr;
     m_frameSetBeingResized = nullptr;
     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;
-    clearGestureScrollState();
-    m_lastGestureScrollOverWidget = false;
-    m_scrollbarHandlingScrollGesture = nullptr;
     m_pointerEventManager.clear();
+    m_scrollManager.clear();
     m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
     m_longTapShouldInvokeContextMenu = false;
     m_dragStartPos = LayoutPoint();
-    m_offsetFromResizeCorner = LayoutSize();
     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
@@ skipping 129 matching lines @@
         if (!parent)
             return WebInputEventResult::NotHandled;
 
         layoutObject = parent->layoutObject();
         if (!layoutObject || !layoutObject->isListBox())
             return WebInputEventResult::NotHandled;
     }
 
     m_mouseDownMayStartDrag = false;
 
-    if (m_mouseDownMayStartAutoscroll && !panScrollInProgress()) {
-        if (AutoscrollController* controller = 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);
 }
 
 WebInputEventResult EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
 {
-    AutoscrollController* controller = autoscrollController();
+    AutoscrollController* controller = m_scrollManager.autoscrollController();
     if (controller && controller->autoscrollInProgress())
-        stopAutoscroll();
+        m_scrollManager.stopAutoscroll();
 
     // 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;
 
     return selectionController().handleMouseReleaseEvent(event, m_dragStartPos) ? WebInputEventResult::HandledSystem : WebInputEventResult::NotHandled;
 }
 
 #if OS(WIN)
 
 void EventHandler::startPanScrolling(LayoutObject* layoutObject)

[mustaq, 2016/05/31 16:04:11]

I think it's fine to move startPanScrolling() to scrollManager, even outside
#if. This will give us the chance to include panScrolling in non-Win cases if
needed. Keep the wrapper here plus the click invalidation, inside #if, rename to
startPanScrollingInvalidatingClick.

[Navid Zolghadr, 2016/06/01 17:36:43]

As Bokan suggested let's keep this function here as is and leave this CL for
only moving the code. I'll change this function in the later cleanups.

 {
     if (!layoutObject->isBox())
         return;
-    AutoscrollController* controller = autoscrollController();
+    AutoscrollController* controller = m_scrollManager.autoscrollController();
     if (!controller)
         return;
     controller->startPanScrolling(toLayoutBox(layoutObject), lastKnownMousePosition());
     invalidateClick();
 }
 
 #endif // OS(WIN)
 
-AutoscrollController* EventHandler::autoscrollController() const
-{
-    if (Page* page = m_frame->page())
-        return &page->autoscrollController();
-    return nullptr;
-}
-
-bool EventHandler::panScrollInProgress() const
-{
-    return autoscrollController() && autoscrollController()->panScrollInProgress();
-}
-
 HitTestResult EventHandler::hitTestResultAtPoint(const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType, const LayoutSize& padding)
 {
     TRACE_EVENT0("blink", "EventHandler::hitTestResultAtPoint");
 
     ASSERT((hitType & HitTestRequest::ListBased) || padding.isEmpty());
 
     // We always send hitTestResultAtPoint to the main frame if we have one,
     // otherwise we might hit areas that are obscured by higher frames.
     if (m_frame->page()) {
         LocalFrame* mainFrame = m_frame->localFrameRoot();
@@ skipping 22 matching lines @@
 
     m_frame->contentLayoutItem().hitTest(result);
     if (!request.readOnly())
         m_frame->document()->updateHoverActiveState(request, result.innerElement());
 
     return result;
 }
 
 void EventHandler::stopAutoscroll()
 {
-    if (AutoscrollController* controller = autoscrollController())
-        controller->stopAutoscroll();
-}
-
-ScrollResult EventHandler::scrollBox(LayoutBox* box,
-    ScrollGranularity granularity, const FloatSize& delta,
-    const FloatPoint& position, const FloatSize& velocity,
-    bool* wasRootScroller)
-{
-    ASSERT(box);
-    Node* node = box->node();
-
-    // If there's no ApplyScroll callback on the element, scroll as usuall in
-    // the non-scroll-customization case.
-    if (!node || !node->isElementNode() || !toElement(node)->getApplyScroll()) {
-        *wasRootScroller = false;
-        return box->scroll(granularity, delta);
-    }
-
-    // Viewport actions should only happen when scrolling an element in the
-    // main frame.
-    ASSERT(m_frame->isMainFrame());
-
-    // If there is an ApplyScroll callback, its because we placed one on the
-    // root scroller to control top controls and overscroll. Invoke a scroll
-    // using parts of the scroll customization framework on just this element.
-    computeScrollChainForSingleNode(*node, m_currentScrollChain);
-
-    OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
-    scrollStateData->delta_x = delta.width();
-    scrollStateData->delta_y = delta.height();
-    scrollStateData->position_x = position.x();
-    scrollStateData->position_y = position.y();
-    // TODO(bokan): delta_granularity is meant to be the number of pixels per
-    // unit of delta but we can't determine that until we get to the area we'll
-    // scroll. This is a hack, we stuff the enum into the double value for
-    // now.
-    scrollStateData->delta_granularity = static_cast<double>(granularity);
-    scrollStateData->velocity_x = velocity.width();
-    scrollStateData->velocity_y = velocity.height();
-    scrollStateData->should_propagate = false;
-    scrollStateData->is_in_inertial_phase = false;
-    scrollStateData->from_user_input = true;
-    scrollStateData->delta_consumed_for_scroll_sequence = false;
-    ScrollState* scrollState =
-        ScrollState::create(std::move(scrollStateData));
-
-    customizedScroll(*node, *scrollState);
-
-    ScrollResult result(
-        scrollState->deltaX() != delta.width(),
-        scrollState->deltaY() != delta.height(),
-        scrollState->deltaX(),
-        scrollState->deltaY());
-
-    *wasRootScroller = true;
-    m_currentScrollChain.clear();
-
-    return result;
-}
-
-ScrollResult EventHandler::physicalScroll(ScrollGranularity granularity,
-    const FloatSize& delta, const FloatPoint& position,
-    const FloatSize& velocity, Node* startNode, Node** stopNode, bool* consumed)
-{
-    if (consumed)
-        *consumed = false;
-    if (delta.isZero())
-        return ScrollResult();
-
-    Node* node = startNode;
-    ASSERT(node && node->layoutObject());
-
-    m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-    ScrollResult result;
-
-    LayoutBox* curBox = node->layoutObject()->enclosingBox();
-    while (curBox) {
-        // If we're at the stopNode, we should try to scroll it but we shouldn't
-        // chain past it.
-        bool shouldStopChaining =
-            stopNode && *stopNode && curBox->node() == *stopNode;
-        bool wasRootScroller = false;
-
-        result = scrollBox(
-            curBox,
-            granularity,
-            delta,
-            position,
-            velocity,
-            &wasRootScroller);
-
-        if (result.didScroll() && stopNode)
-            *stopNode = curBox->node();
-
-        if (result.didScroll() || shouldStopChaining) {
-            setFrameWasScrolledByUser();
-            if (consumed)
-                *consumed = true;
-            return result;
-        } else if (wasRootScroller) {
-            // Don't try to chain past the root scroller, even if there's
-            // eligible ancestors.
-            break;
-        }
-
-        curBox = curBox->containingBlock();
-    }
-
-    return result;
-}
-
-bool EventHandler::logicalScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode)
-{
-    Node* node = startNode;
-
-    if (!node)
-        node = m_frame->document()->focusedElement();
-
-    if (!node)
-        node = m_mousePressNode.get();
-
-    if ((!node || !node->layoutObject()) && m_frame->view() && !m_frame->view()->layoutViewItem().isNull())
-        node = m_frame->view()->layoutViewItem().node();
-
-    if (!node)
-        return false;
-
-    m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-    LayoutBox* curBox = node->layoutObject()->enclosingBox();
-    while (curBox) {
-        ScrollDirectionPhysical physicalDirection = toPhysicalDirection(
-            direction, curBox->isHorizontalWritingMode(), curBox->style()->isFlippedBlocksWritingMode());
-
-        ScrollResult result = curBox->scroll(granularity, toScrollDelta(physicalDirection, 1));
-
-        if (result.didScroll()) {
-            setFrameWasScrolledByUser();
-            return true;
-        }
-
-        curBox = curBox->containingBlock();
-    }
-
-    return false;
-}
-
-void EventHandler::customizedScroll(const Node& startNode, ScrollState& scrollState)
-{
-    if (scrollState.fullyConsumed())
-        return;
-
-    if (scrollState.deltaX() || scrollState.deltaY())
-        m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-    if (m_currentScrollChain.empty())
-        recomputeScrollChain(*m_frame, startNode, m_currentScrollChain);
-    scrollState.setScrollChain(m_currentScrollChain);
-
-    scrollState.distributeToScrollChainDescendant();
+    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)
 {
-    // The layout needs to be up to date to determine if we can scroll. We may be
-    // here because of an onLoad event, in which case the final layout hasn't been performed yet.
-    m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
-    // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (logicalScroll(direction, granularity, startingNode))
-        return true;
-
-    Frame* parentFrame = m_frame->tree().parent();
-    if (!parentFrame || !parentFrame->isLocalFrame())
-        return false;
-    // FIXME: Broken for OOPI.
-    return toLocalFrame(parentFrame)->eventHandler().bubblingScroll(direction, granularity, m_frame->deprecatedLocalOwner());
+    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_resizeScrollableArea && m_resizeScrollableArea->inResizeMode())
+    if (m_scrollManager.inResizeMode())
         return NoCursorChange;
 
     Page* page = m_frame->page();
     if (!page)
         return NoCursorChange;
-    if (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 = panScrollInProgress();
-    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();
 
     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_resizeScrollableArea = layer->getScrollableArea();
-            m_resizeScrollableArea->setInResizeMode(true);
-            m_offsetFromResizeCorner = LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(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();
@@ skipping 150 matching lines @@
     if (forceLeave)
         m_frame->document()->updateHoverActiveState(request, 0);
     else
         mev = prepareMouseEvent(request, mouseEvent);
 
     if (hoveredNode)
         *hoveredNode = mev.hitTestResult();
 
     Scrollbar* scrollbar = nullptr;
 
-    if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
-        m_resizeScrollableArea->resize(mev.event(), m_offsetFromResizeCorner);
+    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 147 matching lines @@
             // This is to suppress sending click events for non-primary buttons.
             // But still doing default action like opening a new tab for middle
             // click (crbug.com/255).
             if (mev.event().button() != MouseButton::LeftButton)
                 event->stopPropagation();
 
             clickEventResult = toWebInputEventResult(clickTargetNode->dispatchEvent(event));
         }
     }
 
-    if (m_resizeScrollableArea) {
-        m_resizeScrollableArea->setInResizeMode(false);
-        m_resizeScrollableArea = nullptr;
-    }
+    m_scrollManager.clearResizeScrollableArea(false);
 
     if (eventResult == WebInputEventResult::NotHandled)
         eventResult = handleMouseReleaseEvent(mev);
 
     invalidateClick();
 
     return mergeEventResult(clickEventResult, eventResult);
 }
 
 WebInputEventResult EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
@@ skipping 74 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 = 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 67 matching lines @@
             result = targetFrame->eventHandler().performDragAndDrop(event, dataTransfer);
     } else if (m_dragTarget.get()) {
         result = dispatchDragEvent(EventTypeNames::drop, m_dragTarget.get(), event, dataTransfer);
     }
     clearDragState();
     return result;
 }
 
 void EventHandler::clearDragState()
 {
-    stopAutoscroll();
+    m_scrollManager.stopAutoscroll();
     m_dragTarget = nullptr;
     m_capturingMouseEventsNode = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
 }
 
 void EventHandler::setCapturingMouseEventsNode(Node* n)
 {
     m_capturingMouseEventsNode = n;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
 }
@@ skipping 221 matching lines @@
 
     // If we're over the frame scrollbar, scroll the document.
     if (!node && result.scrollbar())
         node = doc->documentElement();
 
     bool sendDOMEvent = true;
     LocalFrame* subframe = subframeForTargetNode(node);
     if (subframe) {
         WebInputEventResult result = subframe->eventHandler().handleWheelEvent(event);
         if (result != WebInputEventResult::NotHandled) {
-            setFrameWasScrolledByUser();
+            m_scrollManager.setFrameWasScrolledByUser();
             return result;
         }
         // TODO(dtapuska): Remove this once wheel gesture scroll has
         // been enabled everywhere; as we can just return early.
         // http://crbug.com/568183
         // Don't propagate the DOM event into the parent iframe
         // but do dispatch the scroll event.
         sendDOMEvent = false;
     }
 
@@ skipping 47 matching lines @@
     if (granularity == ScrollByPage) {
         if (delta.width())
             delta.setWidth(delta.width() > 0 ? 1 : -1);
         if (delta.height())
             delta.setHeight(delta.height() > 0 ? 1 : -1);
     }
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
     bool consumed = false;
 
-    physicalScroll(
+    m_scrollManager.physicalScroll(
         granularity,
         delta,
         FloatPoint(),
         FloatSize(),
         startNode,
         &node,
         &consumed);
 
     if (consumed)
         wheelEvent->setDefaultHandled();
@@ skipping 57 matching lines @@
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
     return handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
     ASSERT(!targetedEvent.event().isScrollEvent());
 
     Node* eventTarget = targetedEvent.hitTestResult().innerNode();
-    Scrollbar* scrollbar = targetedEvent.hitTestResult().scrollbar();
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
 
-    if (scrollbar) {
-        bool shouldUpdateCapture = false;
-        if (scrollbar->gestureEvent(gestureEvent, &shouldUpdateCapture)) {
-            if (shouldUpdateCapture)
-                m_scrollbarHandlingScrollGesture = scrollbar;
-            return WebInputEventResult::HandledSuppressed;
-        }
-    }
+    if (m_scrollManager.canHandleGestureEvent(targetedEvent))
+        return WebInputEventResult::HandledSuppressed;
 
     if (eventTarget) {
         GestureEvent* gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
         if (gestureDomEvent) {
             DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
             if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
                 ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
                 return toWebInputEventResult(gestureDomEventResult);
             }
         }
@@ skipping 21 matching lines @@
         ASSERT_NOT_REACHED();
     }
 
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
 
-    Node* eventTarget = nullptr;
-    Scrollbar* scrollbar = nullptr;
-    if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
-        scrollbar = m_scrollbarHandlingScrollGesture.get();
-        eventTarget = m_scrollGestureHandlingNode.get();
-    }
-
-    if (!eventTarget) {
-        Document* document = m_frame->document();
-        if (document->layoutViewItem().isNull())
-            return WebInputEventResult::NotHandled;
-
-        FrameView* view = m_frame->view();
-        LayoutPoint viewPoint = view->rootFrameToContents(gestureEvent.position());
-        HitTestRequest request(HitTestRequest::ReadOnly);
-        HitTestResult result(request, viewPoint);
-        document->layoutViewItem().hitTest(result);
-
-        eventTarget = result.innerNode();
-
-        m_lastGestureScrollOverWidget = result.isOverWidget();
-        m_scrollGestureHandlingNode = eventTarget;
-        m_previousGestureScrolledNode = nullptr;
-
-        if (!scrollbar)
-            scrollbar = result.scrollbar();
-    }
-
-    if (scrollbar) {
-        bool shouldUpdateCapture = false;
-        if (scrollbar->gestureEvent(gestureEvent, &shouldUpdateCapture)) {
-            if (shouldUpdateCapture)
-                m_scrollbarHandlingScrollGesture = scrollbar;
-            return WebInputEventResult::HandledSuppressed;
-        }
-        m_scrollbarHandlingScrollGesture = nullptr;
-    }
-
-    if (eventTarget) {
-        if (handleScrollGestureOnResizer(eventTarget, gestureEvent))
-            return WebInputEventResult::HandledSuppressed;
-
-        GestureEvent* gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
-        if (gestureDomEvent) {
-            DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
-            if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
-                ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
-                return toWebInputEventResult(gestureDomEventResult);
-            }
-        }
-    }
-
-    switch (gestureEvent.type()) {
-    case PlatformEvent::GestureScrollBegin:
-        return handleGestureScrollBegin(gestureEvent);
-    case PlatformEvent::GestureScrollUpdate:
-        return handleGestureScrollUpdate(gestureEvent);
-    case PlatformEvent::GestureScrollEnd:
-        return handleGestureScrollEnd(gestureEvent);
-    case PlatformEvent::GestureFlingStart:
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
-        return WebInputEventResult::NotHandled;
-    default:
-        ASSERT_NOT_REACHED();
-        return WebInputEventResult::NotHandled;
-    }
+    return m_scrollManager.handleGestureScrollEvent(gestureEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
 {
     FrameView* frameView(m_frame->view());
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
     uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
@@ skipping 142 matching lines @@
 {
 #if !OS(ANDROID)
     if (m_longTapShouldInvokeContextMenu) {
         m_longTapShouldInvokeContextMenu = false;
         return sendContextMenuEventForGesture(targetedEvent);
     }
 #endif
     return WebInputEventResult::NotHandled;
 }
 
-bool EventHandler::handleScrollGestureOnResizer(Node* eventTarget, const PlatformGestureEvent& gestureEvent)
-{
-    if (gestureEvent.type() == PlatformEvent::GestureScrollBegin) {
-        PaintLayer* layer = eventTarget->layoutObject() ? eventTarget->layoutObject()->enclosingLayer() : nullptr;
-        IntPoint p = m_frame->view()->rootFrameToContents(gestureEvent.position());
-        if (layer && layer->getScrollableArea() && layer->getScrollableArea()->isPointInResizeControl(p, ResizerForTouch)) {
-            m_resizeScrollableArea = layer->getScrollableArea();
-            m_resizeScrollableArea->setInResizeMode(true);
-            m_offsetFromResizeCorner = LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));
-            return true;
-        }
-    } else if (gestureEvent.type() == PlatformEvent::GestureScrollUpdate) {
-        if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
-            m_resizeScrollableArea->resize(gestureEvent, m_offsetFromResizeCorner);
-            return true;
-        }
-    } else if (gestureEvent.type() == PlatformEvent::GestureScrollEnd) {
-        if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
-            m_resizeScrollableArea->setInResizeMode(false);
-            m_resizeScrollableArea = nullptr;
-            return false;
-        }
-    }
-
-    return false;
-}
-
-WebInputEventResult EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, LayoutObject* layoutObject)
-{
-    ASSERT(gestureEvent.isScrollEvent());
-
-    if (!m_lastGestureScrollOverWidget || !layoutObject || !layoutObject->isLayoutPart())
-        return WebInputEventResult::NotHandled;
-
-    Widget* widget = toLayoutPart(layoutObject)->widget();
-
-    if (!widget || !widget->isFrameView())
-        return WebInputEventResult::NotHandled;
-
-    return toFrameView(widget)->frame().eventHandler().handleGestureScrollEvent(gestureEvent);
-}
-
 WebInputEventResult EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)

[mustaq, 2016/05/31 16:04:11]

There seems to be many "op-op" wrappers to a corresponding scollManager
functions. This is an indication that adding a public
EventHandler::scrollMamanger() (return m_scrollManager} may be a better idea.

[Navid Zolghadr, 2016/05/31 16:11:16]

I thought that too. But I wanted to have that sort of APIs more clear with this
op-op way in EventHandler. This way it is clear that these APIs from
EventHandler are being called in different places in the code. In other words no
class accesses the *Manager class APIs directly and outside of this folder (or
outside of its frame). This way it is more clear what APIs of a frame are
exposed to other frames/classes. Is that reasonable?

[bokan, 2016/05/31 19:39:13]

I think it's fine to make EventHandler the "interface" and let it delegate to
the various managers. At the least, this is a good start to breaking everything
apart for more cleanup down the line. Once we've broken up EventHandler, maybe
we'll decide that different managers should have different visibility to the
higher levels but I think that's premature for now so I'm fine with this as-is.

[mustaq, 2016/05/31 20:20:10]

+1 on deferring the visibility of the sub-units, but I would ask for a TODO so
that it doesn't fall through the cracks.

[Navid Zolghadr, 2016/06/01 17:36:43]

Done.

 {
-    Node* node = m_scrollGestureHandlingNode;
-
-    if (node) {
-        passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
-        if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
-            OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
-            scrollStateData->is_ending = true;
-            scrollStateData->is_in_inertial_phase = gestureEvent.inertialPhase() == ScrollInertialPhaseMomentum;
-            scrollStateData->from_user_input = true;
-            scrollStateData->is_direct_manipulation = true;
-            scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-            ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
-            customizedScroll(*node, *scrollState);
-        }
-    }
-
-    clearGestureScrollState();
-    return WebInputEventResult::NotHandled;
-}
-
-WebInputEventResult EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
-{
-    Document* document = m_frame->document();
-    if (document->layoutViewItem().isNull())
-        return WebInputEventResult::NotHandled;
-
-    FrameView* view = m_frame->view();
-    if (!view)
-        return WebInputEventResult::NotHandled;
-
-    // If there's no layoutObject on the node, send the event to the nearest ancestor with a layoutObject.
-    // Needed for <option> and <optgroup> elements so we can touch scroll <select>s
-    while (m_scrollGestureHandlingNode && !m_scrollGestureHandlingNode->layoutObject())
-        m_scrollGestureHandlingNode = m_scrollGestureHandlingNode->parentOrShadowHostNode();
-
-    if (!m_scrollGestureHandlingNode) {
-        if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
-            m_scrollGestureHandlingNode = m_frame->document()->documentElement();
-        else
-            return WebInputEventResult::NotHandled;
-    }
-    ASSERT(m_scrollGestureHandlingNode);
-
-    passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
-    if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
-        m_currentScrollChain.clear();
-        OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
-        scrollStateData->position_x = gestureEvent.position().x();
-        scrollStateData->position_y = gestureEvent.position().y();
-        scrollStateData->is_beginning = true;
-        scrollStateData->from_user_input = true;
-        scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-        ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
-        customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
-    } else {
-        if (m_frame->isMainFrame())
-            m_frame->host()->topControls().scrollBegin();
-    }
-    return WebInputEventResult::HandledSystem;
-}
-
-bool EventHandler::isRootScroller(const Node& node) const
-{
-    // The root scroller is the one Element on the page designated to perform
-    // "viewport actions" like top controls movement and overscroll glow.
-    if (!frameHost() || !frameHost()->rootScroller())
-        return false;
-
-    return frameHost()->rootScroller()->get() == &node;
-}
-
-WebInputEventResult EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
-{
-    ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
-
-    // Negate the deltas since the gesture event stores finger movement and
-    // scrolling occurs in the direction opposite the finger's movement
-    // direction. e.g. Finger moving up has negative event delta but causes the
-    // page to scroll down causing positive scroll delta.
-    FloatSize delta(-gestureEvent.deltaX(), -gestureEvent.deltaY());
-    FloatSize velocity(-gestureEvent.velocityX(), -gestureEvent.velocityY());
-    if (delta.isZero())
-        return WebInputEventResult::NotHandled;
-
-    ScrollGranularity granularity = gestureEvent.deltaUnits();
-    Node* node = m_scrollGestureHandlingNode.get();
-
-    // Scroll customization is only available for touch.
-    bool handleScrollCustomization = RuntimeEnabledFeatures::scrollCustomizationEnabled() && gestureEvent.source() == PlatformGestureSourceTouchscreen;
-    if (node) {
-        LayoutObject* layoutObject = node->layoutObject();
-        if (!layoutObject)
-            return WebInputEventResult::NotHandled;
-
-        // Try to send the event to the correct view.
-        WebInputEventResult result = passScrollGestureEventToWidget(gestureEvent, layoutObject);
-        if (result != WebInputEventResult::NotHandled) {
-            if (gestureEvent.preventPropagation()
-                && !RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
-                // This is an optimization which doesn't apply with
-                // scroll customization enabled.
-                m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
-            }
-            // FIXME: we should allow simultaneous scrolling of nested
-            // iframes along perpendicular axes. See crbug.com/466991.
-            m_deltaConsumedForScrollSequence = true;
-            return result;
-        }
-
-        if (handleScrollCustomization) {
-            OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
-            scrollStateData->delta_x = delta.width();
-            scrollStateData->delta_y = delta.height();
-            scrollStateData->delta_granularity = ScrollByPrecisePixel;
-            scrollStateData->velocity_x = velocity.width();
-            scrollStateData->velocity_y = velocity.height();
-            scrollStateData->should_propagate = !gestureEvent.preventPropagation();
-            scrollStateData->is_in_inertial_phase = gestureEvent.inertialPhase() == ScrollInertialPhaseMomentum;
-            scrollStateData->from_user_input = true;
-            scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-            ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
-            if (m_previousGestureScrolledNode) {
-                // The ScrollState needs to know what the current
-                // native scrolling element is, so that for an
-                // inertial scroll that shouldn't propagate, only the
-                // currently scrolling element responds.
-                ASSERT(m_previousGestureScrolledNode->isElementNode());
-                scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
-            }
-            customizedScroll(*node, *scrollState);
-            m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
-            m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
-            if (scrollState->deltaX() != delta.width()
-                || scrollState->deltaY() != delta.height()) {
-                setFrameWasScrolledByUser();
-                return WebInputEventResult::HandledSystem;
-            }
-        } else {
-            Node* stopNode = nullptr;
-            if (gestureEvent.preventPropagation())
-                stopNode = m_previousGestureScrolledNode.get();
-
-            bool consumed = false;
-            ScrollResult result = physicalScroll(
-                granularity,
-                delta,
-                FloatPoint(gestureEvent.position()),
-                velocity,
-                node,
-                &stopNode,
-                &consumed);
-
-            if (gestureEvent.preventPropagation())
-                m_previousGestureScrolledNode = stopNode;
-
-            if ((!stopNode || !isRootScroller(*stopNode)) && frameHost()) {
-                frameHost()->overscrollController().resetAccumulated(
-                    result.didScrollX, result.didScrollY);
-            }
-
-            if (consumed)
-                return WebInputEventResult::HandledSystem;
-        }
-    }
-
-    return WebInputEventResult::NotHandled;
-}
-
-void EventHandler::clearGestureScrollState()
-{
-    m_scrollGestureHandlingNode = nullptr;
-    m_previousGestureScrolledNode = nullptr;
-    m_deltaConsumedForScrollSequence = false;
-    m_currentScrollChain.clear();
-
-    if (FrameHost* host = frameHost()) {
-        bool resetX = true;
-        bool resetY = true;
-        host->overscrollController().resetAccumulated(resetX, resetY);
-    }
+    return m_scrollManager.handleGestureScrollEnd(gestureEvent);
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
-    return m_scrollbarHandlingScrollGesture.get();
+    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 518 matching lines @@
     return m_frame->page()->isCursorVisible();
 }
 
 void EventHandler::setResizingFrameSet(HTMLFrameSetElement* frameSet)
 {
     m_frameSetBeingResized = frameSet;
 }
 
 void EventHandler::resizeScrollableAreaDestroyed()
 {
-    ASSERT(m_resizeScrollableArea);
-    m_resizeScrollableArea = nullptr;
+    m_scrollManager.clearResizeScrollableArea(true);
 }
 
 void EventHandler::hoverTimerFired(Timer<EventHandler>*)
 {
     TRACE_EVENT0("input", "EventHandler::hoverTimerFired");
     m_hoverTimer.stop();
 
     ASSERT(m_frame);
     ASSERT(m_frame->document());
 
@@ skipping 49 matching lines @@
 }
 
 WebInputEventResult EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
 {
     m_frame->chromeClient().clearToolTip();
 
     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
         capsLockStateMayHaveChanged();
 
 #if OS(WIN)
-    if (panScrollInProgress()) {
+    if (m_scrollManager.panScrollInProgress()) {
         // If a key is pressed while the panScroll is in progress then we want to stop
         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
-            stopAutoscroll();
+            m_scrollManager.stopAutoscroll();
 
         // If we were in panscroll mode, we swallow the key event
         return WebInputEventResult::HandledSuppressed;
     }
 #endif
 
     // Check for cases where we are too early for events -- possible unmatched key up
     // from pressing return in the location bar.
     Node* node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
@@ skipping 306 matching lines @@
 void EventHandler::defaultSpaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keypress);
 
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
     ScrollDirection direction = event->shiftKey() ? ScrollBlockDirectionBackward : ScrollBlockDirectionForward;
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (logicalScroll(direction, ScrollByPage)) {
+    if (m_scrollManager.logicalScroll(direction, ScrollByPage, nullptr, m_mousePressNode)) {
         event->setDefaultHandled();
         return;
     }
 }
 
 void EventHandler::defaultBackspaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keydown);
 
     if (!RuntimeEnabledFeatures::backspaceDefaultHandlerEnabled())
@@ skipping 75 matching lines @@
 void EventHandler::capsLockStateMayHaveChanged()
 {
     if (Element* element = m_frame->document()->focusedElement()) {
         if (LayoutObject* r = element->layoutObject()) {
             if (r->isTextField())
                 toLayoutTextControlSingleLine(r)->capsLockStateMayHaveChanged();
         }
     }
 }
 
-void EventHandler::setFrameWasScrolledByUser()
-{
-    if (DocumentLoader* documentLoader = m_frame->loader().documentLoader())
-        documentLoader->initialScrollState().wasScrolledByUser = true;
-}
-
 bool EventHandler::passMousePressEventToScrollbar(MouseEventWithHitTestResults& mev)
 {
     Scrollbar* scrollbar = mev.scrollbar();
     updateLastScrollbarUnderMouse(scrollbar, true);
 
     if (!scrollbar || !scrollbar->enabled())
         return false;
-    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.
@@ skipping 88 matching lines @@
 
 FrameHost* EventHandler::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 } // namespace blink