Implement AP2 Promises

Source/bindings/v8/custom/V8PromiseCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #include "config.h"
 #include "bindings/v8/custom/V8PromiseCustom.h"
 
 #include "V8Promise.h"
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptFunctionCall.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
+#include "bindings/v8/V8HiddenPropertyName.h"
 #include "bindings/v8/V8PerIsolateData.h"
 #include "bindings/v8/V8ScriptRunner.h"
 #include "bindings/v8/WrapperTypeInfo.h"
 #include "core/dom/Document.h"
 #include "core/page/DOMWindow.h"
 #include "core/platform/Task.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "wtf/Functional.h"
+#include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
+#include "wtf/Vector.h"
 #include <v8.h>
 
 namespace WebCore {
 
 namespace {
 
 v8::Local<v8::ObjectTemplate> cachedObjectTemplate(void* privateTemplateUniqueKey, int internalFieldCount, v8::Isolate* isolate)
 {
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     WrapperWorldType currentWorldType = worldType(isolate);
     v8::Handle<v8::FunctionTemplate> functionDescriptor = data->privateTemplateIfExists(currentWorldType, privateTemplateUniqueKey);
     if (!functionDescriptor.IsEmpty())
         return functionDescriptor->InstanceTemplate();
 
     functionDescriptor = v8::FunctionTemplate::New();
     v8::Local<v8::ObjectTemplate> instanceTemplate = functionDescriptor->InstanceTemplate();
     instanceTemplate->SetInternalFieldCount(internalFieldCount);
     data->setPrivateTemplate(currentWorldType, privateTemplateUniqueKey, functionDescriptor);
     return instanceTemplate;
 }
 
-v8::Local<v8::ObjectTemplate> wrapperCallbackEnvironmentObjectTemplate(v8::Isolate* isolate)
-{
-    // This is only for getting a unique pointer which we can pass to privateTemplate.
-    static int privateTemplateUniqueKey = 0;
-    return cachedObjectTemplate(&privateTemplateUniqueKey, V8PromiseCustom::WrapperCallbackEnvironmentFieldCount, isolate);
-}
-
 v8::Local<v8::ObjectTemplate> promiseAllEnvironmentObjectTemplate(v8::Isolate* isolate)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static int privateTemplateUniqueKey = 0;
     return cachedObjectTemplate(&privateTemplateUniqueKey, V8PromiseCustom::PromiseAllEnvironmentFieldCount, isolate);
 }
 
 v8::Local<v8::ObjectTemplate> primitiveWrapperObjectTemplate(v8::Isolate* isolate)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static int privateTemplateUniqueKey = 0;
     return cachedObjectTemplate(&privateTemplateUniqueKey, V8PromiseCustom::PrimitiveWrapperFieldCount, isolate);
 }
 
 v8::Local<v8::ObjectTemplate> internalObjectTemplate(v8::Isolate* isolate)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static int privateTemplateUniqueKey = 0;
     return cachedObjectTemplate(&privateTemplateUniqueKey, V8PromiseCustom::InternalFieldCount, isolate);
 }
 
-class PromiseTask : public ScriptExecutionContext::Task {
+void promiseResolveCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    ASSERT(!args.Data().IsEmpty());
+    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
+    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
+    if (args.Length() > 0)
+        result = args[0];
+
+    V8PromiseCustom::resolve(promise, result, args.GetIsolate());
+}
+
+void promiseRejectCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    ASSERT(!args.Data().IsEmpty());
+    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
+    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
+    if (args.Length() > 0)
+        result = args[0];
+
+    V8PromiseCustom::reject(promise, result, args.GetIsolate());
+}
+
+void promiseAllFulfillCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    ASSERT(!args.Data().IsEmpty());
+    v8::Local<v8::Object> environment = args.Data().As<v8::Object>();
+    v8::Local<v8::Value> result = v8::Undefined(isolate);
+    if (args.Length() > 0)
+        result = args[0];
+
+    v8::Local<v8::Object> promise = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentPromiseIndex).As<v8::Object>();
+    v8::Local<v8::Object> countdownWrapper = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentCountdownIndex).As<v8::Object>();
+    v8::Local<v8::Integer> index = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentIndexIndex).As<v8::Integer>();
+    v8::Local<v8::Array> results = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentResultsIndex).As<v8::Array>();
+
+    results->Set(index->Value(), result);
+
+    v8::Local<v8::Integer> countdown = countdownWrapper->GetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex).As<v8::Integer>();
+    ASSERT(countdown->Value() >= 1);
+    if (countdown->Value() == 1) {
+        V8PromiseCustom::resolve(promise, results, isolate);
+        return;
+    }
+    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1, isolate));
+}
+
+v8::Local<v8::Object> promiseAllEnvironment(v8::Handle<v8::Object> promise, v8::Handle<v8::Object> countdownWrapper, int index, v8::Handle<v8::Array> results, v8::Isolate* isolate)
+{
+    v8::Local<v8::ObjectTemplate> objectTemplate = promiseAllEnvironmentObjectTemplate(isolate);
+    v8::Local<v8::Object> environment = objectTemplate->NewInstance();
+
+    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentPromiseIndex, promise);
+    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentCountdownIndex, countdownWrapper);
+    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentIndexIndex, v8::Integer::New(index, isolate));
+    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentResultsIndex, results);
+    return environment;
+}
+
+// Clear |internal|'s derived array.
+void clearDerived(v8::Handle<v8::Object> internal)
+{
+    internal->SetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex, v8::Array::New());
+    internal->SetInternalField(V8PromiseCustom::InternalRejectCallbackIndex, v8::Array::New());
+    internal->SetInternalField(V8PromiseCustom::InternalDerivedPromiseIndex, v8::Array::New());
+}
+
+// Add a tuple (|derivedPromise|, |onFulfilled|, |onRejected|) to
+// |internal|'s derived array.
+// |internal| must be a Promise internal object.
+// |derivedPromise| must be a Promise instance.
+// |onFulfilled| and |onRejected| can be an empty value respectively.
+void addToDerived(v8::Handle<v8::Object> internal, v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Isolate* isolate)
+{
+    v8::Local<v8::Array> fulfillCallbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
+    v8::Local<v8::Array> rejectCallbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
+    v8::Local<v8::Array> derivedPromises = internal->GetInternalField(V8PromiseCustom::InternalDerivedPromiseIndex).As<v8::Array>();
+
+    if (onFulfilled.IsEmpty()) {
+        fulfillCallbacks->Set(fulfillCallbacks->Length(), v8::Undefined(isolate));
+    } else {
+        fulfillCallbacks->Set(fulfillCallbacks->Length(), onFulfilled);
+    }
+
+    if (onRejected.IsEmpty()) {
+        rejectCallbacks->Set(rejectCallbacks->Length(), v8::Undefined(isolate));
+    } else {
+        rejectCallbacks->Set(rejectCallbacks->Length(), onRejected);
+    }
+
+    ASSERT(!derivedPromise.IsEmpty());
+    derivedPromises->Set(derivedPromises->Length(), derivedPromise);
+
+    // Since they are treated as a tuple,
+    // we need to guaranteed that the length of these arrays are same.
+    ASSERT(fulfillCallbacks->Length() == rejectCallbacks->Length() && rejectCallbacks->Length() == derivedPromises->Length());
+}
+
+class CallHandlerTask : public ScriptExecutionContext::Task {
 public:
-    PromiseTask(v8::Handle<v8::Function> callback, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> result, v8::Isolate* isolate)
-        : m_callback(isolate, callback)
-        , m_receiver(isolate, receiver)
-        , m_result(isolate, result)
+    CallHandlerTask(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> handler, v8::Handle<v8::Value> argument, v8::Isolate* isolate)
+        : m_promise(isolate, promise)
+        , m_handler(isolate, handler)
+        , m_argument(isolate, argument)
     {
-        ASSERT(!m_callback.isEmpty());
-        ASSERT(!m_receiver.isEmpty());
-        ASSERT(!m_result.isEmpty());
+        ASSERT(!m_promise.isEmpty());
+        ASSERT(!m_handler.isEmpty());
+        ASSERT(!m_argument.isEmpty());
     }
-    virtual ~PromiseTask() { }
+    virtual ~CallHandlerTask() { }
 
     virtual void performTask(ScriptExecutionContext*) OVERRIDE;
 
 private:
-    ScopedPersistent<v8::Function> m_callback;
-    ScopedPersistent<v8::Object> m_receiver;
-    ScopedPersistent<v8::Value> m_result;
+    ScopedPersistent<v8::Object> m_promise;
+    ScopedPersistent<v8::Function> m_handler;
+    ScopedPersistent<v8::Value> m_argument;
 };
 
-void PromiseTask::performTask(ScriptExecutionContext* context)
+void CallHandlerTask::performTask(ScriptExecutionContext* context)
 {
     ASSERT(context);
     if (context->activeDOMObjectsAreStopped())
         return;
 
     ScriptState* state = 0;
     if (context->isDocument()) {
         state = mainWorldScriptState(static_cast<Document*>(context)->frame());
     } else {
         ASSERT(context->isWorkerGlobalScope());
         state = scriptStateFromWorkerGlobalScope(toWorkerGlobalScope(context));
     }
     ASSERT(state);
 
     v8::Isolate* isolate = state->isolate();
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Context> v8Context = state->context();
     v8::Context::Scope scope(v8Context);
-    v8::Handle<v8::Value> args[] = { m_result.newLocal(isolate) };
-    V8ScriptRunner::callFunction(m_callback.newLocal(isolate), context, m_receiver.newLocal(isolate), WTF_ARRAY_LENGTH(args), args, isolate);
+    v8::Handle<v8::Value> args[] = { m_argument.newLocal(isolate) };
+    v8::TryCatch trycatch;
+    v8::Local<v8::Value> value = V8ScriptRunner::callFunction(m_handler.newLocal(isolate), context, v8::Undefined(isolate), WTF_ARRAY_LENGTH(args), args, isolate);
+    if (value.IsEmpty()) {
+        V8PromiseCustom::reject(m_promise.newLocal(isolate), trycatch.Exception(), isolate);
+    } else {
+        V8PromiseCustom::resolve(m_promise.newLocal(isolate), value, isolate);
+    }
+}
+
+class UpdateDerivedTask : public ScriptExecutionContext::Task {
+public:
+    UpdateDerivedTask(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originatorValueObject, v8::Isolate* isolate)
+        : m_promise(isolate, promise)
+        , m_onFulfilled(isolate, onFulfilled)
+        , m_onRejected(isolate, onRejected)
+        , m_originatorValueObject(isolate, originatorValueObject)
+    {
+        ASSERT(!m_promise.isEmpty());
+        ASSERT(!m_originatorValueObject.isEmpty());
+    }
+    virtual ~UpdateDerivedTask() { }
+
+    virtual void performTask(ScriptExecutionContext*) OVERRIDE;
+
+private:
+    ScopedPersistent<v8::Object> m_promise;
+    ScopedPersistent<v8::Function> m_onFulfilled;
+    ScopedPersistent<v8::Function> m_onRejected;
+    ScopedPersistent<v8::Object> m_originatorValueObject;
 };
 
-v8::Handle<v8::Value> postTask(v8::Handle<v8::Function> callback, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> value, v8::Isolate* isolate)
-{
-    ScriptExecutionContext* scriptExecutionContext = getScriptExecutionContext();
-    ASSERT(scriptExecutionContext && scriptExecutionContext->isContextThread());
-    scriptExecutionContext->postTask(adoptPtr(new PromiseTask(callback, receiver, value, isolate)));
-    return v8::Undefined(isolate);
-}
-
-void wrapperCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    v8::Isolate* isolate = args.GetIsolate();
-    ASSERT(!args.Data().IsEmpty());
-    v8::Local<v8::Object> environment = args.Data().As<v8::Object>();
-    v8::Local<v8::Value> result = v8::Undefined(isolate);
-    if (args.Length() > 0)
-        result = args[0];
-
-    v8::Local<v8::Object> promise = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseIndex).As<v8::Object>();
-    v8::Local<v8::Function> callback = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentCallbackIndex).As<v8::Function>();
-
-    v8::Local<v8::Value> argv[] = {
-        result,
-    };
+void UpdateDerivedTask::performTask(ScriptExecutionContext* context)
+{
+    ASSERT(context);
+    if (context->activeDOMObjectsAreStopped())
+        return;
+
+    ScriptState* state = 0;
+    if (context->isDocument()) {
+        state = mainWorldScriptState(static_cast<Document*>(context)->frame());
+    } else {
+        ASSERT(context->isWorkerGlobalScope());
+        state = scriptStateFromWorkerGlobalScope(toWorkerGlobalScope(context));
+    }
+    ASSERT(state);
+
+    v8::Isolate* isolate = state->isolate();
+    v8::HandleScope handleScope(isolate);
+    v8::Handle<v8::Context> v8Context = state->context();
+    v8::Context::Scope scope(v8Context);
+
+    v8::Local<v8::Object> originatorValueObject = m_originatorValueObject.newLocal(isolate);
+    v8::Local<v8::Value> coercedAlready = originatorValueObject->GetHiddenValue(V8HiddenPropertyName::thenableHiddenPromise(isolate));
+    if (!coercedAlready.IsEmpty() && coercedAlready->IsObject()) {
+        ASSERT(V8PromiseCustom::isPromise(coercedAlready.As<v8::Object>(), isolate));
+        V8PromiseCustom::updateDerivedFromPromise(m_promise.newLocal(isolate), m_onFulfilled.newLocal(isolate), m_onRejected.newLocal(isolate), coercedAlready.As<v8::Object>(), isolate);
+        return;
+    }
+
+    v8::Local<v8::Value> then;
     v8::TryCatch trycatch;
-    result = V8ScriptRunner::callFunction(callback, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv, isolate);
-    if (result.IsEmpty()) {
-        V8PromiseCustom::reject(promise, trycatch.Exception(), V8PromiseCustom::Synchronous, isolate);
-        return;
-    }
-    V8PromiseCustom::resolve(promise, result, V8PromiseCustom::Synchronous, isolate);
-}
-
-v8::Local<v8::Object> wrapperCallbackEnvironment(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> callback, v8::Isolate* isolate)
-{
-    v8::Local<v8::ObjectTemplate> objectTemplate = wrapperCallbackEnvironmentObjectTemplate(isolate);
-    v8::Local<v8::Object> environment = objectTemplate->NewInstance();
-    environment->SetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseIndex, promise);
-    environment->SetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentCallbackIndex, callback);
-    return environment;
-}
-
-void promiseFulfillCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    ASSERT(!args.Data().IsEmpty());
-    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
-    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
-    if (args.Length() > 0)
-        result = args[0];
-
-    V8PromiseCustom::fulfill(promise, result, V8PromiseCustom::Synchronous, args.GetIsolate());
-}
-
-void promiseResolveCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    ASSERT(!args.Data().IsEmpty());
-    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
-    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
-    if (args.Length() > 0)
-        result = args[0];
-
-    V8PromiseCustom::resolve(promise, result, V8PromiseCustom::Synchronous, args.GetIsolate());
-}
-
-void promiseRejectCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    ASSERT(!args.Data().IsEmpty());
-    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
-    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
-    if (args.Length() > 0)
-        result = args[0];
-
-    V8PromiseCustom::reject(promise, result, V8PromiseCustom::Synchronous, args.GetIsolate());
-}
-
-void callCallbacks(v8::Handle<v8::Array> callbacks, v8::Handle<v8::Value> result, V8PromiseCustom::SynchronousMode mode, v8::Isolate* isolate)
-{
-    v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
-    for (uint32_t i = 0, length = callbacks->Length(); i < length; ++i) {
-        v8::Local<v8::Value> value = callbacks->Get(i);
-        v8::Local<v8::Function> callback = value.As<v8::Function>();
-        V8PromiseCustom::call(callback, global, result, mode, isolate);
-    }
-}
-
-void promiseAllFulfillCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    v8::Isolate* isolate = args.GetIsolate();
-    ASSERT(!args.Data().IsEmpty());
-    v8::Local<v8::Object> environment = args.Data().As<v8::Object>();
-    v8::Local<v8::Value> result = v8::Undefined(isolate);
-    if (args.Length() > 0)
-        result = args[0];
-
-    v8::Local<v8::Object> promise = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentPromiseIndex).As<v8::Object>();
-    v8::Local<v8::Object> countdownWrapper = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentCountdownIndex).As<v8::Object>();
-    v8::Local<v8::Integer> index = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentIndexIndex).As<v8::Integer>();
-    v8::Local<v8::Array> results = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentResultsIndex).As<v8::Array>();
-
-    results->Set(index->Value(), result);
-
-    v8::Local<v8::Integer> countdown = countdownWrapper->GetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex).As<v8::Integer>();
-    ASSERT(countdown->Value() >= 1);
-    if (countdown->Value() == 1) {
-        V8PromiseCustom::resolve(promise, results, V8PromiseCustom::Synchronous, isolate);
-        return;
-    }
-    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1, isolate));
-}
-
-v8::Local<v8::Object> promiseAllEnvironment(v8::Handle<v8::Object> promise, v8::Handle<v8::Object> countdownWrapper, int index, v8::Handle<v8::Array> results, v8::Isolate* isolate)
-{
-    v8::Local<v8::ObjectTemplate> objectTemplate = promiseAllEnvironmentObjectTemplate(isolate);
-    v8::Local<v8::Object> environment = objectTemplate->NewInstance();
-
-    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentPromiseIndex, promise);
-    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentCountdownIndex, countdownWrapper);
-    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentIndexIndex, v8::Integer::New(index, isolate));
-    environment->SetInternalField(V8PromiseCustom::PromiseAllEnvironmentResultsIndex, results);
-    return environment;
-}
-
-void promiseResolve(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
-    ASSERT(!promise.IsEmpty());
-    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
-    if (V8PromiseCustom::getState(internal) != V8PromiseCustom::Pending)
-        return;
-    v8::Isolate* isolate = args.GetIsolate();
-    V8PromiseCustom::setState(V8PromiseCustom::getInternal(promise), V8PromiseCustom::Following, isolate);
-
-    v8::Local<v8::Value> result = v8::Undefined(isolate);
-    if (args.Length() > 0)
-        result = args[0];
-    V8PromiseCustom::resolve(promise, result, V8PromiseCustom::Asynchronous, isolate);
-}
-
-void promiseReject(const v8::FunctionCallbackInfo<v8::Value>& args)
-{
-    v8::Local<v8::Object> promise = args.Data().As<v8::Object>();
-    ASSERT(!promise.IsEmpty());
-    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
-    if (V8PromiseCustom::getState(internal) != V8PromiseCustom::Pending)
-        return;
-    v8::Isolate* isolate = args.GetIsolate();
-    V8PromiseCustom::setState(V8PromiseCustom::getInternal(promise), V8PromiseCustom::Following, isolate);
-
-    v8::Local<v8::Value> result = v8::Undefined(isolate);
-    if (args.Length() > 0)
-        result = args[0];
-    V8PromiseCustom::reject(promise, result, V8PromiseCustom::Asynchronous, isolate);
+    then = originatorValueObject->Get(v8::String::NewSymbol("then"));
+    if (then.IsEmpty()) {
+        // If calling the [[Get]] internal method threw an exception, catch it and run updateDerivedFromReason.
+        V8PromiseCustom::updateDerivedFromReason(m_promise.newLocal(isolate), m_onRejected.newLocal(isolate), trycatch.Exception(), isolate);
+        return;
+    }
+
+    if (then->IsFunction()) {
+        ASSERT(then->IsObject());
+        v8::Local<v8::Object> coerced = V8PromiseCustom::coerceThenable(originatorValueObject, then.As<v8::Function>(), isolate);
+        V8PromiseCustom::updateDerivedFromPromise(m_promise.newLocal(isolate), m_onFulfilled.newLocal(isolate), m_onRejected.newLocal(isolate), coerced, isolate);
+        return;
+    }
+
+    V8PromiseCustom::updateDerivedFromValue(m_promise.newLocal(isolate), m_onFulfilled.newLocal(isolate), originatorValueObject, isolate);
+}
+
+class Derived {
+    WTF_MAKE_NONCOPYABLE(Derived);
+public:
+    Derived(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originator, v8::Isolate* isolate)
+        : m_promise(isolate, promise)
+        , m_onFulfilled(isolate, onFulfilled)
+        , m_onRejected(isolate, onRejected)
+        , m_originator(isolate, originator)
+    {
+        ASSERT(!m_promise.isEmpty());
+        ASSERT(!m_originator.isEmpty());
+    }
+
+    static PassOwnPtr<Derived> create(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originator, v8::Isolate* isolate)
+    {
+        return adoptPtr(new Derived(promise, onFulfilled, onRejected, originator, isolate));
+    }
+
+    v8::Local<v8::Object> promise(v8::Isolate* isolate) const { return m_promise.newLocal(isolate); }
+    v8::Local<v8::Function> onFulfilled(v8::Isolate* isolate) const { return m_onFulfilled.newLocal(isolate); }
+    v8::Local<v8::Function> onRejected(v8::Isolate* isolate) const { return m_onRejected.newLocal(isolate); }
+    v8::Local<v8::Object> originator(v8::Isolate* isolate) const { return m_originator.newLocal(isolate); }
+
+private:
+    ScopedPersistent<v8::Object> m_promise;
+    ScopedPersistent<v8::Function> m_onFulfilled;
+    ScopedPersistent<v8::Function> m_onRejected;
+    ScopedPersistent<v8::Object> m_originator;

[abarth-chromium, 2013/10/03 18:49:54]

We could probably just use local handles here because this object appears to be
held only by the PromisePropagator, which is held on the stack.

The risk in using ScopedPersistent here is that we could create a memory leak if
we retain this object in the heap (since it strongly retains these objects).  On
the other hand, if we use Local handles, we'll get memory corruption from that!

It's probably ok to use ScopedPersistent here, but it would be ideal to add an
ASSERT that would trigger if we retain this object in the heap.  I'm not
entirely sure how to write that assert, but maybe you have an idea.

[yusukesuzuki, 2013/10/03 20:19:07]

Since users can create a lot of Derived tuples by using recursive propagation
routines calls and handle stack may be grown infinitely, we inserted
v8::HandleScope to performPropagation loop and made Derived's members
ScopedPersistent.
If it isn't problem, we can replace them with v8::Local and remove
v8::HandleScope in performPropagation loop. In this case, memory corruption
doesn't happen. Is it preferable?
I cannot come up with any nice idea about checking by ASSERT.

But since only PromisePropagator holds Derived tuples ownership, we can change
Derived to PromisePropagator inner class to hide Derived from other classes.

And by checking the use cases that PromisePropagator is held only on the stack,
I think that we can ensure that Derived isn't retained in the heap. Since
PromisePropagator is defined in the cpp file, it is only used in this file. So
we can check it easily.

I've changed Derived to PromisePropagator inner class and added
"PromisePropagator should be held on the stack" comment.

+};
+
+// Since Promises state propagation routines are executed recursively, they cause
+// stack overflow.
+// (e.g. UpdateDerived -> UpdateDerivedFromValue -> SetValue ->
+//  PropagateToDerived -> UpdateDerived)
+//
+// To fix that, we introduce PromisePropagator. It holds the stack. When
+// propagating the result to the derived tuples, we append the derived tuples
+// to the stack. After that, we drain the stack to propagate the result to
+// the stored tuples.
+class PromisePropagator {
+    WTF_MAKE_NONCOPYABLE(PromisePropagator);
+public:
+    PromisePropagator() { }
+
+    void performPropagation(v8::Isolate*);
+
+    void setValue(v8::Handle<v8::Object> promise, v8::Handle<v8::Value>, v8::Isolate*);
+    void setReason(v8::Handle<v8::Object> promise, v8::Handle<v8::Value>, v8::Isolate*);
+    void propagateToDerived(v8::Handle<v8::Object> promise, v8::Isolate*);
+    void updateDerived(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originator, v8::Isolate*);
+    void updateDerivedFromValue(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Value>, v8::Isolate*);
+    void updateDerivedFromReason(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Value>, v8::Isolate*);
+    void updateDerivedFromPromise(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> promise, v8::Isolate*);
+
+private:
+    Vector<OwnPtr<Derived> > m_derivedStack;
+};
+
+void PromisePropagator::performPropagation(v8::Isolate* isolate)
+{
+    while (!m_derivedStack.isEmpty()) {
+        v8::HandleScope handleScope(isolate);
+        OwnPtr<Derived> derived = m_derivedStack.last().release();
+        m_derivedStack.removeLast();

[abarth-chromium, 2013/10/03 18:49:54]

Consider using a Deque instead of a Vector.  Then you can call takeFirst() to
combine these operations (or add a takeLast if you need the last one).

[yusukesuzuki, 2013/10/03 20:19:07]

Sounds nice! I've added takeLast/removeLast to Deque and used it here.

+        updateDerived(derived->promise(isolate), derived->onFulfilled(isolate), derived->onRejected(isolate), derived->originator(isolate), isolate);
+    }
+}
+
+void PromisePropagator::setValue(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> value, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
+    ASSERT(V8PromiseCustom::getState(internal) != V8PromiseCustom::Fulfilled && V8PromiseCustom::getState(internal) != V8PromiseCustom::Rejected);
+    V8PromiseCustom::setState(internal, V8PromiseCustom::Fulfilled, value, isolate);
+    propagateToDerived(promise, isolate);
+}
+
+void PromisePropagator::setReason(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
+    ASSERT(V8PromiseCustom::getState(internal) != V8PromiseCustom::Fulfilled && V8PromiseCustom::getState(internal) != V8PromiseCustom::Rejected);
+    V8PromiseCustom::setState(internal, V8PromiseCustom::Rejected, reason, isolate);
+    propagateToDerived(promise, isolate);
+}
+
+void PromisePropagator::propagateToDerived(v8::Handle<v8::Object> promise, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
+    ASSERT(V8PromiseCustom::getState(internal) == V8PromiseCustom::Fulfilled || V8PromiseCustom::getState(internal) == V8PromiseCustom::Rejected);
+    v8::Local<v8::Array> fulfillCallbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
+    v8::Local<v8::Array> rejectCallbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
+    v8::Local<v8::Array> derivedPromises = internal->GetInternalField(V8PromiseCustom::InternalDerivedPromiseIndex).As<v8::Array>();
+    // Since they are treated as a tuple,
+    // we need to guaranteed that the length of these arrays are same.
+    ASSERT(fulfillCallbacks->Length() == rejectCallbacks->Length() && rejectCallbacks->Length() == derivedPromises->Length());
+
+    // Append Derived tuple to the stack in reverse order.
+    for (uint32_t count = 0, length = derivedPromises->Length(); count < length; ++count) {
+        uint32_t i = length - count - 1;
+        v8::Local<v8::Object> derivedPromise = derivedPromises->Get(i).As<v8::Object>();
+
+        v8::Local<v8::Function> onFulfilled, onRejected;
+        v8::Local<v8::Value> onFulfilledValue = fulfillCallbacks->Get(i);
+        if (onFulfilledValue->IsFunction()) {
+            onFulfilled = onFulfilledValue.As<v8::Function>();
+        }
+        v8::Local<v8::Value> onRejectedValue = rejectCallbacks->Get(i);
+        if (onRejectedValue->IsFunction()) {
+            onRejected = onRejectedValue.As<v8::Function>();
+        }
+
+        m_derivedStack.append(Derived::create(derivedPromise, onFulfilled, onRejected, promise, isolate));
+    }
+    clearDerived(internal);
+}
+
+void PromisePropagator::updateDerivedFromValue(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Value> value, v8::Isolate* isolate)
+{
+    if (!onFulfilled.IsEmpty()) {
+        V8PromiseCustom::callHandler(derivedPromise, onFulfilled, value, isolate);
+    } else {
+        setValue(derivedPromise, value, isolate);
+    }
+}
+
+void PromisePropagator::updateDerivedFromReason(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
+{
+    if (!onRejected.IsEmpty()) {
+        V8PromiseCustom::callHandler(derivedPromise, onRejected, reason, isolate);
+    } else {
+        setReason(derivedPromise, reason, isolate);
+    }
+}
+
+void PromisePropagator::updateDerived(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originator, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> originatorInternal = V8PromiseCustom::getInternal(originator);
+    V8PromiseCustom::PromiseState originatorState = V8PromiseCustom::getState(originatorInternal);
+    ASSERT(originatorState == V8PromiseCustom::Fulfilled || originatorState == V8PromiseCustom::Rejected);
+    v8::Local<v8::Value> originatorValue = originatorInternal->GetInternalField(V8PromiseCustom::InternalResultIndex);
+    if (originatorState == V8PromiseCustom::Fulfilled) {
+        if (originatorValue->IsObject()) {
+            ScriptExecutionContext* scriptExecutionContext = getScriptExecutionContext();
+            ASSERT(scriptExecutionContext && scriptExecutionContext->isContextThread());
+            scriptExecutionContext->postTask(adoptPtr(new UpdateDerivedTask(derivedPromise, onFulfilled, onRejected, originatorValue.As<v8::Object>(), isolate)));
+        } else {
+            updateDerivedFromValue(derivedPromise, onFulfilled, originatorValue, isolate);
+        }
+    } else {
+        updateDerivedFromReason(derivedPromise, onRejected, originatorValue, isolate);
+    }
+}
+
+void PromisePropagator::updateDerivedFromPromise(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> promise, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
+    V8PromiseCustom::PromiseState state = V8PromiseCustom::getState(internal);
+    if (state == V8PromiseCustom::Fulfilled || state == V8PromiseCustom::Rejected) {
+        updateDerived(derivedPromise, onFulfilled, onRejected, promise, isolate);
+    } else {
+        addToDerived(internal, derivedPromise, onFulfilled, onRejected, isolate);
+    }
 }
 
 } // namespace
 
 void V8Promise::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8SetReturnValue(args, v8::Local<v8::Value>());
     v8::Isolate* isolate = args.GetIsolate();
     if (!args.Length() || !args[0]->IsFunction()) {
         throwTypeError("Promise constructor takes a function argument", isolate);
         return;
     }
     v8::Local<v8::Function> init = args[0].As<v8::Function>();
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
     v8::Handle<v8::Value> argv[] = {
-        createClosure(promiseResolve, promise, isolate),
-        createClosure(promiseReject, promise, isolate)
+        createClosure(promiseResolveCallback, promise, isolate),
+        createClosure(promiseRejectCallback, promise, isolate)
     };
     v8::TryCatch trycatch;
-    if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty()) {
+    if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), v8::Undefined(isolate), WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty()) {
         // An exception is thrown. Reject the promise if its resolved flag is unset.
-        if (V8PromiseCustom::getState(V8PromiseCustom::getInternal(promise)) == V8PromiseCustom::Pending)
-            V8PromiseCustom::reject(promise, trycatch.Exception(), V8PromiseCustom::Asynchronous, isolate);
+        V8PromiseCustom::reject(promise, trycatch.Exception(), isolate);
     }
     v8SetReturnValue(args, promise);
     return;
 }
 
 void V8Promise::thenMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
-    v8::Local<v8::Function> fulfillWrapper, rejectWrapper;
+    v8::Local<v8::Function> onFulfilled, onRejected;
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
     if (args.Length() > 0 && !args[0]->IsUndefined()) {
         if (!args[0]->IsFunction()) {
-            v8SetReturnValue(args, throwTypeError("fulfillCallback must be a function or undefined", isolate));
+            v8SetReturnValue(args, throwTypeError("onFulfilled must be a function or undefined", isolate));
             return;
         }
-        fulfillWrapper = createClosure(wrapperCallback, wrapperCallbackEnvironment(promise, args[0].As<v8::Function>(), isolate), isolate);
-    } else {
-        fulfillWrapper = createClosure(promiseFulfillCallback, promise, isolate);
+        onFulfilled = args[0].As<v8::Function>();
     }
     if (args.Length() > 1 && !args[1]->IsUndefined()) {
         if (!args[1]->IsFunction()) {
-            v8SetReturnValue(args, throwTypeError("rejectCallback must be a function or undefined", isolate));
+            v8SetReturnValue(args, throwTypeError("onRejected must be a function or undefined", isolate));
             return;
         }
-        rejectWrapper = createClosure(wrapperCallback, wrapperCallbackEnvironment(promise, args[1].As<v8::Function>(), isolate), isolate);
-    } else {
-        rejectWrapper = createClosure(promiseRejectCallback, promise, isolate);
+        onRejected = args[1].As<v8::Function>();
     }
-    V8PromiseCustom::append(args.Holder(), fulfillWrapper, rejectWrapper, isolate);
-    v8SetReturnValue(args, promise);
+    v8SetReturnValue(args, V8PromiseCustom::then(args.Holder(), onFulfilled, onRejected, isolate));
 }
 
 void V8Promise::castMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (args.Length() > 0)
         result = args[0];
 
     v8SetReturnValue(args, V8PromiseCustom::toPromise(result, isolate));
 }
 
 void V8Promise::catchMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
-    v8::Local<v8::Function> fulfillWrapper, rejectWrapper;
-    v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
+    v8::Local<v8::Function> onFulfilled, onRejected;
 
     if (args.Length() > 0 && !args[0]->IsUndefined()) {
         if (!args[0]->IsFunction()) {
-            v8SetReturnValue(args, throwTypeError("rejectCallback must be a function or undefined", isolate));
+            v8SetReturnValue(args, throwTypeError("onRejected must be a function or undefined", isolate));
             return;
         }
-        rejectWrapper = createClosure(wrapperCallback, wrapperCallbackEnvironment(promise, args[0].As<v8::Function>(), isolate), isolate);
-    } else {
-        rejectWrapper = createClosure(promiseRejectCallback, promise, isolate);
+        onRejected = args[0].As<v8::Function>();
     }
-    fulfillWrapper = createClosure(promiseFulfillCallback, promise, isolate);
-    V8PromiseCustom::append(args.Holder(), fulfillWrapper, rejectWrapper, isolate);
-    v8SetReturnValue(args, promise);
+    v8SetReturnValue(args, V8PromiseCustom::then(args.Holder(), onFulfilled, onRejected, isolate));
 }
 
 void V8Promise::resolveMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (args.Length() > 0)
         result = args[0];
 
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
-    V8PromiseCustom::resolve(promise, result, V8PromiseCustom::Asynchronous, isolate);
+    V8PromiseCustom::resolve(promise, result, isolate);
     v8SetReturnValue(args, promise);
 }
 
 void V8Promise::rejectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (args.Length() > 0)
         result = args[0];
 
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
-    V8PromiseCustom::reject(promise, result, V8PromiseCustom::Asynchronous, isolate);
+    V8PromiseCustom::reject(promise, result, isolate);
     v8SetReturnValue(args, promise);
 }
 
 void V8Promise::raceMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
 
     if (!args.Length() || !args[0]->IsArray()) {
         v8SetReturnValue(args, promise);
         return;
     }
 
     // FIXME: Now we limit the iterable type to the Array type.
     v8::Local<v8::Array> iterable = args[0].As<v8::Array>();
-    v8::Local<v8::Function> fulfillCallback = createClosure(promiseResolveCallback, promise, isolate);
-    v8::Local<v8::Function> rejectCallback = createClosure(promiseRejectCallback, promise, isolate);
+    v8::Local<v8::Function> onFulfilled = createClosure(promiseResolveCallback, promise, isolate);
+    v8::Local<v8::Function> onRejected = createClosure(promiseRejectCallback, promise, isolate);
 
     for (unsigned i = 0, length = iterable->Length(); i < length; ++i) {
         // Array-holes should not be skipped by for-of iteration semantics.
         V8TRYCATCH_VOID(v8::Local<v8::Value>, nextValue, iterable->Get(i));
         v8::Local<v8::Object> nextPromise = V8PromiseCustom::toPromise(nextValue, isolate);
-        V8PromiseCustom::append(nextPromise, fulfillCallback, rejectCallback, isolate);
+        V8PromiseCustom::then(nextPromise, onFulfilled, onRejected, isolate);
     }
     v8SetReturnValue(args, promise);
 }
 
 void V8Promise::allMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Object> promise = V8PromiseCustom::createPromise(args.Holder(), isolate);
     v8::Local<v8::Array> results = v8::Array::New();
 
     if (!args.Length() || !args[0]->IsArray()) {
-        V8PromiseCustom::resolve(promise, results, V8PromiseCustom::Asynchronous, isolate);
+        V8PromiseCustom::resolve(promise, results, isolate);
         v8SetReturnValue(args, promise);
         return;
     }
 
     // FIXME: Now we limit the iterable type to the Array type.
     v8::Local<v8::Array> iterable = args[0].As<v8::Array>();
 
     if (!iterable->Length()) {
-        V8PromiseCustom::resolve(promise, results, V8PromiseCustom::Asynchronous, isolate);
+        V8PromiseCustom::resolve(promise, results, isolate);
         v8SetReturnValue(args, promise);
         return;
     }
 
     v8::Local<v8::ObjectTemplate> objectTemplate = primitiveWrapperObjectTemplate(isolate);
     v8::Local<v8::Object> countdownWrapper = objectTemplate->NewInstance();
     countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(iterable->Length(), isolate));
 
-    v8::Local<v8::Function> rejectCallback = createClosure(promiseRejectCallback, promise, isolate);
+    v8::Local<v8::Function> onRejected = createClosure(promiseRejectCallback, promise, isolate);
     for (unsigned i = 0, length = iterable->Length(); i < length; ++i) {
         // Array-holes should not be skipped by for-of iteration semantics.
         v8::Local<v8::Object> environment = promiseAllEnvironment(promise, countdownWrapper, i, results, isolate);
-        v8::Local<v8::Function> fulfillCallback = createClosure(promiseAllFulfillCallback, environment, isolate);
+        v8::Local<v8::Function> onFulfilled = createClosure(promiseAllFulfillCallback, environment, isolate);
         V8TRYCATCH_VOID(v8::Local<v8::Value>, nextValue, iterable->Get(i));
         v8::Local<v8::Object> nextPromise = V8PromiseCustom::toPromise(nextValue, isolate);
-        V8PromiseCustom::append(nextPromise, fulfillCallback, rejectCallback, isolate);
+        V8PromiseCustom::then(nextPromise, onFulfilled, onRejected, isolate);
     }
     v8SetReturnValue(args, promise);
 }
 
 //
 // -- V8PromiseCustom --
 v8::Local<v8::Object> V8PromiseCustom::createPromise(v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> internalTemplate = internalObjectTemplate(isolate);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
     v8::Local<v8::Object> promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::info, 0, isolate);
 
-    clearInternal(internal, V8PromiseCustom::Pending, v8::Undefined(isolate), isolate);
+    clearDerived(internal);
+    setState(internal, Pending, v8::Undefined(isolate), isolate);
 
     promise->SetInternalField(v8DOMWrapperObjectIndex, internal);
     return promise;
 }
 
-void V8PromiseCustom::fulfill(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
-{
-    v8::Local<v8::Object> internal = getInternal(promise);
-    PromiseState state = getState(internal);
-    if (state == Fulfilled || state == Rejected)
-        return;
-
-    ASSERT(state == Pending || state == Following);
-    v8::Local<v8::Array> callbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
-    clearInternal(internal, Fulfilled, result, isolate);
-
-    callCallbacks(callbacks, result, mode, isolate);
-}
-
-void V8PromiseCustom::resolve(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
-{
-    ASSERT(!result.IsEmpty());
-
-    v8::Local<v8::Value> then;
-    if (result->IsObject()) {
-        v8::TryCatch trycatch;
-        then = result.As<v8::Object>()->Get(v8::String::NewSymbol("then"));
-        if (then.IsEmpty()) {
-            // If calling the [[Get]] internal method threw an exception, catch it and run reject.
-            reject(promise, trycatch.Exception(), mode, isolate);
-            return;
-        }
-    }
-
-    if (!then.IsEmpty() && then->IsFunction()) {
-        ASSERT(result->IsObject());
-        v8::TryCatch trycatch;
-        v8::Handle<v8::Value> argv[] = {
-            createClosure(promiseResolveCallback, promise, isolate),
-            createClosure(promiseRejectCallback, promise, isolate),
-        };
-        if (V8ScriptRunner::callFunction(then.As<v8::Function>(), getScriptExecutionContext(), result.As<v8::Object>(), WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty())
-            reject(promise, trycatch.Exception(), mode, isolate);
-        return;
-    }
-
-    fulfill(promise, result, mode, isolate);
-}
-
-void V8PromiseCustom::reject(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
-{
-    v8::Local<v8::Object> internal = getInternal(promise);
-    PromiseState state = getState(internal);
-    if (state == Fulfilled || state == Rejected)
-        return;
-
-    ASSERT(state == Pending || state == Following);
-    v8::Local<v8::Array> callbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
-    clearInternal(internal, Rejected, result, isolate);
-
-    callCallbacks(callbacks, result, mode, isolate);
-}
-
-void V8PromiseCustom::append(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> fulfillCallback, v8::Handle<v8::Function> rejectCallback, v8::Isolate* isolate)
-{
-    // fulfillCallback and rejectCallback can be empty.
-    v8::Local<v8::Object> internal = getInternal(promise);
-
-    PromiseState state = getState(internal);
-    if (state == Fulfilled) {
-        if (!fulfillCallback.IsEmpty()) {
-            v8::Local<v8::Value> result = internal->GetInternalField(V8PromiseCustom::InternalResultIndex);
-            v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
-            call(fulfillCallback, global, result, Asynchronous, isolate);
-        }
-        return;
-    }
-    if (state == Rejected) {
-        if (!rejectCallback.IsEmpty()) {
-            v8::Local<v8::Value> result = internal->GetInternalField(V8PromiseCustom::InternalResultIndex);
-            v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
-            call(rejectCallback, global, result, Asynchronous, isolate);
-        }
-        return;
-    }
-
-    ASSERT(state == Pending || state == Following);
-    if (!fulfillCallback.IsEmpty()) {
-        v8::Local<v8::Array> callbacks = internal->GetInternalField(InternalFulfillCallbackIndex).As<v8::Array>();
-        callbacks->Set(callbacks->Length(), fulfillCallback);
-    }
-    if (!rejectCallback.IsEmpty()) {
-        v8::Local<v8::Array> callbacks = internal->GetInternalField(InternalRejectCallbackIndex).As<v8::Array>();
-        callbacks->Set(callbacks->Length(), rejectCallback);
-    }
-}
-
 v8::Local<v8::Object> V8PromiseCustom::getInternal(v8::Handle<v8::Object> promise)
 {
     v8::Local<v8::Value> value = promise->GetInternalField(v8DOMWrapperObjectIndex);
     return value.As<v8::Object>();
 }
 
-void V8PromiseCustom::clearInternal(v8::Handle<v8::Object> internal, PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
-{
-    setState(internal, state, isolate);
-    internal->SetInternalField(V8PromiseCustom::InternalResultIndex, value);
-    internal->SetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex, v8::Array::New());
-    internal->SetInternalField(V8PromiseCustom::InternalRejectCallbackIndex, v8::Array::New());
-}
-
 V8PromiseCustom::PromiseState V8PromiseCustom::getState(v8::Handle<v8::Object> internal)
 {
     v8::Handle<v8::Value> value = internal->GetInternalField(V8PromiseCustom::InternalStateIndex);
     bool ok = false;
     uint32_t number = toInt32(value, ok);
     ASSERT(ok && (number == Pending || number == Fulfilled || number == Rejected || number == Following));
     return static_cast<PromiseState>(number);
 }
 
-void V8PromiseCustom::setState(v8::Handle<v8::Object> internal, PromiseState state, v8::Isolate* isolate)
+void V8PromiseCustom::setState(v8::Handle<v8::Object> internal, PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
+    ASSERT(!value.IsEmpty());
     ASSERT(state == Pending || state == Fulfilled || state == Rejected || state == Following);
-    internal->SetInternalField(V8PromiseCustom::InternalStateIndex, v8::Integer::New(state, isolate));
-}
-
-void V8PromiseCustom::call(v8::Handle<v8::Function> function, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
-{
-    if (mode == Synchronous) {
-        v8::Context::Scope scope(isolate->GetCurrentContext());
-        // If an exception is thrown, catch it and do nothing.
-        v8::TryCatch trycatch;
-        v8::Handle<v8::Value> args[] = { result };
-        V8ScriptRunner::callFunction(function, getScriptExecutionContext(), receiver, WTF_ARRAY_LENGTH(args), args, isolate);
-    } else {
-        ASSERT(mode == Asynchronous);
-        postTask(function, receiver, result, isolate);
-    }
+    internal->SetInternalField(InternalStateIndex, v8::Integer::New(state, isolate));
+    internal->SetInternalField(InternalResultIndex, value);
 }
 
 bool V8PromiseCustom::isPromise(v8::Handle<v8::Value> maybePromise, v8::Isolate* isolate)
 {
     WrapperWorldType currentWorldType = worldType(isolate);
     return V8Promise::GetTemplate(isolate, currentWorldType)->HasInstance(maybePromise);
 }
 
 v8::Local<v8::Object> V8PromiseCustom::toPromise(v8::Handle<v8::Value> maybePromise, v8::Isolate* isolate)
 {
     // FIXME: Currently we dones't check [[PromiseConstructor]] since we limits
     // the creation of the promise objects only from the Blink Promise
     // constructor.
     if (isPromise(maybePromise, isolate))
         return maybePromise.As<v8::Object>();
 
     v8::Local<v8::Object> promise = createPromise(v8::Handle<v8::Object>(), isolate);
-    resolve(promise, maybePromise, Asynchronous, isolate);
+    resolve(promise, maybePromise, isolate);
     return promise;
 }
 
+void V8PromiseCustom::resolve(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> result, v8::Isolate* isolate)
+{
+    ASSERT(!result.IsEmpty());
+    v8::Local<v8::Object> internal = getInternal(promise);
+    PromiseState state = getState(internal);
+    if (state != Pending)
+        return;
+
+    if (isPromise(result, isolate)) {
+        v8::Local<v8::Object> valuePromise = result.As<v8::Object>();
+        v8::Local<v8::Object> valueInternal = getInternal(valuePromise);
+        PromiseState valueState = getState(valueInternal);
+        if (promise->SameValue(valuePromise)) {
+            v8::Local<v8::Value> reason = V8ThrowException::createTypeError("Resolve a promise with itself", isolate);
+            setReason(promise, reason, isolate);
+        } else if (valueState == Following) {
+            v8::Local<v8::Object> valuePromiseFollowing = valueInternal->GetInternalField(InternalResultIndex).As<v8::Object>();
+            setState(internal, Following, valuePromiseFollowing, isolate);
+            addToDerived(getInternal(valuePromiseFollowing), promise, v8::Handle<v8::Function>(), v8::Handle<v8::Function>(), isolate);
+        } else if (valueState == Fulfilled) {
+            setValue(promise, valueInternal->GetInternalField(InternalResultIndex), isolate);
+        } else if (valueState == Rejected) {
+            setReason(promise, valueInternal->GetInternalField(InternalResultIndex), isolate);
+        } else {
+            ASSERT(valueState == Pending);
+            setState(internal, Following, valuePromise, isolate);
+            addToDerived(valueInternal, promise, v8::Handle<v8::Function>(), v8::Handle<v8::Function>(), isolate);
+        }
+    } else {
+        setValue(promise, result, isolate);
+    }
+}
+
+void V8PromiseCustom::reject(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
+{
+    v8::Local<v8::Object> internal = getInternal(promise);
+    PromiseState state = getState(internal);
+    if (state != Pending)
+        return;
+    setReason(promise, reason, isolate);
+}
+
+v8::Local<v8::Object> V8PromiseCustom::then(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Isolate* isolate)
+{
+    v8::Handle<v8::Object> internal = getInternal(promise);
+    while (getState(internal) == Following) {
+        promise = internal->GetInternalField(InternalResultIndex).As<v8::Object>();
+        internal = getInternal(promise);
+    }
+    // FIXME: Currently we dones't lookup "constructor" property since we limits

[abarth-chromium, 2013/10/03 18:49:54]

dones't -> don't

limits -> limit

[yusukesuzuki, 2013/10/03 20:19:07]

Done.

+    // the creation of the promise objects only from the Blink Promise
+    // constructor.
+    v8::Local<v8::Object> derivedPromise = createPromise(v8::Handle<v8::Object>(), isolate);
+    updateDerivedFromPromise(derivedPromise, onFulfilled, onRejected, promise, isolate);
+    return derivedPromise;
+}
+
+void V8PromiseCustom::setValue(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> value, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.setValue(promise, value, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::setReason(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.setReason(promise, reason, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::propagateToDerived(v8::Handle<v8::Object> promise, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.propagateToDerived(promise, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::updateDerived(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originator, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.updateDerived(derivedPromise, onFulfilled, onRejected, originator, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::updateDerivedFromValue(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Value> value, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.updateDerivedFromValue(derivedPromise, onFulfilled, value, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::updateDerivedFromReason(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.updateDerivedFromReason(derivedPromise, onRejected, reason, isolate);
+    propagator.performPropagation(isolate);
+}
+
+void V8PromiseCustom::updateDerivedFromPromise(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> promise, v8::Isolate* isolate)
+{
+    PromisePropagator propagator;
+    propagator.updateDerivedFromPromise(derivedPromise, onFulfilled, onRejected, promise, isolate);
+    propagator.performPropagation(isolate);
+}
+
+v8::Local<v8::Object> V8PromiseCustom::coerceThenable(v8::Handle<v8::Object> thenable, v8::Handle<v8::Function> then, v8::Isolate* isolate)
+{
+    ASSERT(!thenable.IsEmpty());
+    ASSERT(!then.IsEmpty());
+    v8::Local<v8::Object> promise = createPromise(v8::Handle<v8::Object>(), isolate);
+    v8::Handle<v8::Value> argv[] = {
+        createClosure(promiseResolveCallback, promise, isolate),
+        createClosure(promiseRejectCallback, promise, isolate)
+    };
+    v8::TryCatch trycatch;
+    if (V8ScriptRunner::callFunction(then, getScriptExecutionContext(), thenable, WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty()) {
+        reject(promise, trycatch.Exception(), isolate);
+    }
+    thenable->SetHiddenValue(V8HiddenPropertyName::thenableHiddenPromise(isolate), promise);
+    return promise;
+}
+
+void V8PromiseCustom::callHandler(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> handler, v8::Handle<v8::Value> argument, v8::Isolate* isolate)
+{
+    ScriptExecutionContext* scriptExecutionContext = getScriptExecutionContext();
+    ASSERT(scriptExecutionContext && scriptExecutionContext->isContextThread());
+    scriptExecutionContext->postTask(adoptPtr(new CallHandlerTask(promise, handler, argument, isolate)));
+}
+
 } // namespace WebCore