Make all gesture scrolls use customization path internally

third_party/WebKit/Source/core/input/ScrollManager.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/ScrollManager.h"
 
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/TopControls.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutPart.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/OverscrollController.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/PlatformGestureEvent.h"
 
 
 namespace blink {
 
-namespace {
-
-// 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();
-
-    DCHECK(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();
-
-    DCHECK(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
-
 ScrollManager::ScrollManager(LocalFrame* frame)
 : m_frame(frame)
 {
     clear();
 }
 
 ScrollManager::~ScrollManager()
 {
 }
 
@@ skipping 31 matching lines @@
     return autoscrollController() && autoscrollController()->panScrollInProgress();
 }
 
 AutoscrollController* ScrollManager::autoscrollController() const
 {
     if (Page* page = m_frame->page())
         return &page->autoscrollController();
     return nullptr;
 }
 
-ScrollResult ScrollManager::physicalScroll(ScrollGranularity granularity,
-    const FloatSize& delta, const FloatPoint& position,
-    const FloatSize& velocity, Node* startNode, Node** stopNode, bool* consumed)
+void ScrollManager::recomputeScrollChain(const Node& startNode,
+    std::deque<int>& scrollChain)
 {
-    if (consumed)
-        *consumed = false;
-    if (delta.isZero())
-        return ScrollResult();
+    scrollChain.clear();
 
-    Node* node = startNode;
-    DCHECK(node && node->layoutObject());
+    DCHECK(startNode.layoutObject());
+    LayoutBox* curBox = startNode.layoutObject()->enclosingBox();
 
-    m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
+    // Scrolling propagates along the containing block chain and ends at the
+    // RootScroller element. The RootScroller element will have a custom
+    // applyScroll callback that scrolls the frame or element.
+    while (curBox) {
+        Node* curNode = curBox->node();
+        Element* curElement = nullptr;
 
-    ScrollResult result;
+        // FIXME: this should reject more elements, as part of crbug.com/410974.
+        if (curNode && curNode->isElementNode()) {
+            curElement = toElement(curNode);
+        } else if (curNode && curNode->isDocumentNode()) {
+            // In normal circumastances, the documentElement will be the root
+            // scroller but the documentElement itself isn't a containing block,
+            // that'll be the document node rather than the element.
+            curElement = m_frame->document()->documentElement();
+            DCHECK(!curElement || isEffectiveRootScroller(*curElement));
+        }
 
-    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;
-        }
-        if (wasRootScroller) {
-            // Don't try to chain past the root scroller, even if there's
-            // eligible ancestors.
-            break;
+        if (curElement) {
+            scrollChain.push_front(DOMNodeIds::idForNode(curElement));
+            if (isEffectiveRootScroller(*curElement))
+                break;
         }
 
         curBox = curBox->containingBlock();
     }
-
-    return result;
 }
 
 bool ScrollManager::logicalScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node* mousePressNode)
 {
     Node* node = startNode;
 
     if (!node)
         node = m_frame->document()->focusedElement();
 
     if (!node)
@@ skipping 36 matching lines @@
     if (logicalScroll(direction, granularity, startingNode, mousePressNode))
         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());
 }
 
-ScrollResult ScrollManager::scrollBox(LayoutBox* box,
-    ScrollGranularity granularity, const FloatSize& delta,
-    const FloatPoint& position, const FloatSize& velocity,
-    bool* wasRootScroller)
-{
-    DCHECK(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);
-    }
-
-    // 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;
-}
-
 void ScrollManager::setFrameWasScrolledByUser()
 {
     if (DocumentLoader* documentLoader = m_frame->loader().documentLoader())
         documentLoader->initialScrollState().wasScrolledByUser = true;
 }
 
 void ScrollManager::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);
+        recomputeScrollChain(startNode, m_currentScrollChain);
     scrollState.setScrollChain(m_currentScrollChain);
 
     scrollState.distributeToScrollChainDescendant();
 }
 
 WebInputEventResult ScrollManager::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;
-    }
+    if (!m_scrollGestureHandlingNode)
+        m_scrollGestureHandlingNode = m_frame->document()->documentElement();
+
     DCHECK(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();
-    }
+
+    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);
     return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     DCHECK_EQ(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());
+    FloatPoint position(gestureEvent.position());
+
     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;
+    if (!node)
+        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;
-        }
+    LayoutObject* layoutObject = node->layoutObject();
+    if (!layoutObject)
+        return WebInputEventResult::NotHandled;
 
-        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.
-                DCHECK(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();
+    // Try to send the event to the correct view.
+    WebInputEventResult result = passScrollGestureEventToWidget(gestureEvent, layoutObject);
+    if (result != WebInputEventResult::NotHandled) {
+        // FIXME: we should allow simultaneous scrolling of nested
+        // iframes along perpendicular axes. See crbug.com/466991.
+        m_deltaConsumedForScrollSequence = true;
+        return result;
+    }
 
-            bool consumed = false;
-            ScrollResult result = physicalScroll(
-                granularity,
-                delta,
-                FloatPoint(gestureEvent.position()),
-                velocity,
-                node,
-                &stopNode,
-                &consumed);
+    OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
+    scrollStateData->delta_x = delta.width();
+    scrollStateData->delta_y = delta.height();
+    scrollStateData->delta_granularity = static_cast<double>(gestureEvent.deltaUnits());
+    scrollStateData->velocity_x = velocity.width();
+    scrollStateData->velocity_y = velocity.height();
+    scrollStateData->position_x = position.x();
+    scrollStateData->position_y = position.y();
+    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.
+        DCHECK(m_previousGestureScrolledNode->isElementNode());
+        scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
+    }
+    customizedScroll(*node, *scrollState);
+    m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
+    m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
 
-            if (gestureEvent.preventPropagation())
-                m_previousGestureScrolledNode = stopNode;
+    bool didScrollX = scrollState->deltaX() != delta.width();
+    bool didScrollY = scrollState->deltaY() != delta.height();
 
-            if ((!stopNode || !isRootScroller(*stopNode)) && frameHost()) {
-                frameHost()->overscrollController().resetAccumulated(
-                    result.didScrollX, result.didScrollY);
-            }
+    if ((!m_previousGestureScrolledNode || !isEffectiveRootScroller(*m_previousGestureScrolledNode)) && frameHost())
+        frameHost()->overscrollController().resetAccumulated(didScrollX, didScrollY);
 
-            if (consumed)
-                return WebInputEventResult::HandledSystem;
-        }
+    if (didScrollX || didScrollY) {
+        setFrameWasScrolledByUser();
+        return WebInputEventResult::HandledSystem;
     }
 
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
 {
     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);
-        }
+        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;
 }
 
 FrameHost* ScrollManager::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 WebInputEventResult ScrollManager::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, LayoutObject* layoutObject)
 {
     DCHECK(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);
 }
 
-bool ScrollManager::isRootScroller(const Node& node) const
+bool ScrollManager::isEffectiveRootScroller(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 (!m_frame->document())
         return false;
 
     if (!node.isElementNode())
         return false;
 
-    return m_frame->document()->topDocument().isEffectiveRootScroller(toElement(node));
+    return node.isSameNode(m_frame->document()->effectiveRootScroller());
 }
 
 
 WebInputEventResult ScrollManager::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     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;
+        m_deltaConsumedForScrollSequence = false;
 
         if (!scrollbar)
             scrollbar = result.scrollbar();
     }
 
     if (scrollbar) {
         bool shouldUpdateCapture = false;
         if (scrollbar->gestureEvent(gestureEvent, &shouldUpdateCapture)) {
             if (shouldUpdateCapture)
                 m_scrollbarHandlingScrollGesture = scrollbar;
@@ skipping 111 matching lines @@
 DEFINE_TRACE(ScrollManager)
 {
     visitor->trace(m_frame);
     visitor->trace(m_scrollGestureHandlingNode);
     visitor->trace(m_previousGestureScrolledNode);
     visitor->trace(m_scrollbarHandlingScrollGesture);
     visitor->trace(m_resizeScrollableArea);
 }
 
 } // namespace blink