Use scroll customization primitives for touch scrolling (behind REF).

Source/core/page/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 62 matching lines @@
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/EditorClient.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/ScrollState.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"
 #include "platform/TraceEvent.h"
 #include "platform/WindowsKeyboardCodes.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/graphics/Image.h"
@@ skipping 95 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.
 static inline bool shouldRefetchEventTarget(const MouseEventWithHitTestResults& mev)
 {
     Node* targetNode = mev.innerNode();
     if (!targetNode || !targetNode->parentNode())
         return true;
     return targetNode->isShadowRoot() && isHTMLInputElement(*toShadowRoot(targetNode)->host());
 }
 
+void recomputeScrollChain(const LocalFrame& frame, const Node& startNode,
+    WillBeHeapDeque<RefPtrWillBeMember<Element>>& scrollChain)
+{
+    scrollChain.clear();
+    bool rootLayerScrolls = frame.settings() && frame.settings()->rootLayerScrolls();
+
+    ASSERT(startNode.layoutObject());
+    LayoutBox* curBox = startNode.layoutObject()->enclosingBox();
+    bool addedDocumentElement = false;
+
+    while (curBox && (rootLayerScrolls || !curBox->isLayoutView())) {

[Rick Byers, 2015/03/11 02:22:18]

I think this deserves a comment describing why we're doing this.  Maybe just
"scrolling propagates along the containing block chain" or some such.  

Also I think this code is Shadow-DOM correct, but you should probably add at
least one test (eg. a scroller as a template argument to a custom element,
instantiated inside some other scroller inside the custom element - the chain
should reflect the instantiation).

[tdresser, 2015/03/20 18:00:37]

Done.
I'll add a test for scroll customization with shadow dom in the patch which
enables javascript scroll customization.

+        Node* curNode = curBox->node();
+        curBox = curBox->containingBlock();

[Rick Byers, 2015/03/11 02:22:18]

What if the first curBox is scrollable itself?  It won't get added to the scroll
chain since we walk up first before doing the below logic.

[tdresser, 2015/03/20 18:00:37]

We don't use curBox until the next iteration of the loop, so this is logically
correct. I've cleaned it up so it's a bit clearer.

[Rick Byers, 2015/03/26 21:22:49]

Acknowledged.

+        // FIXME: this should reject more elements.
+        if (!curNode || !curNode->isElementNode())
+            continue;
+        scrollChain.prepend(toElement(curNode));
+        if (curNode == frame.document()->documentElement())
+            addedDocumentElement = true;
+    }
+
+    if (!addedDocumentElement)

[Rick Byers, 2015/03/11 02:22:19]

Do we want to do this even when rootLayerScrolls is false?

Can't we simplify the loop by always stopping once we hit the documentElement or
RenderView, and then always (or at least whenver rootLayerScrolls is true)
adding the document element?  It's really special in that many properties /
operations on it are redirected to the RenderView.

[tdresser, 2015/03/20 18:00:36]

I've simplified the loop a bit. Actually determining if adding the
documentElement is necessary won't be possible until JS scroll customization is
implemented, so I'm going to mark this with a FIXME for now.

[Rick Byers, 2015/03/26 21:22:49]

Acknowledged.

+        scrollChain.prepend(frame.document()->documentElement());
+}
+
 EventHandler::EventHandler(LocalFrame* frame)
     : m_frame(frame)
     , m_mousePressed(false)
     , m_capturesDragging(false)
     , m_mouseDownMayStartSelect(false)
     , m_mouseDownMayStartDrag(false)
     , m_mouseDownWasSingleClickInSelection(false)
     , m_selectionInitiationState(HaveNotStartedSelection)
     , 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_widgetIsLatched(false)
     , m_touchPressed(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_maxMouseMovedDuration(0)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
+    , m_deltaConsumedForScrollSequence(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_mousePressNode);
     visitor->trace(m_capturingMouseEventsNode);
     visitor->trace(m_nodeUnderMouse);
     visitor->trace(m_lastNodeUnderMouse);
     visitor->trace(m_lastMouseMoveEventSubframe);
     visitor->trace(m_lastScrollbarUnderMouse);
     visitor->trace(m_clickNode);
     visitor->trace(m_dragTarget);
     visitor->trace(m_frameSetBeingResized);
     visitor->trace(m_latchedWheelEventNode);
     visitor->trace(m_previousWheelScrolledNode);
     visitor->trace(m_scrollbarHandlingScrollGesture);
     visitor->trace(m_targetForTouchID);
     visitor->trace(m_touchSequenceDocument);
     visitor->trace(m_scrollGestureHandlingNode);
     visitor->trace(m_previousGestureScrolledNode);
     visitor->trace(m_lastDeferredTapElement);
+    visitor->trace(m_currentScrollChain);
 #endif
 }
 
 DragState& EventHandler::dragState()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<DragState>, state, (adoptPtrWillBeNoop(new DragState())));
     return *state;
 }
 
 void EventHandler::clear()
@@ skipping 674 matching lines @@
             setFrameWasScrolledByUser();
             return true;
         }
 
         curBox = curBox->containingBlock();
     }
 
     return false;
 }
 
+void EventHandler::customizedScroll(const Node& startNode, ScrollState& scrollState)
+{
+    if (scrollState.fullyConsumed())
+        return;
+
+    if (m_currentScrollChain.isEmpty())
+        recomputeScrollChain(*m_frame, startNode, m_currentScrollChain);
+    scrollState.setScrollChain(m_currentScrollChain);
+    scrollState.distributeToScrollChainDescendant();
+}
+
 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()->updateLayoutIgnorePendingStylesheets();
+    // FIXME: enable scroll customization in this case.

[Rick Byers, 2015/03/11 02:22:18]

you might want to reference your scroll customization bug number - then we can
do a search for that URL in the code before calling your bug fixed.  I assume
this will be the first of many such FIXMEs ;-)

[tdresser, 2015/03/20 18:00:37]

Done.

     if (scroll(direction, granularity, startingNode))
         return true;
     LocalFrame* frame = m_frame;
     FrameView* view = frame->view();
     if (view && view->scroll(direction, granularity))
         return true;
     Frame* parentFrame = frame->tree().parent();
     if (!parentFrame || !parentFrame->isLocalFrame())
         return false;
     // FIXME: Broken for OOPI.
@@ skipping 1090 matching lines @@
 
     // When the wheelEvent do not scroll, we trigger zoom in/out instead.
     if (!wheelEvent->canScroll())
         return;
 
     Node* stopNode = m_previousWheelScrolledNode.get();
     ScrollGranularity granularity = wheelGranularityToScrollGranularity(wheelEvent);
 
     // Break up into two scrolls if we need to.  Diagonal movement on
     // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
+
+    // FIXME: enable scroll customization in this case.
     if (scroll(ScrollRight, granularity, startNode, &stopNode, wheelEvent->deltaX(), roundedIntPoint(wheelEvent->absoluteLocation())))
         wheelEvent->setDefaultHandled();
 
     if (scroll(ScrollDown, granularity, startNode, &stopNode, wheelEvent->deltaY(), roundedIntPoint(wheelEvent->absoluteLocation())))
         wheelEvent->setDefaultHandled();
 
     if (!m_latchedWheelEventNode)
         m_previousWheelScrolledNode = stopNode;
 }
 
@@ skipping 116 matching lines @@
         FrameView* view = m_frame->view();
         LayoutPoint viewPoint = view->windowToContents(gestureEvent.position());
         HitTestRequest request(HitTestRequest::ReadOnly);
         HitTestResult result(viewPoint);
         document->layoutView()->hitTest(request, result);
 
         eventTarget = result.innerNode();
 
         m_lastGestureScrollOverWidget = result.isOverWidget();
         m_scrollGestureHandlingNode = eventTarget;
-        m_previousGestureScrolledNode = nullptr;

[Rick Byers, 2015/03/11 02:22:19]

why remove this?

[tdresser, 2015/03/20 18:00:37]

Looks wrong to me. Fixed.

 
         if (!scrollbar)
             scrollbar = result.scrollbar();
     }
 
     if (scrollbar) {
         bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
         if (gestureEvent.type() == PlatformEvent::GestureScrollEnd
             || gestureEvent.type() == PlatformEvent::GestureFlingStart
             || !eventSwallowed) {
@@ skipping 232 matching lines @@
     Widget* widget = toLayoutPart(renderer)->widget();
 
     if (!widget || !widget->isFrameView())
         return false;
 
     return toFrameView(widget)->frame().eventHandler().handleGestureScrollEvent(gestureEvent);
 }
 
 bool EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent) {
     RefPtrWillBeRawPtr<Node> node = m_scrollGestureHandlingNode;
+
+    if (node) {
+        if (passScrollGestureEventToWidget(gestureEvent, node->layoutObject()))
+            return false;

[Rick Byers, 2015/03/11 02:22:18]

this doesn't make sense to me.  If the subframe handles the GSE then we report
NOT handled and terminate?  The original code made sure to clear any scrolling
state across the entire frame chain involved.  Your code doesn't, does it?

Do you need some more iframe tests?

[tdresser, 2015/03/20 18:00:37]

This was correct before, but _extremely_ confusing.

Note that the return value here is the same as it was before - we only ever
return false (I believe this is because we need to ensure that all frames
receive the gesture end). The return value of passScrollGestureEventToWidget is
ignored.

The early out will never trigger, since we always return false in
handleGestureScrollEnd... I've gotten rid of it.


clearGestureScrollNodes() will always be called across all frames, and it clears
up all of the scrolling state.

There's a reasonable set of existing iframe tests - I'm planning to add some
more when I align the behavior of main thread iframe scroll bubbling with impl
thread iframe scroll bubbling, but until then I think the coverage is
acceptable. Are there specific tests you think are missing?

[Rick Byers, 2015/03/26 21:22:49]

Thanks, makes sense.
No, that sounds fine.  Thanks.

+        if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
+            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+                0, 0, 0, 0, 0, gestureEvent.inertial(), false, true, true);

[Rick Byers, 2015/03/11 02:22:18]

Blink coding style says: "Prefer enums to bools on function parameters if
callers are likely to be passing constants"
(http://www.chromium.org/blink/coding-style#TOC-Names) precisely because this
"false, true, true" is hard to understand.  I'd probably also accept comments in
front of each of these 3 args giving its name.

[tdresser, 2015/03/20 18:00:37]

Done.

+            customizedScroll(*node.get(), *scrollState);
+        }
+    }
+
     clearGestureScrollNodes();
-
-    if (node)
-        passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
-
+    m_currentScrollChain.clear();
     return false;
 }
 
 bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
 {
     Document* document = m_frame->document();
     if (!document->layoutView())
         return false;
 
     FrameView* view = m_frame->view();
     if (!view)
         return false;
 
     // If there's no renderer on the node, send the event to the nearest ancestor with a renderer.
     // 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)
-        return false;
+    if (!m_scrollGestureHandlingNode) {
+        if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
+            m_scrollGestureHandlingNode = m_frame->document()->documentElement();
+        else
+            return false;
+    }
+    ASSERT(m_scrollGestureHandlingNode);
 
     passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
+    if (!RuntimeEnabledFeatures::scrollCustomizationEnabled()) {

[Rick Byers, 2015/03/11 02:22:18]

this would be slightly clearer to me as a if(enabled)/else block (with a single
return true at the end.  WDYT?

[tdresser, 2015/03/20 18:00:37]

Done.

[Rick Byers, 2015/03/26 21:22:49]

nit: I meants put the true case first to avoid a double-negative

[tdresser, 2015/03/27 15:28:52]

Done.

+        if (m_frame->isMainFrame())
+            m_frame->host()->topControls().scrollBegin();
+        return true;
+    }
 
-    if (m_frame->isMainFrame())
-        m_frame->host()->topControls().scrollBegin();
+    m_deltaConsumedForScrollSequence = false;
+    m_currentScrollChain.clear();
+    RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+        0, 0, 0, 0, 0, false, true, false, true);

[Rick Byers, 2015/03/11 02:22:18]

ditto

[tdresser, 2015/03/20 18:00:37]

Done.

+    customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
 
     return true;
 }
 
-static bool scrollAreaOnBothAxes(const FloatSize& delta, ScrollableArea& view)
-{
-    bool scrolledHorizontal = view.scroll(ScrollLeft, ScrollByPrecisePixel, delta.width());
-    bool scrolledVertical = view.scroll(ScrollUp, ScrollByPrecisePixel, delta.height());
-    return scrolledHorizontal || scrolledVertical;
-}
-
 bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
         return false;
 
     Node* node = m_scrollGestureHandlingNode.get();
     if (node) {
         LayoutObject* renderer = node->layoutObject();
         if (!renderer)
             return false;
 
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
         Node* stopNode = nullptr;
 
         // Try to send the event to the correct view.
         if (passScrollGestureEventToWidget(gestureEvent, renderer)) {
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
-
+            m_deltaConsumedForScrollSequence = true;
             return true;
         }
 
+        bool scrolled = false;
+        if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
+            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+                gestureEvent.deltaX(), gestureEvent.deltaY(),
+                0, gestureEvent.velocityX(), gestureEvent.velocityY(),
+                gestureEvent.inertial(), false, false, true,
+                !gestureEvent.preventPropagation(), m_deltaConsumedForScrollSequence);
+            if (m_previousGestureScrolledNode) {

[Rick Byers, 2015/03/11 02:22:18]

So does this field now represent just native scrolls (doesn't include custom
scrolled nodes)?  Perhaps update it's comment or maybe even it's name.  I'm not
fully following (although I haven't finished looking at all code yet) why you
need this, and 'currentNativeScrollingElement', perhaps some more comments would
help.

[tdresser, 2015/03/20 18:00:37]

Done.

+                ASSERT(m_previousGestureScrolledNode->isElementNode());
+                scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
+            }
+            customizedScroll(*node, *scrollState);
+            m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
+            m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
 
-        if (gestureEvent.preventPropagation())
-            stopNode = m_previousGestureScrolledNode.get();
+            scrolled = scrollState->deltaX() != gestureEvent.deltaX()
+                || scrollState->deltaY() != gestureEvent.deltaY();
+        } else {
+            if (gestureEvent.preventPropagation())
+                stopNode = m_previousGestureScrolledNode.get();
 
-        // First try to scroll the closest scrollable LayoutBox ancestor of |node|.
-        ScrollGranularity granularity = ScrollByPixel;
-        bool horizontalScroll = scroll(ScrollLeft, granularity, node, &stopNode, delta.width());
-        bool verticalScroll = scroll(ScrollUp, granularity, node, &stopNode, delta.height());
+            // First try to scroll the closest scrollable LayoutBox ancestor of |node|.
+            ScrollGranularity granularity = ScrollByPixel;
+            scrolled = scroll(ScrollLeft, granularity, node, &stopNode, delta.width())
+                | scroll(ScrollUp, granularity, node, &stopNode, delta.height());

[Rick Byers, 2015/03/11 02:22:19]

This is a little subtle (I could imagine someone replacing | with || and
breaking things).  Maybe a comment or just return to the more explicit form
(scrolled = horizontalScroll || verticalScroll).

[tdresser, 2015/03/20 18:00:37]

Done.

 
-        if (gestureEvent.preventPropagation())
-            m_previousGestureScrolledNode = stopNode;
-
-        if (horizontalScroll || verticalScroll) {
+            if (gestureEvent.preventPropagation())
+                m_previousGestureScrolledNode = stopNode;
+        }
+        if (scrolled) {
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
-    // If this is main frame, allow top controls to scroll first and update
-    // delta accordingly
-    bool consumed = false;
-    if (m_frame->isMainFrame() && shouldTopControlsConsumeScroll(delta)) {
-        FloatSize excessDelta = m_frame->host()->topControls().scrollBy(delta);
-        consumed = excessDelta != delta;
-        delta = excessDelta;
-
-        if (delta.isZero())
-            return consumed;
-    }
+    if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
+        return false;
 
     // Try to scroll the frame view.
-    FrameView* view = m_frame->view();
-    if (!view)
-        return consumed;
-
-    if (scrollAreaOnBothAxes(delta, *view)) {
+    if (m_frame->applyScrollDelta(delta, false)) {
         setFrameWasScrolledByUser();
         return true;
     }
 
-    // If this is the main frame and it didn't scroll, propagate up to the pinch viewport.
-    if (!m_frame->settings()->pinchVirtualViewportEnabled() || !m_frame->isMainFrame())
-        return consumed;
-
-    if (scrollAreaOnBothAxes(delta, m_frame->host()->pinchViewport())) {
-        setFrameWasScrolledByUser();
-        return true;
-    }
-
-    return consumed;
+    return false;
 }
 
 void EventHandler::clearGestureScrollNodes()
 {
     m_scrollGestureHandlingNode = nullptr;
     m_previousGestureScrolledNode = nullptr;
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
@@ skipping 809 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.
     if (scroll(direction, ScrollByPage)) {
         event->setDefaultHandled();
         return;
     }
 
     FrameView* view = m_frame->view();
     if (!view)
         return;
 
     if (view->scroll(direction, ScrollByPage))
@@ skipping 497 matching lines @@
 
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
-bool EventHandler::shouldTopControlsConsumeScroll(FloatSize scrollDelta) const
-{
-    // Always consume if it's in the direction to show the top controls.
-    if (scrollDelta.height() > 0)
-        return true;
-
-    // If it's in the direction to hide the top controls, only consume when the frame can also scroll.
-    if (m_frame->view()->scrollPosition().y() < m_frame->view()->maximumScrollPosition().y())
-        return true;
-
-    return false;
-}
-
-
 } // namespace blink