[promises] port NewPromiseCapability to TF

src/js/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 71 matching lines @@
 // Only used by async-await.js
 function RejectPromise(promise, reason, debugEvent) {
   %PromiseReject(promise, reason, debugEvent);
 }
 
 // Export to bindings
 function DoRejectPromise(promise, reason) {
   %PromiseReject(promise, reason, true);
 }
 
-// The resultCapability.promise is only ever fulfilled internally,
-// so we don't need the closures to protect against accidentally
-// calling them multiple times.
-function CreateInternalPromiseCapability(parent) {
-  return {
-    promise: %promise_internal_constructor(parent),
-    resolve: UNDEFINED,
-    reject: UNDEFINED
-  };
-}
-
-// ES#sec-newpromisecapability
-// NewPromiseCapability ( C )
-function NewPromiseCapability(C, debugEvent) {
-  if (C === GlobalPromise) {
-    // Optimized case, avoid extra closure.
-    var promise = %promise_internal_constructor(UNDEFINED);
-    // TODO(gsathya): Remove container for callbacks when this is
-    // moved to CPP/TF.
-    var callbacks = %create_resolving_functions(promise, debugEvent);
-    return {
-      promise: promise,
-      resolve: callbacks[kResolveCallback],
-      reject: callbacks[kRejectCallback]
-    };
-  }
-
-  var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
-  result.promise = new C((resolve, reject) => {
-    if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
-        throw %make_type_error(kPromiseExecutorAlreadyInvoked);
-    result.resolve = resolve;
-    result.reject = reject;
-  });
-
-  if (!IS_CALLABLE(result.resolve) || !IS_CALLABLE(result.reject))
-      throw %make_type_error(kPromiseNonCallable);
-
-  return result;
-}
-
 // ES#sec-promise.reject
 // Promise.reject ( x )
 function PromiseReject(r) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = %promise_create_and_set(kRejected, r);
     // Trigger debug events if the debugger is on, as Promise.reject is
     // equivalent to throwing an exception directly.
     %PromiseRejectEventFromStack(promise, r);
     return promise;
   } else {
-    var promiseCapability = NewPromiseCapability(this, true);
+    var promiseCapability = %new_promise_capability(this, true);
     %_Call(promiseCapability.reject, UNDEFINED, r);
     return promiseCapability.promise;
   }
 }
 
 // ES#sec-promise.prototype.catch
 // Promise.prototype.catch ( onRejected )
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
 
 // ES#sec-promise.resolve
 // Promise.resolve ( x )
 function PromiseResolve(x) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   if (%is_promise(x) && x.constructor === this) return x;
 
   // Avoid creating resolving functions.
   if (this === GlobalPromise) {
     var promise = %promise_internal_constructor(UNDEFINED);
     %promise_resolve(promise, x);
     return promise;
   }
 
   // debugEvent is not so meaningful here as it will be resolved
-  var promiseCapability = NewPromiseCapability(this, true);
+  var promiseCapability = %new_promise_capability(this, true);
   %_Call(promiseCapability.resolve, UNDEFINED, x);
   return promiseCapability.promise;
 }
 
 // ES#sec-promise.all
 // Promise.all ( iterable )
 function PromiseAll(iterable) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, "Promise.all");
   }
 
   // false debugEvent so that forwarding the rejection through all does not
   // trigger redundant ExceptionEvents
-  var deferred = NewPromiseCapability(this, false);
+  var deferred = %new_promise_capability(this, false);
   var resolutions = new InternalArray();
   var count;
 
   // For catch prediction, don't treat the .then calls as handling it;
   // instead, recurse outwards.
   var instrumenting = DEBUG_IS_ACTIVE;
   if (instrumenting) {
     SET_PRIVATE(deferred.reject, promiseForwardingHandlerSymbol, true);
   }
 
@@ skipping 43 matching lines @@
 
 // ES#sec-promise.race
 // Promise.race ( iterable )
 function PromiseRace(iterable) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseRace);
   }
 
   // false debugEvent so that forwarding the rejection through race does not
   // trigger redundant ExceptionEvents
-  var deferred = NewPromiseCapability(this, false);
+  var deferred = %new_promise_capability(this, false);
 
   // For catch prediction, don't treat the .then calls as handling it;
   // instead, recurse outwards.
   var instrumenting = DEBUG_IS_ACTIVE;
   if (instrumenting) {
     SET_PRIVATE(deferred.reject, promiseForwardingHandlerSymbol, true);
   }
 
   try {
     for (var value of iterable) {
@@ skipping 97 matching lines @@
 %SetCode(GlobalPromise.prototype.catch, PromiseCatch);
 
 %InstallToContext([
   "promise_catch", GlobalPromise.prototype.catch,
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", DoRejectPromise,
   // TODO(gsathya): Remove this once we update the promise builtin.
   "promise_internal_reject", RejectPromise,
   "promise_debug_get_info", PromiseDebugGetInfo,
-  "new_promise_capability", NewPromiseCapability,
-  "internal_promise_capability", CreateInternalPromiseCapability,
   "promise_id_resolve_handler", PromiseIdResolveHandler,
   "promise_id_reject_handler", PromiseIdRejectHandler
 ]);
 
 // This allows extras to create promises quickly without building extra
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "rejectPromise", DoRejectPromise,
   "markPromiseAsHandled", MarkPromiseAsHandled
 ]);
 
 utils.Export(function(to) {
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
-
-  to.CreateInternalPromiseCapability = CreateInternalPromiseCapability;
   to.RejectPromise = RejectPromise;
 });
 
 })