Expose scroll customization for touch to JS (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 95 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/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/page/scrolling/ScrollStateCallback.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 337 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)
+namespace {
+
+NativeScrollBehavior toNativeScrollBehavior(String nativeScrollBehavior)
+{
+    DEFINE_STATIC_LOCAL(const String, disable, ("disable-native-scroll"));
+    DEFINE_STATIC_LOCAL(const String, before, ("perform-before-native-scroll"));
+    DEFINE_STATIC_LOCAL(const String, after, ("perform-after-native-scroll"));
+
+    if (nativeScrollBehavior == disable)
+        return DisableNativeScroll;
+    if (nativeScrollBehavior == before)
+        return PerformBeforeNativeScroll;
+    if (nativeScrollBehavior == after)
+        return PerformAfterNativeScroll;
+
+    ASSERT_NOT_REACHED();
+    return DisableNativeScroll;
+}
+
+} // namespace
+
+void Element::setDistributeScroll(ScrollStateCallback* scrollStateCallback, String nativeScrollBehavior)
+{
+    scrollStateCallback->setNativeScrollBehavior(toNativeScrollBehavior(nativeScrollBehavior));
+    ensureElementRareData().setDistributeScroll(scrollStateCallback);
+}
+
+void Element::setApplyScroll(ScrollStateCallback* scrollStateCallback, String nativeScrollBehavior)
+{
+    scrollStateCallback->setNativeScrollBehavior(toNativeScrollBehavior(nativeScrollBehavior));
+    ensureElementRareData().setApplyScroll(scrollStateCallback);
+}
+
+void Element::nativeDistributeScroll(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);
+    callApplyScroll(scrollState);
 
     if (deltaX != scrollState.deltaX() || deltaY != scrollState.deltaY())
         scrollState.setCurrentNativeScrollingElement(this);
 }
 
-void Element::applyScroll(ScrollState& scrollState)
+void Element::callDistributeScroll(ScrollState& scrollState)
+{
+    if (!hasRareData() || !elementRareData()->getDistributeScroll()) {
+        nativeDistributeScroll(scrollState);
+    } else {
+        ScrollStateCallback& callback = *elementRareData()->getDistributeScroll();
+        if (callback.nativeScrollBehavior() == PerformAfterNativeScroll)
+            nativeDistributeScroll(scrollState);
+        callback.handleEvent(&scrollState);
+        if (callback.nativeScrollBehavior() == PerformBeforeNativeScroll)
+            nativeDistributeScroll(scrollState);
+    }
+};
+
+void Element::nativeApplyScroll(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()) {
+    if (deltaY || deltaX)
+        document().updateLayoutIgnorePendingStylesheets();
+
+    // Handle the scrollingElement separately, as it scrolls the FrameView.
+    if (this == document().scrollingElement()) {
         FloatSize delta(deltaX, deltaY);
         if (document().frame()->applyScrollDelta(delta, scrollState.isBeginning()).didScroll()) {
             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
@@ skipping 14 matching lines @@
 
     // 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);
 };
 
+void Element::callApplyScroll(ScrollState& scrollState)
+{
+    if (!hasRareData() || !elementRareData()->getApplyScroll()) {
+        nativeApplyScroll(scrollState);
+    } else {
+        ScrollStateCallback& callback = *elementRareData()->getApplyScroll();
+        if (callback.nativeScrollBehavior() == PerformAfterNativeScroll)
+            nativeApplyScroll(scrollState);
+        callback.handleEvent(&scrollState);
+        if (callback.nativeScrollBehavior() == PerformBeforeNativeScroll)
+            nativeApplyScroll(scrollState);
+    }
+};
+
 static float localZoomForLayoutObject(LayoutObject& layoutObject)
 {
     // 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 layout tree every
     // time (or store an additional bit in the ComputedStyle to indicate that a zoom was specified).
     float zoomFactor = 1;
     if (layoutObject.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 = &layoutObject;
@@ skipping 2874 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink