Add a helper for implementing Promise-valued properties.

Source/bindings/core/v8/ScriptPromisePropertyBase.cpp

Index: Source/bindings/core/v8/ScriptPromisePropertyBase.cpp
diff --git a/Source/bindings/core/v8/ScriptPromisePropertyBase.cpp b/Source/bindings/core/v8/ScriptPromisePropertyBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d62d9dfd10dc560cf6145faff9d69e188f04da3
--- /dev/null
+++ b/Source/bindings/core/v8/ScriptPromisePropertyBase.cpp
@@ -0,0 +1,143 @@
+// Copyright 2014 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 "bindings/core/v8/ScriptPromisePropertyBase.h"
+
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8HiddenValue.h"
+#include "core/dom/ExecutionContext.h"
+#include "wtf/text/StringBuilder.h"
+
+namespace WebCore {
+
+static String makeName(const char* name, const char* suffix)
+{
+    StringBuilder builder;
+    builder.append(name);
+    builder.append(suffix);
+    return builder.toString();
+}
+
+ScriptPromisePropertyBase::ScriptPromisePropertyBase(ExecutionContext* executionContext, const char* name)
+    : ContextLifecycleObserver(executionContext)
+    , m_isolate(toIsolate(executionContext))
+    , m_state(Pending)
+{
+    v8::HandleScope handleScope(m_isolate);

[haraken, 2014/07/02 09:04:31]

The HandleScope is not needed.

+    m_resolverName = makeName(name, "/Resolver");
+    m_promiseName = makeName(name, "/Promise");

[haraken, 2014/07/02 09:04:32]

It's a bit fragile that there is no mechanism to prevent name conflict (then
something unexpected/dangerous will happen).

How about forcing developers to list up the names in V8HiddenValue.h?

+}
+
+ScriptPromisePropertyBase::~ScriptPromisePropertyBase()
+{
+    v8::HandleScope handleScope(m_isolate);
+    v8::Handle<v8::Object> wrapper = m_mainWorldWrapper.newLocal(m_isolate);
+    if (!wrapper.IsEmpty()) {
+        v8::Handle<v8::String> resolverName = v8String(m_isolate, m_resolverName);
+        wrapper->DeleteHiddenValue(resolverName);
+        v8::Handle<v8::String> promiseName = v8String(m_isolate, m_promiseName);
+        wrapper->DeleteHiddenValue(promiseName);
+    }
+}
+
+static void clearHandle(const v8::WeakCallbackData<v8::Object, ScopedPersistent<v8::Object> >& data)
+{
+    data.GetParameter()->clear();
+}
+
+ScriptPromise ScriptPromisePropertyBase::promise(DOMWrapperWorld& world)
+{
+    if (!executionContext())
+        return ScriptPromise();
+
+    if (!world.isMainWorld()) {
+        // FIXME: Support isolated worlds.
+        return ScriptPromise();
+    }
+
+    v8::HandleScope handleScope(m_isolate);
+    v8::Handle<v8::Context> context = toV8Context(executionContext(), world);
+    if (context.IsEmpty())
+        return ScriptPromise();
+    ScriptState* scriptState = ScriptState::from(context);
+    ScriptState::Scope scope(scriptState);
+
+    v8::Handle<v8::String> resolverName = v8String(m_isolate, m_resolverName);
+    v8::Handle<v8::String> promiseName = v8String(m_isolate, m_promiseName);
+
+    v8::Handle<v8::Object> wrapper = m_mainWorldWrapper.newLocal(m_isolate);
+    if (wrapper.IsEmpty()) {
+        wrapper = holder(context->Global(), m_isolate);
+        ASSERT(!wrapper.IsEmpty());
+        ASSERT(V8HiddenValue::getHiddenValue(m_isolate, wrapper, resolverName).IsEmpty());
+        ASSERT(V8HiddenValue::getHiddenValue(m_isolate, wrapper, promiseName).IsEmpty());
+        m_mainWorldWrapper.set(m_isolate, wrapper);
+        m_mainWorldWrapper.setWeak(&m_mainWorldWrapper, &clearHandle);
+    }
+    ASSERT(wrapper->CreationContext() == context);
+
+    v8::Handle<v8::Promise> promise = V8HiddenValue::getHiddenValue(m_isolate, wrapper, promiseName).As<v8::Promise>();
+    if (!promise.IsEmpty()) {
+        // Return cached Promise
+        return ScriptPromise(scriptState, promise);
+    }
+
+    // Create and cache the Promise
+    v8::Handle<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(m_isolate);
+    promise = resolver->GetPromise();
+    V8HiddenValue::setHiddenValue(m_isolate, wrapper, promiseName, promise);
+    V8HiddenValue::setHiddenValue(m_isolate, promise, promiseName, wrapper);
+
+    switch (m_state) {
+    case Pending:
+        // Cache the resolver too
+        V8HiddenValue::setHiddenValue(m_isolate, wrapper, resolverName, resolver);
+        break;
+    case Resolved:
+    case Rejected:
+        resolveOrReject(resolver);
+        break;
+    }
+
+    return ScriptPromise(scriptState, promise);
+}
+
+void ScriptPromisePropertyBase::settle(State targetState)
+{
+    ASSERT(executionContext());
+    ASSERT(m_state == Pending);
+    ASSERT(targetState == Resolved || targetState == Rejected);
+
+    m_state = targetState;
+
+    v8::HandleScope handleScope(m_isolate);
+    v8::Handle<v8::Object> wrapper = m_mainWorldWrapper.newLocal(m_isolate);
+    if (wrapper.IsEmpty())
+        return; // wrapper has died or was never populated

[haraken, 2014/07/02 09:04:32]

Is this a valid state? In order to provide deterministic behavior to JavaScript,
I think we need to make sure that the holder wrapper is kept alive as long as
the Promise alive.

If so, probably we can add a flag that is set when the weak callback is called,
and assert that the flag is not set here.

[dominicc (has gone to gerrit), 2014/07/03 02:13:39]

We don't want to prevent garbage collection! So if we made this a strong
reference, we would need a protocol to say when the object is "stopped." It gets
more complicated in the isolated world case--we don't want to prevent an
isolated world's context from being collected, even if the property is still
"alive" in the main world.

A weak reference to the wrapper works for this. Because you access properties
through the holder (eg navigator.serviceWorker.ready) and the holder is already
being kept alive (window -> navigator -> etc. in the ServiceWorkerContainer
case) then we have at least the lifetime we need and no leaks.

Obviously there is a risk that if the holder is leaked for other reasons, or
there's time while the world is dying but we didn't GC yet, we will settle its
Promise. But having an explicit shut-down protocol does not make those problems
go away.

+    ScriptState::Scope scope(ScriptState::from(wrapper->CreationContext()));
+
+    v8::Handle<v8::String> resolverName = v8String(m_isolate, m_resolverName);
+    v8::Handle<v8::Promise::Resolver> resolver = V8HiddenValue::getHiddenValue(m_isolate, wrapper, resolverName).As<v8::Promise::Resolver>();
+
+    V8HiddenValue::deleteHiddenValue(m_isolate, wrapper, resolverName);

[haraken, 2014/07/02 09:04:31]

Can we delete the hidden value for the Promise as well?

[dominicc (has gone to gerrit), 2014/07/03 02:13:39]

No. We need to keep the reference to the Promise because somebody may get the
Promise object (eg through navigator.serviceWorker.ready) after it has been
settled and we need to return the same object to them, too. Accessing the
Promise after settling is a valid, maybe even typical, use case.

+    resolveOrReject(resolver);
+}
+
+void ScriptPromisePropertyBase::resolveOrReject(v8::Handle<v8::Promise::Resolver> resolver)

[haraken, 2014/07/02 09:04:32]

Shall we rename settle to resolveOrReject, and resolveOrReject to
resolveOrRejectInternal? We want to use resolveOrReject for an exposed method.

+{
+    switch (m_state) {
+    case Pending:
+        ASSERT_NOT_REACHED();
+        break;
+    case Resolved:
+        resolver->Resolve(resolvedValue(resolver->CreationContext()->Global(), m_isolate));
+        break;
+    case Rejected:
+        resolver->Reject(rejectedValue(resolver->CreationContext()->Global(), m_isolate));
+        break;
+    }
+}
+
+} // namespace WebCore