Promise init callback takes resolve and reject functions

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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "bindings/v8/custom/V8PromiseCustom.h"
 
 #include "V8Promise.h"
-#include "V8PromiseResolver.h"
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptFunctionCall.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.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"
@@ skipping 42 matching lines @@
     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);
 }
 
+v8::Local<v8::ObjectTemplate> resolverObjectTemplate(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::ResolverFieldCount, isolate);
+}
+
 class PromiseTask : 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)
     {
         ASSERT(!m_callback.isEmpty());
         ASSERT(!m_receiver.isEmpty());
         ASSERT(!m_result.isEmpty());
@@ skipping 172 matching lines @@
     v8::Local<v8::ObjectTemplate> objectTemplate = promiseEveryEnvironmentObjectTemplate(isolate);
     v8::Local<v8::Object> environment = objectTemplate->NewInstance();
 
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentPromiseResolverIndex, resolver);
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentCountdownIndex, countdownWrapper);
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentIndexIndex, v8::Integer::New(index, isolate));
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentResultsIndex, results);
     return environment;
 }
 
+void promiseResolve(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Local<v8::Object> resolver = args.Data().As<v8::Object>();
+    ASSERT(!resolver.IsEmpty());
+    if (V8PromiseCustom::isInternalDetached(resolver))
+        return;
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(resolver);
+    if (V8PromiseCustom::getState(internal) != V8PromiseCustom::Pending)
+        return;
+    v8::Isolate* isolate = args.GetIsolate();
+    V8PromiseCustom::setState(internal, V8PromiseCustom::PendingWithResolvedFlagSet, isolate);
+
+    v8::Local<v8::Value> result = v8::Undefined(isolate);
+    if (args.Length() > 0)
+        result = args[0];
+    V8PromiseCustom::resolveResolver(resolver, result, V8PromiseCustom::Asynchronous, isolate);
+}
+
+void promiseReject(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Local<v8::Object> resolver = args.Data().As<v8::Object>();
+    ASSERT(!resolver.IsEmpty());
+    if (V8PromiseCustom::isInternalDetached(resolver))
+        return;
+    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(resolver);
+    if (V8PromiseCustom::getState(internal) != V8PromiseCustom::Pending)
+        return;
+    v8::Isolate* isolate = args.GetIsolate();
+    V8PromiseCustom::setState(internal, V8PromiseCustom::PendingWithResolvedFlagSet, isolate);
+
+    v8::Local<v8::Value> result = v8::Undefined(isolate);
+    if (args.Length() > 0)
+        result = args[0];
+    V8PromiseCustom::rejectResolver(resolver, result, V8PromiseCustom::Asynchronous, 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, resolver;
     V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
     v8::Handle<v8::Value> argv[] = {
-        resolver,
+        createClosure(promiseResolve, resolver),
+        createClosure(promiseReject, resolver)
     };
     v8::TryCatch trycatch;
     if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty()) {
         // An exception is thrown. Reject the promise if its resolved flag is unset.
         if (!V8PromiseCustom::isInternalDetached(resolver) && V8PromiseCustom::getState(V8PromiseCustom::getInternal(resolver)) == V8PromiseCustom::Pending)
             V8PromiseCustom::rejectResolver(resolver, trycatch.Exception(), V8PromiseCustom::Asynchronous, isolate);
     }
     v8SetReturnValue(args, promise);
     return;
 }
@@ skipping 167 matching lines @@
         V8PromiseCustom::append(eachPromise, fulfillCallback, rejectCallback, isolate);
     }
     v8SetReturnValue(args, promise);
 }
 
 //
 // -- V8PromiseCustom --
 void V8PromiseCustom::createPromise(v8::Handle<v8::Object> creationContext, v8::Local<v8::Object>* promise, v8::Local<v8::Object>* resolver, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> internalTemplate = internalObjectTemplate(isolate);
+    v8::Local<v8::ObjectTemplate> resolverTemplate = resolverObjectTemplate(isolate);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
+    *resolver = resolverTemplate->NewInstance();
     *promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::info, 0, isolate);
-    *resolver = V8DOMWrapper::createWrapper(creationContext, &V8PromiseResolver::info, 0, isolate);
 
     clearInternal(internal, V8PromiseCustom::Pending, v8::Undefined(isolate), isolate);
 
     (*promise)->SetInternalField(v8DOMWrapperObjectIndex, internal);
     (*resolver)->SetInternalField(v8DOMWrapperObjectIndex, internal);

[yhirano, 2013/09/18 12:52:39]

Please add a comment describing that v8DOMWrapperObjectIndex equals to
ResolverInternalIndex.

[yusukesuzuki, 2013/09/18 14:48:24]

Done.

 }
 
 void V8PromiseCustom::fulfillResolver(v8::Handle<v8::Object> resolver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
 {
     if (isInternalDetached(resolver))
         return;
     v8::Local<v8::Object> internal = getInternal(resolver);
     ASSERT(getState(internal) == Pending || getState(internal) == PendingWithResolvedFlagSet);
     v8::Local<v8::Array> callbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
     clearInternal(internal, Fulfilled, result, isolate);
@@ skipping 128 matching lines @@
         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);
     }
 }
 
 } // namespace WebCore