Enable V8 Promises.

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/V8PerIsolateData.h"
+#include "core/dom/ExecutionContextTask.h"
+#include "wtf/PassOwnPtr.h"
+
 namespace WebCore {
 
+namespace {
+
+class RunMicrotasksTask FINAL : public ExecutionContextTask {
+public:
+    static PassOwnPtr<RunMicrotasksTask> create(NewScriptState* scriptState)
+    {
+        return adoptPtr<RunMicrotasksTask>(new RunMicrotasksTask(scriptState));
+    }
+
+    virtual void performTask(ExecutionContext* executionContext) OVERRIDE
+    {
+        if (m_scriptState->contextIsEmpty())
+            return;
+        if (executionContext->activeDOMObjectsAreStopped())
+            return;
+        NewScriptState::Scope scope(m_scriptState.get());
+        v8::V8::RunMicrotasks(m_scriptState->isolate());
+    }
+
+private:
+    explicit RunMicrotasksTask(NewScriptState* scriptState) : m_scriptState(scriptState) { }
+    RefPtr<NewScriptState> m_scriptState;
+};
+
+} // namespace
+
 ScriptPromiseResolverWithContext::ScriptPromiseResolverWithContext(NewScriptState* scriptState)
     : ActiveDOMObject(scriptState->executionContext())
     , m_state(Pending)
     , m_scriptState(scriptState)
-    , m_timer(this, &ScriptPromiseResolverWithContext::resolveOrRejectImmediately)
+    , m_timer(this, &ScriptPromiseResolverWithContext::onTimerFired)
     , m_resolver(ScriptPromiseResolver::create(m_scriptState->executionContext())) { }
 
 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()
 {
     m_timer.stop();
     clear();
 }
 
-void ScriptPromiseResolverWithContext::resolveOrRejectImmediately(Timer<ScriptPromiseResolverWithContext>*)
+void ScriptPromiseResolverWithContext::onTimerFired(Timer<ScriptPromiseResolverWithContext>*)
+{
+    RefPtr<ScriptPromiseResolverWithContext> protect(this);
+    NewScriptState::Scope scope(m_scriptState.get());
+    v8::Isolate* isolate = m_scriptState->isolate();
+    resolveOrRejectImmediately();
+
+    // There is no need to post a RunMicrotasksTask because it is safe to
+    // call RunMicrotasks here.
+    v8::V8::RunMicrotasks(isolate);
+}
+
+void ScriptPromiseResolverWithContext::resolveOrRejectImmediately()
 {
     ASSERT(!executionContext()->activeDOMObjectsAreStopped());
     ASSERT(!executionContext()->activeDOMObjectsAreSuspended());
     if (m_state == Resolving) {
-        NewScriptState::Scope scope(m_scriptState.get());
         m_resolver->resolve(m_value.newLocal(m_scriptState->isolate()));
     } else {
         ASSERT(m_state == Rejecting);
-        NewScriptState::Scope scope(m_scriptState.get());
         m_resolver->reject(m_value.newLocal(m_scriptState->isolate()));
     }
-    m_state = ResolvedOrRejected;
     clear();
 }
 
+void ScriptPromiseResolverWithContext::postRunMicrotasks()
+{
+    executionContext()->postTask(RunMicrotasksTask::create(m_scriptState.get()));
+}
+
 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.
 }
 
 } // namespace WebCore