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 12 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/dom/Element.h"
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/ScriptFunctionCall.h"
+#include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "core/CSSValueKeywords.h"
 #include "core/SVGNames.h"
 #include "core/XLinkNames.h"
 #include "core/XMLNames.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 427 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)
+// Returns true iff a V8 method existed and was called.
+static bool callScrollCustomizationV8Method(Element* element,
+    ScrollState& scrollState, String methodName)
+{
+    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+
+    LocalFrame* frame = element->document().frame();
+    if (!frame)
+        return false;
+    ScriptState* scriptState = ScriptState::forMainWorld(frame);

[haraken, 2015/06/09 00:07:13]

Why can we assume the main world?

[tdresser, 2015/06/09 14:27:42]

We're okay if scroll customization methods can only be assigned from the main
world.

My understanding is that currently, if you assign a scroll customization method
from a world other than the main world, this code will pay no attention to it.
Is that correct?

[haraken, 2015/06/09 15:16:38]

That is not OK. Unless you have a strong reason to do so, we should support the
Web API in isolated worlds as well.
If an isolated world assigns a scroll customization method, it will install the
method on the main world -- which is not correct.

Assuming that callScrollCustomizationV8Method is called from only JavaScript, I
think you can use:

  ScriptState* scriptState = ScriptState::current(toIsolate(frame));

which will give you the ScriptState of the JS that called the
callScrollCustomizationV8Method.

(However, I'd strongly recommend using a callback interface because that's a
standard way to handle this kind of situation in a safe manner.)

[tdresser, 2015/06/26 14:53:15]

callScrollCustomizationV8Method is never called from JavaScript.

+    ScriptState::Scope scope(scriptState);
+
+    v8::Handle<v8::Object> creationContext = scriptState->context()->Global();
+    ScriptValue thisWrapper = ScriptValue(scriptState, toV8(element, creationContext, scriptState->isolate()));
+    ScriptValue scrollStateWrapper = ScriptValue(scriptState, toV8(&scrollState, creationContext, scriptState->isolate()));
+
+    v8::Handle<v8::Object> thisObject = v8::Handle<v8::Object>::Cast(thisWrapper.v8Value());
+    v8::Local<v8::Value> functionValue = thisObject->Get(v8String(scriptState->isolate(), methodName));
+    ASSERT(functionValue->IsFunction());
+    v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(functionValue);
+
+    // Native methods should avoid the performance overhead of a v8 method call.
+    if (function->ScriptId() == v8::UnboundScript::kNoScriptId)
+        return false;
+
+    ScriptFunctionCall functionCall(thisWrapper, methodName);

[haraken, 2015/06/09 00:07:12]

ScriptFunctionCall is an abstraction for devtools. Can we use
V8ScriptRunner::callFunction?

[tdresser, 2015/06/09 14:27:42]

Done.

+    functionCall.appendArgument(scrollStateWrapper);
+    functionCall.call();
+    return true;
+}
+
+void Element::distributeScrollNative(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 (!callScrollCustomizationV8Method(this, scrollState, "distributeScroll"))
+        distributeScrollNative(scrollState);
+};
+
+void Element::distributeScroll(ScrollState* scrollState)
+{
+    ASSERT(scrollState);
+    distributeScrollNative(*scrollState);
+}
+
+void Element::applyScrollNative(ScrollState& scrollState)
 {
     ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    document().updateLayoutIgnorePendingStylesheets();
+
     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()) {
+    // Handle the scrollingElement separately, as it scrolls the FrameView.
+    if (this == document().scrollingElement()) {
         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
@@ 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 (!callScrollCustomizationV8Method(this, scrollState, "applyScroll"))
+        applyScrollNative(scrollState);
+};
+
+void Element::applyScroll(ScrollState* scrollState)
+{
+    ASSERT(scrollState);
+    applyScrollNative(*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 2888 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink