Introduce KeepAliveWhilePending to ScriptPromiseResolverWithContext.

Source/bindings/v8/ScriptPromiseResolverWithContext.cpp

 // 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/v8/ScriptPromiseResolverWithContext.h"
 
 #include "bindings/v8/V8RecursionScope.h"
 
 namespace WebCore {
 
+namespace {
+const char hiddenPropertyName[] = "blink::keepObjectWhilePending";
+} // namespace
+
 ScriptPromiseResolverWithContext::ScriptPromiseResolverWithContext(ScriptState* scriptState)
     : ActiveDOMObject(scriptState->executionContext())
     , m_state(Pending)
     , m_scriptState(scriptState)
     , m_timer(this, &ScriptPromiseResolverWithContext::onTimerFired)
     , m_resolver(ScriptPromiseResolver::create(m_scriptState.get()))
 {
 }
 
+ScriptPromiseResolverWithContext::~ScriptPromiseResolverWithContext()
+{
+    if (m_state != ResolvedOrRejected) {
+        ScriptState::Scope scope(m_scriptState.get());
+        unregisterKeptObject();
+        reject(v8::Exception::Error(v8::String::NewFromUtf8(m_scriptState->isolate(),
+            "ScriptPromiseResolverWithContext is destructed without resolve / reject")));
+    }
+}
+
 void ScriptPromiseResolverWithContext::suspend()
 {
     m_timer.stop();
 }
 
 void ScriptPromiseResolverWithContext::resume()
 {
     if (m_state == Resolving || m_state == Rejecting)
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void ScriptPromiseResolverWithContext::stop()
 {
+    ScriptState::Scope scope(m_scriptState.get());
+    unregisterKeptObject();
     m_timer.stop();
     clear();
 }
 
 void ScriptPromiseResolverWithContext::onTimerFired(Timer<ScriptPromiseResolverWithContext>*)
 {
     RefPtr<ScriptPromiseResolverWithContext> protect(this);
     ScriptState::Scope scope(m_scriptState.get());
     resolveOrRejectImmediately();
 }
 
 void ScriptPromiseResolverWithContext::resolveOrRejectImmediately()
 {
     ASSERT(!executionContext()->activeDOMObjectsAreStopped());
     ASSERT(!executionContext()->activeDOMObjectsAreSuspended());
     {
         // FIXME: The V8RecursionScope is only necessary to force microtask delivery for promises
         // resolved or rejected in workers. It can be removed once worker threads run microtasks
         // at the end of every task (rather than just the main thread).
         V8RecursionScope scope(m_scriptState->isolate(), m_scriptState->executionContext());
         if (m_state == Resolving) {
             m_resolver->resolve(m_value.newLocal(m_scriptState->isolate()));
+            unregisterKeptObject();
         } else {
             ASSERT(m_state == Rejecting);
             m_resolver->reject(m_value.newLocal(m_scriptState->isolate()));
+            unregisterKeptObject();
         }
     }
     clear();
 }
 
 void ScriptPromiseResolverWithContext::clear()
 {
     ResolutionState state = m_state;
     m_state = ResolvedOrRejected;
     m_resolver.clear();
     m_value.clear();
     if (state == Resolving || state == Rejecting) {
         // |ref| was called in |resolveOrReject|.
         deref();
     }
     // |this| may be deleted here.
 }
 
+void ScriptPromiseResolverWithContext::keepObjectWhilePendingInternal(v8::Handle<v8::Value> value)
+{
+    ScriptState::Scope scope(m_scriptState.get());
+    if (!m_resolver)
+        return;
+    ScriptPromise promise = this->promise();
+    if (promise.isEmpty())
+        return;
+    v8::Local<v8::Promise> v8Promise = promise.v8Value().As<v8::Promise>();
+    v8::Local<v8::String> name = v8::String::NewFromUtf8(m_scriptState->isolate(), hiddenPropertyName);
+    ASSERT(v8Promise->GetHiddenValue(name).IsEmpty());
+    v8Promise->SetHiddenValue(name, value);
+}
+
+void ScriptPromiseResolverWithContext::unregisterKeptObject()
+{
+    if (!m_resolver)
+        return;
+    ASSERT(m_scriptState->isolate()->InContext());
+    ScriptPromise promise = this->promise();

[jrummell, 2014/06/12 20:10:24]

The comment for promise() states "an empty ScriptPromise will be returned after
resolve or reject is called." On lines 72 & 76 this method is called after
resolve/reject, so will the isEmpty() call below always return true?

[yhirano, 2014/06/13 04:19:30]

You are right, thanks for pointing it out.
Fixed.

+    if (promise.isEmpty())
+        return;
+    v8::Local<v8::Promise> v8Promise = promise.v8Value().As<v8::Promise>();
+    v8::Local<v8::String> name = v8::String::NewFromUtf8(m_scriptState->isolate(), hiddenPropertyName);
+    v8Promise->DeleteHiddenValue(name);
+}
+
 } // namespace WebCore