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& scrollGestureHandlingNode,
+    WillBeHeapDeque<RefPtrWillBeMember<Element>>& scrollChain)
+{
+    scrollChain.clear();
+    bool rootLayerScrolls = frame.settings() && frame.settings()->rootLayerScrolls();
+    LayoutBox* curBox = scrollGestureHandlingNode.renderer()->enclosingBox();
+    bool addedDocumentElement = false;
+
+    while (curBox && (rootLayerScrolls || !curBox->isLayoutView())) {
+        Node* curNode = curBox->node();
+        curBox = curBox->containingBlock();
+        // FIXME: this should reject more elements.
+        if (!curNode || !curNode->isElementNode())
+            continue;
+        scrollChain.prepend(toElement(curNode));
+        if (curNode == frame.document()->documentElement())
+            addedDocumentElement = true;
+    }
+
+    if (!addedDocumentElement)
+        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(ScrollState* scrollState, Node* startNode)
+{
+    Node* node = startNode;
+
+    if (!node)
+        node = m_frame->document()->focusedElement();
+
+    if (!node)
+        node = m_mousePressNode.get();
+
+    if (!node || !node->renderer())
+        return;
+
+    if (m_currentScrollChain.isEmpty() && m_scrollGestureHandlingNode.get())
+        recomputeScrollChain(*m_frame, *m_scrollGestureHandlingNode.get(), 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.
     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;
 
         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->renderer()))
+            return false;
+        if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
+            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+                0, 0, 0, 0, 0, gestureEvent.inertial(), false, true, true);
+            customizedScroll(scrollState.get(), node.get());
+        }
+    }
+
     clearGestureScrollNodes();
-
-    if (node)
-        passScrollGestureEventToWidget(gestureEvent, node->renderer());
-
+    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->renderer())
         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->renderer());
+    if (!RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
+        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);
+    customizedScroll(scrollState.get(), m_scrollGestureHandlingNode.get());
 
     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->renderer();
         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);
+            // FIXME - check if its an element.

[tdresser, 2015/03/06 20:38:11]

This needs to be done.

[tdresser, 2015/03/09 17:02:56]

Done.

+            scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
+            customizedScroll(scrollState.get(), node);
+            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());
 
-        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