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/loader/DocumentLoader.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/ScrollCustomizationCallbacks.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"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
 
 namespace blink {
 
+namespace {
+
+// We need to retain the scroll customization callbacks until the element
+// they're associated with is destroyed. It would be simplest if the callbacks
+// could be stored in ElementRareData, but we can't afford the space
+// increase. Instead, keep the scroll customization callbacks here. The other
+// option would be to store these callbacks on the FrameHost or document, but
+// that necessitates a bunch more logic for transferring the callbacks between
+// FrameHosts when elements are moved around.
+ScrollCustomizationCallbacks& scrollCustomizationCallbacks()
+{
+    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    DEFINE_STATIC_LOCAL(Persistent<ScrollCustomizationCallbacks>,
+        scrollCustomizationCallbacks, (new ScrollCustomizationCallbacks()));
+    return *scrollCustomizationCallbacks;
+}
+
+} // namespace
+
 using namespace HTMLNames;
 using namespace XMLNames;
 
 PassRefPtrWillBeRawPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRefWillBeNoop(new Element(tagName, document, CreateElement));
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
 }
 
 Element::~Element()
 {
     ASSERT(needsAttach());
 
 #if !ENABLE(OILPAN)
     if (hasRareData()) {
         elementRareData()->clearShadow();
         detachAllAttrNodesFromElement();
     }
 
     if (isCustomElement())
         CustomElement::wasDestroyed(this);
 
+    if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
+        scrollCustomizationCallbacks().removeCallbacksForElement(this);

[Rick Byers, 2015/08/30 20:57:50]

So in the Oilpan case I assume the weak collections automatically remove entries
that get collected, right?  Cool!

[haraken, 2015/08/30 22:21:37]

Right :)

+
     // With Oilpan, either the Element has been removed from the Document
     // or the Document is dead as well. If the Element has been removed from
     // the Document the element has already been removed from the pending
     // resources. If the document is also dead, there is no need to remove
     // the element from the pending resources.
     if (hasPendingResources()) {
         document().accessSVGExtensions().removeElementFromPendingResources(this);
         ASSERT(!hasPendingResources());
     }
 #endif
@@ skipping 295 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)
+void Element::setDistributeScroll(ScrollStateCallback* scrollStateCallback, String nativeScrollBehavior)
+{
+    scrollStateCallback->setNativeScrollBehavior(ScrollStateCallback::toNativeScrollBehavior(nativeScrollBehavior));
+    scrollCustomizationCallbacks().setDistributeScroll(this, scrollStateCallback);
+}
+
+void Element::setApplyScroll(ScrollStateCallback* scrollStateCallback, String nativeScrollBehavior)
+{
+    scrollStateCallback->setNativeScrollBehavior(ScrollStateCallback::toNativeScrollBehavior(nativeScrollBehavior));
+    scrollCustomizationCallbacks().setApplyScroll(this, 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)
+{
+    ScrollStateCallback* callback = scrollCustomizationCallbacks().getDistributeScroll(this);
+    if (!callback) {
+        nativeDistributeScroll(scrollState);
+        return;
+    }
+
+    if (callback->nativeScrollBehavior() != NativeScrollBehavior::PerformAfterNativeScroll)
+        callback->handleEvent(&scrollState);
+    if (callback->nativeScrollBehavior() != NativeScrollBehavior::DisableNativeScroll)
+        nativeDistributeScroll(scrollState);
+    if (callback->nativeScrollBehavior() == NativeScrollBehavior::PerformAfterNativeScroll)
+        callback->handleEvent(&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 viewport.
+    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 16 matching lines @@
     // 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()) {
         if (DocumentLoader* documentLoader = document().loader())
             documentLoader->initialScrollState().wasScrolledByUser = true;
     }
 };
 
+void Element::callApplyScroll(ScrollState& scrollState)
+{
+    ScrollStateCallback* callback = scrollCustomizationCallbacks().getApplyScroll(this);
+    if (!callback) {
+        nativeApplyScroll(scrollState);
+        return;
+    }
+
+    if (callback->nativeScrollBehavior() != NativeScrollBehavior::PerformAfterNativeScroll)
+        callback->handleEvent(&scrollState);
+    if (callback->nativeScrollBehavior() != NativeScrollBehavior::DisableNativeScroll)
+        nativeApplyScroll(scrollState);
+    if (callback->nativeScrollBehavior() == NativeScrollBehavior::PerformAfterNativeScroll)
+        callback->handleEvent(&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 2939 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink