Implement Promise.prototype.then and Promise.prototype.catch

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 33 matching lines @@
 #include "core/page/DOMWindow.h"
 #include "core/platform/Task.h"
 #include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 #include <v8.h>
 
 namespace WebCore {
 
 namespace {
 
+int wrapperCallbackTag = 0;
 int promiseFulfillCallbackTag = 0;
 int promiseResolveCallbackTag = 0;
 int promiseRejectCallbackTag = 0;
 
 v8::Local<v8::Function> getFunction(v8::FunctionCallback callback, int* tag, v8::Isolate* isolate)
 {
     // tag must be a pointer of one of the above tags.
-    ASSERT(tag == &promiseFulfillCallbackTag
+    ASSERT(tag == &wrapperCallbackTag
+        || tag == &promiseFulfillCallbackTag
         || tag == &promiseResolveCallbackTag
         || tag == &promiseRejectCallbackTag);
     WrapperWorldType worldType = WebCore::worldType(isolate);
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     ASSERT(data);
     V8PerIsolateData::TemplateMap::iterator result = data->templateMap(worldType).find(tag);
     if (result != data->templateMap(worldType).end())
         return result->value.newLocal(isolate)->GetFunction();
 
     v8::Handle<v8::FunctionTemplate> functionTemplate = v8::FunctionTemplate::New(callback);
@@ skipping 40 matching lines @@
 v8::Handle<v8::Value> postTask(v8::Handle<v8::Function> callback, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     DOMWindow* window = activeDOMWindow();
     ASSERT(window);
     Document* document = window->document();
     ASSERT(document);
     document->postTask(adoptPtr(new PromiseTask(callback, receiver, value)));
     return v8::Undefined(isolate);
 }
 
-// This function must have the resolver as the first argument when called
+// This function must have an environment object as the first argument
+// when called.
+// See wrapperCallback.
+void wrapperCallbackRaw(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Object> environment;
+    v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
+    ASSERT(args.Length() > 0);
+    environment = args[0].As<v8::Object>();
+    if (args.Length() > 1)
+        result = args[1];
+
+    v8::Local<v8::Object> promise = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseIndex).As<v8::Object>();
+    v8::Local<v8::Object> resolver = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseResolverIndex).As<v8::Object>();
+    v8::Local<v8::Function> callback = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentCallbackIndex).As<v8::Function>();
+
+    v8::Local<v8::Value> argv[] = {
+        result,
+    };
+    v8::TryCatch trycatch;
+    result = V8ScriptRunner::callFunction(callback, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv);
+    if (result.IsEmpty()) {
+        V8PromiseCustom::rejectResolver(resolver, trycatch.Exception(), V8PromiseCustom::Synchronous, isolate);
+        return;
+    }
+    V8PromiseCustom::resolveResolver(resolver, result, V8PromiseCustom::Synchronous, isolate);
+}
+
+v8::Handle<v8::Function> wrapperCallback(v8::Handle<v8::Object> promise, v8::Handle<v8::Object> resolver, v8::Handle<v8::Function> callback, v8::Isolate* isolate)
+{
+    // FIXME: v8::ObjectTemplate::New should be cached.
+    v8::Local<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New();
+    objectTemplate->SetInternalFieldCount(V8PromiseCustom::WrapperCallbackEnvironmentFieldCount);
+    v8::Local<v8::Object> environment = objectTemplate->NewInstance();
+    environment->SetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseIndex, promise);
+    environment->SetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseResolverIndex, resolver);
+    environment->SetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentCallbackIndex, callback);
+
+    // We bind |environment| to wrapperCallbackRaw
+    //
+    // wrapperCallback(result) will be evaluated as
+    // wrapperCallbackRaw(environment, result).
+
+    // FIXME: If there is a way to bind an object to a function other than evaluate a JavaScript, it will be preferable.
+    // We should not depend on the global context that user can change, such as accessing a property, calling a method or so.
+    v8::Local<v8::String> script = v8::String::New("(function(f, v1) { return function(v2) { return f(v1, v2); }; })");
+    v8::Local<v8::Value> value = V8ScriptRunner::compileAndRunInternalScript(script, isolate);

[abarth-chromium, 2013/07/01 05:49:38]

This is kind of ugly....

[yhirano, 2013/07/01 06:58:54]

We have to bind an environment object to the function.
I found two solutions:

1. Using JavaScript (i.e. PS3)
2. Using FunctionTemplate with attached Data (i.e. PS4)

If we choose the latter way, we don't have to use compileAndRunInternalScript,
but we can't share FunctionTemplate between wrapperCallback calls, since the
FunctionTemplate is constructed with data.
Do you prefer the latter way than the former one? Or do you have another option?

+    ASSERT(!value.IsEmpty());
+
+    v8::Local<v8::Value> argv[] = {
+        getFunction(wrapperCallbackRaw, &wrapperCallbackTag, isolate),
+        environment,
+    };
+    v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
+
+    value = V8ScriptRunner::callFunction(value.As<v8::Function>(), getScriptExecutionContext(), global, WTF_ARRAY_LENGTH(argv), argv);
+    ASSERT(!value.IsEmpty());
+    return value.As<v8::Function>();
+}
+
+// This function must have the resolver as the first argument when called.
 // See promiseCallback.
 void promiseFulfillCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Local<v8::Object> resolver;
     v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
     ASSERT(args.Length() > 0);
     resolver = args[0].As<v8::Object>();
     if (args.Length() > 1)
         result = args[1];
 
     V8PromiseCustom::fulfillResolver(resolver, result, V8PromiseCustom::Synchronous, args.GetIsolate());
 }
 
-// This function must be bound with the resolver as the first argument.
+// This function must have the resolver as the first argument when called.
 // See promiseCallback.
 void promiseResolveCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Local<v8::Object> resolver;
     v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
     ASSERT(args.Length() > 0);
     resolver = args[0].As<v8::Object>();
     if (args.Length() > 1)
         result = args[1];
 
     V8PromiseCustom::resolveResolver(resolver, result, V8PromiseCustom::Synchronous, args.GetIsolate());
 }
 
-// This function must be bound with the resolver as the first argument.
+// This function must have the resolver as the first argument when called.
 // See promiseCallback.
 void promiseRejectCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Local<v8::Object> resolver;
     v8::Local<v8::Value> result = v8::Undefined(args.GetIsolate());
     ASSERT(args.Length() > 0);
     resolver = args[0].As<v8::Object>();
     if (args.Length() > 1)
         result = args[1];
 
@@ skipping 19 matching lines @@
     // We bind |resolver| to promise{Fulfill, Resolve, Reject}Callback.
     //
     // promiseCallback(result) will be evaluated as
     // promiseFulfillCallback(resolver, result),
     // if algorithm is FulfillAlgorithm.
 
     // FIXME: If there is a way to bind an object to a function other than evaluate a JavaScript, it will be preferable.
     // We should not depend on the global context that user can change, such as accessing a property, calling a method or so.
     v8::Local<v8::String> script = v8String("(function(f, v1) { return function(v2) { return f(v1, v2); }; })", isolate);
     v8::Local<v8::Value> value = V8ScriptRunner::compileAndRunInternalScript(script, isolate);
+    ASSERT(!value.IsEmpty());
 
     v8::Local<v8::Value> argv[] = {
         callback,
         resolver,
     };
     v8::Local<v8::Object> receiver = isolate->GetCurrentContext()->Global();
 
     value = V8ScriptRunner::callFunction(value.As<v8::Function>(), getScriptExecutionContext(), receiver, WTF_ARRAY_LENGTH(argv), argv);
     ASSERT(!value.IsEmpty());
     return value.As<v8::Function>();
@@ skipping 28 matching lines @@
     v8::TryCatch trycatch;
     if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv).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;
 }
 
+void V8Promise::thenMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Function> fulfillWrapper, rejectWrapper;
+    v8::Local<v8::Object> promise, resolver;
+    V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
+    if (args.Length() > 0 && !args[0]->IsUndefined()) {
+        if (!args[0]->IsFunction()) {
+            v8SetReturnValue(args, throwTypeError("fulfillCallback must be a function or undefined", isolate));
+            return;
+        }
+        fulfillWrapper = wrapperCallback(promise, resolver, args[0].As<v8::Function>(), isolate);
+    } else {
+        fulfillWrapper = promiseCallback(resolver, V8PromiseCustom::FulfillAlgorithm, isolate);
+    }
+    if (args.Length() > 1 && !args[1]->IsUndefined()) {
+        if (!args[1]->IsFunction()) {
+            v8SetReturnValue(args, throwTypeError("rejectCallback must be a function or undefined", isolate));
+            return;
+        }
+        rejectWrapper = wrapperCallback(promise, resolver, args[1].As<v8::Function>(), isolate);
+    } else {
+        rejectWrapper = promiseCallback(resolver, V8PromiseCustom::RejectAlgorithm, isolate);
+    }
+    V8PromiseCustom::append(args.Holder(), fulfillWrapper, rejectWrapper, isolate);
+    v8SetReturnValue(args, promise);
+}
+
+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, resolver;
+    V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
+
+    if (args.Length() > 0 && !args[0]->IsUndefined()) {
+        if (!args[0]->IsFunction()) {
+            v8SetReturnValue(args, throwTypeError("rejectCallback must be a function or undefined", isolate));
+            return;
+        }
+        rejectWrapper = wrapperCallback(promise, resolver, args[0].As<v8::Function>(), isolate);
+    } else {
+        rejectWrapper = promiseCallback(resolver, V8PromiseCustom::RejectAlgorithm, isolate);
+    }
+    fulfillWrapper = promiseCallback(resolver, V8PromiseCustom::FulfillAlgorithm, isolate);
+    V8PromiseCustom::append(args.Holder(), fulfillWrapper, rejectWrapper, 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)
 {
     // FIXME: v8::ObjectTemplate::New should be cached.
     v8::Local<v8::ObjectTemplate> internalTemplate = v8::ObjectTemplate::New();
     internalTemplate->SetInternalFieldCount(InternalFieldCount);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
     *promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::info, 0, isolate);
     *resolver = V8DOMWrapper::createWrapper(creationContext, &V8PromiseResolver::info, 0, isolate);
@@ skipping 143 matching lines @@
         v8::TryCatch trycatch;
         v8::Handle<v8::Value> args[] = { result };
         V8ScriptRunner::callFunction(function, getScriptExecutionContext(), receiver, WTF_ARRAY_LENGTH(args), args);
     } else {
         ASSERT(mode == Asynchronous);
         postTask(function, receiver, result, isolate);
     }
 }
 
 } // namespace WebCore