Revert of 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 94 matching lines @@
 #include "core/html/HTMLTemplateElement.h"
 #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/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);
-
     // 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::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)
+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();
 
-    callApplyScroll(scrollState);
+    applyScroll(scrollState);
 
     if (deltaX != scrollState.deltaX() || deltaY != scrollState.deltaY())
         scrollState.setCurrentNativeScrollingElement(this);
 }
 
-void Element::callDistributeScroll(ScrollState& scrollState)
-{
-    ScrollStateCallback* callback = scrollCustomizationCallbacks().getDistributeScroll(this);
-    if (!callback) {
-        nativeDistributeScroll(scrollState);
-    } else {
-        if (callback->nativeScrollBehavior() == NativeScrollBehavior::PerformAfterNativeScroll)
-            nativeDistributeScroll(scrollState);
-        callback->handleEvent(&scrollState);
-        if (callback->nativeScrollBehavior() == NativeScrollBehavior::PerformBeforeNativeScroll)
-            nativeDistributeScroll(scrollState);
-    }
-};
-
-void Element::nativeApplyScroll(ScrollState& scrollState)
+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;
 
-    if (deltaY || deltaX)
-        document().updateLayoutIgnorePendingStylesheets();
-
-    // Handle the scrollingElement separately, as it scrolls the viewport.
-    if (this == document().scrollingElement()) {
+    // Handle the documentElement separately, as it scrolls the FrameView.
+    if (this == document().documentElement()) {
         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)
-{
-    ScrollStateCallback* callback = scrollCustomizationCallbacks().getApplyScroll(this);
-    if (!callback) {
-        nativeApplyScroll(scrollState);
-    } else {
-        if (callback->nativeScrollBehavior() == NativeScrollBehavior::PerformAfterNativeScroll)
-            nativeApplyScroll(scrollState);
-        callback->handleEvent(&scrollState);
-        if (callback->nativeScrollBehavior() == 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 2894 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink