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

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 94 matching lines @@
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/LayoutView.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "core/page/SpatialNavigation.h"
+#include "core/page/scrolling/ScrollState.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
@@ skipping 349 matching lines @@
     if (!layoutObject())
         return;
 
     LayoutRect bounds = boundingBox();
     if (centerIfNeeded)
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
     else
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 }
 
+void Element::distributeScroll(ScrollState& scrollState)
+{
+    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    if (scrollState.fullyConsumed())
+        return;
+
+    scrollState.distributeToScrollChainDescendant();
+
+    // If the scroll doesn't propagate, and we're currently scrolling
+    // an element other than this one, prevent the scroll from
+    // propagating to this element.
+    if (!scrollState.shouldPropagate()
+        && scrollState.deltaConsumedForScrollSequence()
+        && scrollState.currentNativeScrollingElement() != this) {
+        return;
+    }
+
+    const double deltaX = scrollState.deltaX();
+    const double deltaY = scrollState.deltaY();
+
+    applyScroll(scrollState);
+
+    if (deltaX != scrollState.deltaX() || deltaY != scrollState.deltaY())
+        scrollState.setCurrentNativeScrollingElement(this);
+}
+
+void Element::applyScroll(ScrollState& scrollState)
+{
+    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    if (scrollState.fullyConsumed())
+        return;
+
+    const double deltaX = scrollState.deltaX();
+    const double deltaY = scrollState.deltaY();
+    bool scrolled = false;
+
+    // Handle the documentElement separately, as it scrolls the FrameView.
+    if (this == document().documentElement()) {
+        FloatSize delta(deltaX, deltaY);
+        if (document().frame()->applyScrollDelta(delta, scrollState.isBeginning())) {
+            scrolled = true;
+            scrollState.consumeDeltaNative(scrollState.deltaX(), scrollState.deltaY());
+        }
+    } else {
+        if (!layoutObject())
+            return;
+        LayoutBox* curBox = layoutObject()->enclosingBox();
+        // FIXME: Native scrollers should only consume the scroll they
+        // apply. See crbug.com/457765.
+        if (deltaX && curBox->scroll(ScrollLeft, ScrollByPrecisePixel, deltaX)) {
+            scrollState.consumeDeltaNative(scrollState.deltaX(), 0);
+            scrolled = true;
+        }
+
+        if (deltaY && curBox->scroll(ScrollUp, ScrollByPrecisePixel, deltaY)) {
+            scrollState.consumeDeltaNative(0, scrollState.deltaY());
+            scrolled = true;
+        }
+    }
+
+    if (!scrolled)
+        return;
+
+    // We need to setCurrentNativeScrollingElement in both the
+    // distributeScroll and applyScroll default implementations so
+    // that if JS overrides one of these methods, but not the
+    // other, this bookkeeping remains accurate.
+    scrollState.setCurrentNativeScrollingElement(this);
+    if (scrollState.fromUserInput())
+        document().frame()->view()->setWasScrolledByUser(true);
+};
+
 static float localZoomForRenderer(LayoutObject& renderer)
 {
     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
     // other out, but the alternative is that we'd have to crawl up the whole render tree every
     // time (or store an additional bit in the LayoutStyle to indicate that a zoom was specified).
     float zoomFactor = 1;
     if (renderer.style()->effectiveZoom() != 1) {
         // Need to find the nearest enclosing LayoutObject that set up
         // a differing zoom, and then we divide our result by it to eliminate the zoom.
         LayoutObject* prev = &renderer;
@@ skipping 2892 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink