Expose scroll customization for touch to JS (behind REF).

Source/core/page/scrolling/ScrollStateCallback.cpp

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/page/scrolling/ScrollStateCallback.h"

[haraken, 2015/06/27 08:09:33]

This file uses V8 APIs. So this should go to
Source/bindings/core/v8/ScrollStateCallback.h

[tdresser, 2015/06/29 20:59:33]

It looks like this is a bit tricky, as the idl file can't be moved to that
location. I've factored out the V8 API bits into
ScrollStateCallbackToScriptValue.

+
+#include "bindings/core/v8/V8Element.h"
+#include "bindings/core/v8/V8ScrollState.h"
+
+namespace blink {
+
+namespace {
+
+    static const char applyScrollRequiresScrollStateObject[]

[haraken, 2015/06/27 08:09:33]

Nit: Don't need the identation.

[tdresser, 2015/06/29 20:59:33]

Done.

+        = "applyScroll takes a ScrollState object.";
+    static const char distributeScrollRequiresScrollStateObject[]
+        = "distributeScroll takes a ScrollState object.";
+
+    // Key in |data| passed to scrollStateFunctionCallback.
+    const char* kHandlerFunction = "handler_function";
+
+} // namespace
+
+static void scrollStateFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Isolate* isolate = info.GetIsolate();
+
+    v8::Local<v8::Object> data = info.Data().As<v8::Object>();
+    v8::MaybeLocal<v8::Value> maybeScrollStateCallback =
+        data->Get(v8::String::NewFromUtf8(info.GetIsolate(), kHandlerFunction));

[haraken, 2015/06/27 08:09:33]

Nit: You don't need to wrap lines at 80 characters. 120 characters or so are OK
in Blink. The same comment for other parts in this CL.

[tdresser, 2015/06/29 20:59:33]

Ran git cl format.

+    v8::Local<v8::Value> localScrollStateCallback =
+        maybeScrollStateCallback.ToLocalChecked();

[haraken, 2015/06/27 08:09:33]

  if (!data->Get(...).ToLocal(&localScrollStateCallback))
    return;

I don't like the complexity around Maybe V8 APIs, but we cannot avoid this...

[tdresser, 2015/06/29 20:59:33]

Done. (I'm still using a temporary, as it looks like I'd need an explicit cast
to MaybeLocal to avoid getting the v8::Local version otherwise.)

+
+    ASSERT(!localScrollStateCallback->IsUndefined());
+    ASSERT(localScrollStateCallback->IsExternal());
+    ScrollStateCallback* scrollStateCallback = static_cast<ScrollStateCallback*>(
+        localScrollStateCallback.As<v8::External>()->Value());
+
+    ASSERT(scrollStateCallback->callbackType() != ScrollStateCallback::CallbackType::UNSET);
+    bool isDistributeScroll = scrollStateCallback->callbackType()
+        == ScrollStateCallback::CallbackType::DISTRIBUTE_SCROLL;
+    const char* errorMessage = isDistributeScroll
+        ? distributeScrollRequiresScrollStateObject
+        : applyScrollRequiresScrollStateObject;
+    if (!info[0]->IsObject()) {
+        info.GetIsolate()->ThrowException(v8::Exception::TypeError(v8::String::NewFromUtf8(
+            isolate, errorMessage)));
+        return;
+    }
+    v8::Local<v8::Object> scrollStateObject = info[0]->ToObject();
+
+    if (!V8ScrollState::wrapperTypeInfo.domTemplateFunction(isolate)->HasInstance(
+        scrollStateObject)) {
+        info.GetIsolate()->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, errorMessage)));
+        return;
+    }
+
+    ScrollState* scrollState = toScriptWrappable(scrollStateObject)->toImpl<ScrollState>();
+    ASSERT(scrollState);
+
+    Element* targetElement = toScriptWrappable(info.Holder())->toImpl<Element>();
+    ASSERT(targetElement);
+    scrollStateCallback->handleEventForElement(*targetElement, scrollState);
+}
+
+ScrollStateCallback::ScrollStateCallback()
+    : m_callbackType(CallbackType::UNSET)
+{
+}
+
+void ScrollStateCallback::handleEventForElement(Element& targetElement, ScrollState* scrollState)
+{
+    m_targetElement = &targetElement;
+    handleEvent(scrollState);
+    m_targetElement = nullptr;
+}
+
+ScriptValue ScrollStateCallback::toScriptValue(ScriptState* scriptState)
+{
+    v8::Isolate* isolate = scriptState->isolate();
+    v8::Local<v8::Signature> signature
+        = v8::Signature::New(isolate, V8Element::wrapperTypeInfo.domTemplateFunction(isolate));
+
+    v8::Local<v8::Object> data = v8::Object::New(isolate);
+    data->Set(v8::String::NewFromUtf8(isolate, kHandlerFunction), v8::External::New(isolate, this));

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

I'm fairly sure this is wrong. The v8::External doesn't ref the
ScrollStateCallback, which allows it to be deleted while JS still has a
reference to it. I'm not sure what the correct fix is here though.

[haraken, 2015/06/27 08:09:33]

I don't understand why you need the complexity about creating a function
template etc.

For example, in case of Document.requestAnimationFrame, we just need to
implement FrameRequestCallback, which is fairly straightforward and simple. Why
do we need all the complexity for ScrollStateCallback?

[tdresser, 2015/06/29 20:59:33]

I've written up a quick doc summarizing the requirements we're meeting with this
patch here:
https://docs.google.com/document/d/1Uu7ZudjaGk1zUVMGBtkZs1pslSU3iUHcyPlPv-cX6...

I've addressed this in the Requirements section:
https://docs.google.com/document/d/1Uu7ZudjaGk1zUVMGBtkZs1pslSU3iUHcyPlPv-cX6...

In short, the reason we need all this complexity is that we need to be able to
pass a ScrollStateCallback back out to JavaScript, which isn't a requirement for
requestAnimationFrame.

+
+    v8::Local<v8::FunctionTemplate> functionTemplate = v8::FunctionTemplate::New(
+        scriptState->isolate(), &scrollStateFunctionCallback, data, signature);
+
+    ASSERT(callbackType() != CallbackType::UNSET);
+
+    bool isDistributeScroll = callbackType() == CallbackType::DISTRIBUTE_SCROLL;
+    functionTemplate->SetClassName(
+        v8AtomicString(isolate, isDistributeScroll ? "distributeScroll" : "applyScroll"));
+    v8::MaybeLocal<v8::Function> function = functionTemplate->GetFunction(scriptState->context());
+    return ScriptValue(scriptState, function);
+}
+
+} // namespace blink