mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-07 20:17:37 +00:00
4ad64a690c
Apart from moving the methods, I made the following changes: 1) Renamed them to ToJSValue. 2) Inlined the boolean overload. 3) Added overloads that take integer types. 4) Changed the order of the aCx and aArgument arguments so aCx comes first. 5) Renamed "abv" to "obj" in the typed array overload.
1134 lines
32 KiB
C++
1134 lines
32 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/dom/Promise.h"
|
|
|
|
#include "jsfriendapi.h"
|
|
#include "mozilla/dom/OwningNonNull.h"
|
|
#include "mozilla/dom/PromiseBinding.h"
|
|
#include "mozilla/CycleCollectedJSRuntime.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "PromiseCallback.h"
|
|
#include "PromiseNativeHandler.h"
|
|
#include "nsContentUtils.h"
|
|
#include "WorkerPrivate.h"
|
|
#include "WorkerRunnable.h"
|
|
#include "nsJSPrincipals.h"
|
|
#include "nsJSUtils.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsJSEnvironment.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
using namespace workers;
|
|
|
|
NS_IMPL_ISUPPORTS0(PromiseNativeHandler)
|
|
|
|
// PromiseTask
|
|
|
|
// This class processes the promise's callbacks with promise's result.
|
|
class PromiseTask MOZ_FINAL : public nsRunnable
|
|
{
|
|
public:
|
|
PromiseTask(Promise* aPromise)
|
|
: mPromise(aPromise)
|
|
{
|
|
MOZ_ASSERT(aPromise);
|
|
MOZ_COUNT_CTOR(PromiseTask);
|
|
}
|
|
|
|
~PromiseTask()
|
|
{
|
|
MOZ_COUNT_DTOR(PromiseTask);
|
|
}
|
|
|
|
NS_IMETHOD Run()
|
|
{
|
|
mPromise->mTaskPending = false;
|
|
mPromise->RunTask();
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<Promise> mPromise;
|
|
};
|
|
|
|
class WorkerPromiseTask MOZ_FINAL : public WorkerSameThreadRunnable
|
|
{
|
|
public:
|
|
WorkerPromiseTask(WorkerPrivate* aWorkerPrivate, Promise* aPromise)
|
|
: WorkerSameThreadRunnable(aWorkerPrivate)
|
|
, mPromise(aPromise)
|
|
{
|
|
MOZ_ASSERT(aPromise);
|
|
MOZ_COUNT_CTOR(WorkerPromiseTask);
|
|
}
|
|
|
|
~WorkerPromiseTask()
|
|
{
|
|
MOZ_COUNT_DTOR(WorkerPromiseTask);
|
|
}
|
|
|
|
bool
|
|
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
|
|
{
|
|
mPromise->mTaskPending = false;
|
|
mPromise->RunTask();
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<Promise> mPromise;
|
|
};
|
|
|
|
class PromiseResolverMixin
|
|
{
|
|
public:
|
|
PromiseResolverMixin(Promise* aPromise,
|
|
JS::Handle<JS::Value> aValue,
|
|
Promise::PromiseState aState)
|
|
: mPromise(aPromise)
|
|
, mValue(aValue)
|
|
, mState(aState)
|
|
{
|
|
MOZ_ASSERT(aPromise);
|
|
MOZ_ASSERT(mState != Promise::Pending);
|
|
MOZ_COUNT_CTOR(PromiseResolverMixin);
|
|
|
|
/* It's safe to use unsafeGet() here: the unsafeness comes from the
|
|
* possibility of updating the value of mJSObject without triggering the
|
|
* barriers. However if the value will always be marked, post barriers
|
|
* unnecessary. */
|
|
JS_AddNamedValueRootRT(CycleCollectedJSRuntime::Get()->Runtime(), mValue.unsafeGet(),
|
|
"PromiseResolverMixin.mValue");
|
|
}
|
|
|
|
virtual ~PromiseResolverMixin()
|
|
{
|
|
NS_ASSERT_OWNINGTHREAD(PromiseResolverMixin);
|
|
MOZ_COUNT_DTOR(PromiseResolverMixin);
|
|
|
|
/* It's safe to use unsafeGet() here: the unsafeness comes from the
|
|
* possibility of updating the value of mJSObject without triggering the
|
|
* barriers. However if the value will always be marked, post barriers
|
|
* unnecessary. */
|
|
JS_RemoveValueRootRT(CycleCollectedJSRuntime::Get()->Runtime(), mValue.unsafeGet());
|
|
}
|
|
|
|
protected:
|
|
void
|
|
RunInternal()
|
|
{
|
|
NS_ASSERT_OWNINGTHREAD(PromiseResolverMixin);
|
|
mPromise->RunResolveTask(
|
|
JS::Handle<JS::Value>::fromMarkedLocation(mValue.address()),
|
|
mState, Promise::SyncTask);
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<Promise> mPromise;
|
|
JS::Heap<JS::Value> mValue;
|
|
Promise::PromiseState mState;
|
|
NS_DECL_OWNINGTHREAD;
|
|
};
|
|
|
|
// This class processes the promise's callbacks with promise's result.
|
|
class PromiseResolverTask MOZ_FINAL : public nsRunnable,
|
|
public PromiseResolverMixin
|
|
{
|
|
public:
|
|
PromiseResolverTask(Promise* aPromise,
|
|
JS::Handle<JS::Value> aValue,
|
|
Promise::PromiseState aState)
|
|
: PromiseResolverMixin(aPromise, aValue, aState)
|
|
{}
|
|
|
|
~PromiseResolverTask()
|
|
{}
|
|
|
|
NS_IMETHOD Run()
|
|
{
|
|
RunInternal();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
class WorkerPromiseResolverTask MOZ_FINAL : public WorkerSameThreadRunnable,
|
|
public PromiseResolverMixin
|
|
{
|
|
public:
|
|
WorkerPromiseResolverTask(WorkerPrivate* aWorkerPrivate,
|
|
Promise* aPromise,
|
|
JS::Handle<JS::Value> aValue,
|
|
Promise::PromiseState aState)
|
|
: WorkerSameThreadRunnable(aWorkerPrivate),
|
|
PromiseResolverMixin(aPromise, aValue, aState)
|
|
{}
|
|
|
|
~WorkerPromiseResolverTask()
|
|
{}
|
|
|
|
bool
|
|
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
|
|
{
|
|
RunInternal();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Promise
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(Promise)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Promise)
|
|
tmp->MaybeReportRejectedOnce();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mResolveCallbacks)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mRejectCallbacks)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Promise)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResolveCallbacks)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRejectCallbacks)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Promise)
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_JSVAL_MEMBER_CALLBACK(mResult)
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(Promise)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(Promise)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Promise)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
Promise::Promise(nsIGlobalObject* aGlobal)
|
|
: mGlobal(aGlobal)
|
|
, mResult(JS::UndefinedValue())
|
|
, mState(Pending)
|
|
, mTaskPending(false)
|
|
, mHadRejectCallback(false)
|
|
, mResolvePending(false)
|
|
{
|
|
MOZ_ASSERT(mGlobal);
|
|
|
|
mozilla::HoldJSObjects(this);
|
|
SetIsDOMBinding();
|
|
}
|
|
|
|
Promise::~Promise()
|
|
{
|
|
MaybeReportRejectedOnce();
|
|
mozilla::DropJSObjects(this);
|
|
}
|
|
|
|
JSObject*
|
|
Promise::WrapObject(JSContext* aCx)
|
|
{
|
|
return PromiseBinding::Wrap(aCx, this);
|
|
}
|
|
|
|
JSObject*
|
|
Promise::GetOrCreateWrapper(JSContext* aCx)
|
|
{
|
|
if (JSObject* wrapper = GetWrapper()) {
|
|
return wrapper;
|
|
}
|
|
|
|
nsIGlobalObject* global = GetParentObject();
|
|
MOZ_ASSERT(global);
|
|
|
|
JS::Rooted<JSObject*> scope(aCx, global->GetGlobalJSObject());
|
|
if (!scope) {
|
|
JS_ReportError(aCx, "can't get scope");
|
|
return nullptr;
|
|
}
|
|
|
|
JSAutoCompartment ac(aCx, scope);
|
|
|
|
JS::Rooted<JS::Value> val(aCx);
|
|
if (!WrapNewBindingObject(aCx, this, &val)) {
|
|
MOZ_ASSERT(JS_IsExceptionPending(aCx));
|
|
return nullptr;
|
|
}
|
|
|
|
return GetWrapper();
|
|
}
|
|
|
|
void
|
|
Promise::MaybeResolve(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue)
|
|
{
|
|
MaybeResolveInternal(aCx, aValue);
|
|
}
|
|
|
|
void
|
|
Promise::MaybeReject(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue)
|
|
{
|
|
MaybeRejectInternal(aCx, aValue);
|
|
}
|
|
|
|
enum {
|
|
SLOT_PROMISE = 0,
|
|
SLOT_DATA
|
|
};
|
|
|
|
/* static */ bool
|
|
Promise::JSCallback(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = CallArgsFromVp(aArgc, aVp);
|
|
|
|
JS::Rooted<JS::Value> v(aCx,
|
|
js::GetFunctionNativeReserved(&args.callee(),
|
|
SLOT_PROMISE));
|
|
MOZ_ASSERT(v.isObject());
|
|
|
|
Promise* promise;
|
|
if (NS_FAILED(UNWRAP_OBJECT(Promise, &v.toObject(), promise))) {
|
|
return Throw(aCx, NS_ERROR_UNEXPECTED);
|
|
}
|
|
|
|
v = js::GetFunctionNativeReserved(&args.callee(), SLOT_DATA);
|
|
PromiseCallback::Task task = static_cast<PromiseCallback::Task>(v.toInt32());
|
|
|
|
if (task == PromiseCallback::Resolve) {
|
|
promise->MaybeResolveInternal(aCx, args.get(0));
|
|
} else {
|
|
promise->MaybeRejectInternal(aCx, args.get(0));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Utilities for thenable callbacks.
|
|
*
|
|
* A thenable is a { then: function(resolve, reject) { } }.
|
|
* `then` is called with a resolve and reject callback pair.
|
|
* Since only one of these should be called at most once (first call wins), the
|
|
* two keep a reference to each other in SLOT_DATA. When either of them is
|
|
* called, the references are cleared. Further calls are ignored.
|
|
*/
|
|
namespace {
|
|
void
|
|
LinkThenableCallables(JSContext* aCx, JS::Handle<JSObject*> aResolveFunc,
|
|
JS::Handle<JSObject*> aRejectFunc)
|
|
{
|
|
js::SetFunctionNativeReserved(aResolveFunc, SLOT_DATA,
|
|
JS::ObjectValue(*aRejectFunc));
|
|
js::SetFunctionNativeReserved(aRejectFunc, SLOT_DATA,
|
|
JS::ObjectValue(*aResolveFunc));
|
|
}
|
|
|
|
/*
|
|
* Returns false if callback was already called before, otherwise breaks the
|
|
* links and returns true.
|
|
*/
|
|
bool
|
|
MarkAsCalledIfNotCalledBefore(JSContext* aCx, JS::Handle<JSObject*> aFunc)
|
|
{
|
|
JS::Value otherFuncVal = js::GetFunctionNativeReserved(aFunc, SLOT_DATA);
|
|
|
|
if (!otherFuncVal.isObject()) {
|
|
return false;
|
|
}
|
|
|
|
JSObject* otherFuncObj = &otherFuncVal.toObject();
|
|
MOZ_ASSERT(js::GetFunctionNativeReserved(otherFuncObj, SLOT_DATA).isObject());
|
|
|
|
// Break both references.
|
|
js::SetFunctionNativeReserved(aFunc, SLOT_DATA, JS::UndefinedValue());
|
|
js::SetFunctionNativeReserved(otherFuncObj, SLOT_DATA, JS::UndefinedValue());
|
|
|
|
return true;
|
|
}
|
|
|
|
Promise*
|
|
GetPromise(JSContext* aCx, JS::Handle<JSObject*> aFunc)
|
|
{
|
|
JS::Value promiseVal = js::GetFunctionNativeReserved(aFunc, SLOT_PROMISE);
|
|
|
|
MOZ_ASSERT(promiseVal.isObject());
|
|
|
|
Promise* promise;
|
|
UNWRAP_OBJECT(Promise, &promiseVal.toObject(), promise);
|
|
return promise;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Common bits of (JSCallbackThenableResolver/JSCallbackThenableRejecter).
|
|
* Resolves/rejects the Promise if it is ok to do so, based on whether either of
|
|
* the callbacks have been called before or not.
|
|
*/
|
|
/* static */ bool
|
|
Promise::ThenableResolverCommon(JSContext* aCx, uint32_t aTask,
|
|
unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
JS::CallArgs args = CallArgsFromVp(aArgc, aVp);
|
|
JS::Rooted<JSObject*> thisFunc(aCx, &args.callee());
|
|
if (!MarkAsCalledIfNotCalledBefore(aCx, thisFunc)) {
|
|
// A function from this pair has been called before.
|
|
return true;
|
|
}
|
|
|
|
Promise* promise = GetPromise(aCx, thisFunc);
|
|
MOZ_ASSERT(promise);
|
|
|
|
if (aTask == PromiseCallback::Resolve) {
|
|
promise->ResolveInternal(aCx, args.get(0), SyncTask);
|
|
} else {
|
|
promise->RejectInternal(aCx, args.get(0), SyncTask);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* static */ bool
|
|
Promise::JSCallbackThenableResolver(JSContext* aCx,
|
|
unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
return ThenableResolverCommon(aCx, PromiseCallback::Resolve, aArgc, aVp);
|
|
}
|
|
|
|
/* static */ bool
|
|
Promise::JSCallbackThenableRejecter(JSContext* aCx,
|
|
unsigned aArgc, JS::Value* aVp)
|
|
{
|
|
return ThenableResolverCommon(aCx, PromiseCallback::Reject, aArgc, aVp);
|
|
}
|
|
|
|
/* static */ JSObject*
|
|
Promise::CreateFunction(JSContext* aCx, JSObject* aParent, Promise* aPromise,
|
|
int32_t aTask)
|
|
{
|
|
JSFunction* func = js::NewFunctionWithReserved(aCx, JSCallback,
|
|
1 /* nargs */, 0 /* flags */,
|
|
aParent, nullptr);
|
|
if (!func) {
|
|
return nullptr;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> obj(aCx, JS_GetFunctionObject(func));
|
|
|
|
JS::Rooted<JS::Value> promiseObj(aCx);
|
|
if (!dom::WrapNewBindingObject(aCx, aPromise, &promiseObj)) {
|
|
return nullptr;
|
|
}
|
|
|
|
js::SetFunctionNativeReserved(obj, SLOT_PROMISE, promiseObj);
|
|
js::SetFunctionNativeReserved(obj, SLOT_DATA, JS::Int32Value(aTask));
|
|
|
|
return obj;
|
|
}
|
|
|
|
/* static */ JSObject*
|
|
Promise::CreateThenableFunction(JSContext* aCx, Promise* aPromise, uint32_t aTask)
|
|
{
|
|
JSNative whichFunc =
|
|
aTask == PromiseCallback::Resolve ? JSCallbackThenableResolver :
|
|
JSCallbackThenableRejecter ;
|
|
|
|
JSFunction* func = js::NewFunctionWithReserved(aCx, whichFunc,
|
|
1 /* nargs */, 0 /* flags */,
|
|
nullptr, nullptr);
|
|
if (!func) {
|
|
return nullptr;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> obj(aCx, JS_GetFunctionObject(func));
|
|
|
|
JS::Rooted<JS::Value> promiseObj(aCx);
|
|
if (!dom::WrapNewBindingObject(aCx, aPromise, &promiseObj)) {
|
|
return nullptr;
|
|
}
|
|
|
|
js::SetFunctionNativeReserved(obj, SLOT_PROMISE, promiseObj);
|
|
|
|
return obj;
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Constructor(const GlobalObject& aGlobal,
|
|
PromiseInit& aInit, ErrorResult& aRv)
|
|
{
|
|
JSContext* cx = aGlobal.GetContext();
|
|
|
|
nsCOMPtr<nsIGlobalObject> global;
|
|
global = do_QueryInterface(aGlobal.GetAsSupports());
|
|
if (!global) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
nsRefPtr<Promise> promise = new Promise(global);
|
|
|
|
JS::Rooted<JSObject*> resolveFunc(cx,
|
|
CreateFunction(cx, aGlobal.Get(), promise,
|
|
PromiseCallback::Resolve));
|
|
if (!resolveFunc) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> rejectFunc(cx,
|
|
CreateFunction(cx, aGlobal.Get(), promise,
|
|
PromiseCallback::Reject));
|
|
if (!rejectFunc) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
aInit.Call(resolveFunc, rejectFunc, aRv, CallbackObject::eRethrowExceptions);
|
|
aRv.WouldReportJSException();
|
|
|
|
if (aRv.IsJSException()) {
|
|
JS::Rooted<JS::Value> value(cx);
|
|
aRv.StealJSException(cx, &value);
|
|
|
|
// we want the same behavior as this JS implementation:
|
|
// function Promise(arg) { try { arg(a, b); } catch (e) { this.reject(e); }}
|
|
if (!JS_WrapValue(cx, &value)) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
promise->MaybeRejectInternal(cx, value);
|
|
}
|
|
|
|
return promise.forget();
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Resolve(const GlobalObject& aGlobal, JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue, ErrorResult& aRv)
|
|
{
|
|
// If a Promise was passed, just return it.
|
|
if (aValue.isObject()) {
|
|
JS::Rooted<JSObject*> valueObj(aCx, &aValue.toObject());
|
|
Promise* nextPromise;
|
|
nsresult rv = UNWRAP_OBJECT(Promise, valueObj, nextPromise);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsRefPtr<Promise> addRefed = nextPromise;
|
|
return addRefed.forget();
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIGlobalObject> global =
|
|
do_QueryInterface(aGlobal.GetAsSupports());
|
|
if (!global) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
return Resolve(global, aCx, aValue, aRv);
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Resolve(nsIGlobalObject* aGlobal, JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue, ErrorResult& aRv)
|
|
{
|
|
nsRefPtr<Promise> promise = new Promise(aGlobal);
|
|
|
|
promise->MaybeResolveInternal(aCx, aValue);
|
|
return promise.forget();
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Reject(const GlobalObject& aGlobal, JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue, ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<nsIGlobalObject> global =
|
|
do_QueryInterface(aGlobal.GetAsSupports());
|
|
if (!global) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
return Reject(global, aCx, aValue, aRv);
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Reject(nsIGlobalObject* aGlobal, JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue, ErrorResult& aRv)
|
|
{
|
|
nsRefPtr<Promise> promise = new Promise(aGlobal);
|
|
|
|
promise->MaybeRejectInternal(aCx, aValue);
|
|
return promise.forget();
|
|
}
|
|
|
|
already_AddRefed<Promise>
|
|
Promise::Then(JSContext* aCx, AnyCallback* aResolveCallback,
|
|
AnyCallback* aRejectCallback)
|
|
{
|
|
nsRefPtr<Promise> promise = new Promise(GetParentObject());
|
|
|
|
JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
|
|
|
|
nsRefPtr<PromiseCallback> resolveCb =
|
|
PromiseCallback::Factory(promise, global, aResolveCallback,
|
|
PromiseCallback::Resolve);
|
|
|
|
nsRefPtr<PromiseCallback> rejectCb =
|
|
PromiseCallback::Factory(promise, global, aRejectCallback,
|
|
PromiseCallback::Reject);
|
|
|
|
AppendCallbacks(resolveCb, rejectCb);
|
|
|
|
return promise.forget();
|
|
}
|
|
|
|
already_AddRefed<Promise>
|
|
Promise::Catch(JSContext* aCx, AnyCallback* aRejectCallback)
|
|
{
|
|
nsRefPtr<AnyCallback> resolveCb;
|
|
return Then(aCx, resolveCb, aRejectCallback);
|
|
}
|
|
|
|
/**
|
|
* The CountdownHolder class encapsulates Promise.all countdown functions and
|
|
* the countdown holder parts of the Promises spec. It maintains the result
|
|
* array and AllResolveHandlers use SetValue() to set the array indices.
|
|
*/
|
|
class CountdownHolder MOZ_FINAL : public nsISupports
|
|
{
|
|
public:
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(CountdownHolder)
|
|
|
|
CountdownHolder(const GlobalObject& aGlobal, Promise* aPromise,
|
|
uint32_t aCountdown)
|
|
: mPromise(aPromise), mCountdown(aCountdown)
|
|
{
|
|
MOZ_ASSERT(aCountdown != 0);
|
|
JSContext* cx = aGlobal.GetContext();
|
|
|
|
// The only time aGlobal.GetContext() and aGlobal.Get() are not
|
|
// same-compartment is when we're called via Xrays, and in that situation we
|
|
// in fact want to create the array in the callee compartment
|
|
|
|
JSAutoCompartment ac(cx, aGlobal.Get());
|
|
mValues = JS_NewArrayObject(cx, aCountdown);
|
|
mozilla::HoldJSObjects(this);
|
|
}
|
|
|
|
~CountdownHolder()
|
|
{
|
|
mozilla::DropJSObjects(this);
|
|
}
|
|
|
|
void SetValue(uint32_t index, const JS::Handle<JS::Value> aValue)
|
|
{
|
|
MOZ_ASSERT(mCountdown > 0);
|
|
|
|
ThreadsafeAutoSafeJSContext cx;
|
|
JSAutoCompartment ac(cx, mValues);
|
|
{
|
|
|
|
AutoDontReportUncaught silenceReporting(cx);
|
|
JS::Rooted<JS::Value> value(cx, aValue);
|
|
if (!JS_WrapValue(cx, &value) ||
|
|
!JS_DefineElement(cx, mValues, index, value, nullptr, nullptr,
|
|
JSPROP_ENUMERATE)) {
|
|
MOZ_ASSERT(JS_IsExceptionPending(cx));
|
|
JS::Rooted<JS::Value> exn(cx);
|
|
JS_GetPendingException(cx, &exn);
|
|
|
|
mPromise->MaybeReject(cx, exn);
|
|
}
|
|
}
|
|
|
|
--mCountdown;
|
|
if (mCountdown == 0) {
|
|
JS::Rooted<JS::Value> result(cx, JS::ObjectValue(*mValues));
|
|
mPromise->MaybeResolve(cx, result);
|
|
}
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<Promise> mPromise;
|
|
uint32_t mCountdown;
|
|
JS::Heap<JSObject*> mValues;
|
|
};
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(CountdownHolder)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(CountdownHolder)
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(CountdownHolder)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CountdownHolder)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(CountdownHolder)
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mValues)
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(CountdownHolder)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPromise)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CountdownHolder)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPromise)
|
|
tmp->mValues = nullptr;
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
/**
|
|
* An AllResolveHandler is the per-promise part of the Promise.all() algorithm.
|
|
* Every Promise in the handler is handed an instance of this as a resolution
|
|
* handler and it sets the relevant index in the CountdownHolder.
|
|
*/
|
|
class AllResolveHandler MOZ_FINAL : public PromiseNativeHandler
|
|
{
|
|
public:
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(AllResolveHandler)
|
|
|
|
AllResolveHandler(CountdownHolder* aHolder, uint32_t aIndex)
|
|
: mCountdownHolder(aHolder), mIndex(aIndex)
|
|
{
|
|
MOZ_ASSERT(aHolder);
|
|
}
|
|
|
|
~AllResolveHandler()
|
|
{
|
|
}
|
|
|
|
void
|
|
ResolvedCallback(JS::Handle<JS::Value> aValue)
|
|
{
|
|
mCountdownHolder->SetValue(mIndex, aValue);
|
|
}
|
|
|
|
void
|
|
RejectedCallback(JS::Handle<JS::Value> aValue)
|
|
{
|
|
// Should never be attached to Promise as a reject handler.
|
|
MOZ_ASSERT(false, "AllResolveHandler should never be attached to a Promise's reject handler!");
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<CountdownHolder> mCountdownHolder;
|
|
uint32_t mIndex;
|
|
};
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(AllResolveHandler)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(AllResolveHandler)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AllResolveHandler)
|
|
NS_INTERFACE_MAP_END_INHERITING(PromiseNativeHandler)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_1(AllResolveHandler, mCountdownHolder)
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::All(const GlobalObject& aGlobal, JSContext* aCx,
|
|
const Sequence<JS::Value>& aIterable, ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<nsIGlobalObject> global =
|
|
do_QueryInterface(aGlobal.GetAsSupports());
|
|
if (!global) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
if (aIterable.Length() == 0) {
|
|
JS::Rooted<JSObject*> empty(aCx, JS_NewArrayObject(aCx, 0));
|
|
if (!empty) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return nullptr;
|
|
}
|
|
JS::Rooted<JS::Value> value(aCx, JS::ObjectValue(*empty));
|
|
return Promise::Resolve(aGlobal, aCx, value, aRv);
|
|
}
|
|
|
|
nsRefPtr<Promise> promise = new Promise(global);
|
|
nsRefPtr<CountdownHolder> holder =
|
|
new CountdownHolder(aGlobal, promise, aIterable.Length());
|
|
|
|
JS::Rooted<JSObject*> obj(aCx, JS::CurrentGlobalOrNull(aCx));
|
|
if (!obj) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
nsRefPtr<PromiseCallback> rejectCb = new RejectPromiseCallback(promise, obj);
|
|
|
|
for (uint32_t i = 0; i < aIterable.Length(); ++i) {
|
|
JS::Rooted<JS::Value> value(aCx, aIterable.ElementAt(i));
|
|
nsRefPtr<Promise> nextPromise = Promise::Resolve(aGlobal, aCx, value, aRv);
|
|
|
|
MOZ_ASSERT(!aRv.Failed());
|
|
|
|
nsRefPtr<PromiseNativeHandler> resolveHandler =
|
|
new AllResolveHandler(holder, i);
|
|
|
|
nsRefPtr<PromiseCallback> resolveCb =
|
|
new NativePromiseCallback(resolveHandler, Resolved);
|
|
// Every promise gets its own resolve callback, which will set the right
|
|
// index in the array to the resolution value.
|
|
nextPromise->AppendCallbacks(resolveCb, rejectCb);
|
|
}
|
|
|
|
return promise.forget();
|
|
}
|
|
|
|
/* static */ already_AddRefed<Promise>
|
|
Promise::Race(const GlobalObject& aGlobal, JSContext* aCx,
|
|
const Sequence<JS::Value>& aIterable, ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<nsIGlobalObject> global =
|
|
do_QueryInterface(aGlobal.GetAsSupports());
|
|
if (!global) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> obj(aCx, JS::CurrentGlobalOrNull(aCx));
|
|
if (!obj) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
|
|
nsRefPtr<Promise> promise = new Promise(global);
|
|
|
|
nsRefPtr<PromiseCallback> resolveCb =
|
|
new ResolvePromiseCallback(promise, obj);
|
|
|
|
nsRefPtr<PromiseCallback> rejectCb = new RejectPromiseCallback(promise, obj);
|
|
|
|
for (uint32_t i = 0; i < aIterable.Length(); ++i) {
|
|
JS::Rooted<JS::Value> value(aCx, aIterable.ElementAt(i));
|
|
nsRefPtr<Promise> nextPromise = Promise::Resolve(aGlobal, aCx, value, aRv);
|
|
// According to spec, Resolve can throw, but our implementation never does.
|
|
// Well it does when window isn't passed on the main thread, but that is an
|
|
// implementation detail which should never be reached since we are checking
|
|
// for window above. Remove this when subclassing is supported.
|
|
MOZ_ASSERT(!aRv.Failed());
|
|
nextPromise->AppendCallbacks(resolveCb, rejectCb);
|
|
}
|
|
|
|
return promise.forget();
|
|
}
|
|
|
|
void
|
|
Promise::AppendNativeHandler(PromiseNativeHandler* aRunnable)
|
|
{
|
|
nsRefPtr<PromiseCallback> resolveCb =
|
|
new NativePromiseCallback(aRunnable, Resolved);
|
|
|
|
nsRefPtr<PromiseCallback> rejectCb =
|
|
new NativePromiseCallback(aRunnable, Rejected);
|
|
|
|
AppendCallbacks(resolveCb, rejectCb);
|
|
}
|
|
|
|
void
|
|
Promise::AppendCallbacks(PromiseCallback* aResolveCallback,
|
|
PromiseCallback* aRejectCallback)
|
|
{
|
|
if (aResolveCallback) {
|
|
mResolveCallbacks.AppendElement(aResolveCallback);
|
|
}
|
|
|
|
if (aRejectCallback) {
|
|
mHadRejectCallback = true;
|
|
mRejectCallbacks.AppendElement(aRejectCallback);
|
|
|
|
// Now that there is a callback, we don't need to report anymore.
|
|
RemoveFeature();
|
|
}
|
|
|
|
// If promise's state is resolved, queue a task to process our resolve
|
|
// callbacks with promise's result. If promise's state is rejected, queue a
|
|
// task to process our reject callbacks with promise's result.
|
|
if (mState != Pending && !mTaskPending) {
|
|
if (MOZ_LIKELY(NS_IsMainThread())) {
|
|
nsRefPtr<PromiseTask> task = new PromiseTask(this);
|
|
NS_DispatchToCurrentThread(task);
|
|
} else {
|
|
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(worker);
|
|
nsRefPtr<WorkerPromiseTask> task = new WorkerPromiseTask(worker, this);
|
|
task->Dispatch(worker->GetJSContext());
|
|
}
|
|
mTaskPending = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
Promise::RunTask()
|
|
{
|
|
MOZ_ASSERT(mState != Pending);
|
|
|
|
nsTArray<nsRefPtr<PromiseCallback>> callbacks;
|
|
callbacks.SwapElements(mState == Resolved ? mResolveCallbacks
|
|
: mRejectCallbacks);
|
|
mResolveCallbacks.Clear();
|
|
mRejectCallbacks.Clear();
|
|
|
|
ThreadsafeAutoJSContext cx; // Just for rooting.
|
|
JS::Rooted<JS::Value> value(cx, mResult);
|
|
|
|
for (uint32_t i = 0; i < callbacks.Length(); ++i) {
|
|
callbacks[i]->Call(value);
|
|
}
|
|
}
|
|
|
|
void
|
|
Promise::MaybeReportRejected()
|
|
{
|
|
if (mState != Rejected || mHadRejectCallback || mResult.isUndefined()) {
|
|
return;
|
|
}
|
|
|
|
if (!mResult.isObject()) {
|
|
return;
|
|
}
|
|
ThreadsafeAutoJSContext cx;
|
|
JS::Rooted<JSObject*> obj(cx, &mResult.toObject());
|
|
JSAutoCompartment ac(cx, obj);
|
|
JSErrorReport* report = JS_ErrorFromException(cx, obj);
|
|
if (!report) {
|
|
return;
|
|
}
|
|
|
|
// Remains null in case of worker.
|
|
nsCOMPtr<nsPIDOMWindow> win;
|
|
bool isChromeError = false;
|
|
|
|
if (MOZ_LIKELY(NS_IsMainThread())) {
|
|
win =
|
|
do_QueryInterface(nsJSUtils::GetStaticScriptGlobal(obj));
|
|
nsIPrincipal* principal = nsContentUtils::GetObjectPrincipal(obj);
|
|
isChromeError = nsContentUtils::IsSystemPrincipal(principal);
|
|
} else {
|
|
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(worker);
|
|
isChromeError = worker->IsChromeWorker();
|
|
}
|
|
|
|
// Now post an event to do the real reporting async
|
|
// Since Promises preserve their wrapper, it is essential to nsRefPtr<> the
|
|
// AsyncErrorReporter, otherwise if the call to DispatchToMainThread fails, it
|
|
// will leak. See Bug 958684.
|
|
nsRefPtr<AsyncErrorReporter> r =
|
|
new AsyncErrorReporter(JS_GetObjectRuntime(obj),
|
|
report,
|
|
nullptr,
|
|
isChromeError,
|
|
win);
|
|
NS_DispatchToMainThread(r);
|
|
}
|
|
|
|
void
|
|
Promise::MaybeResolveInternal(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue,
|
|
PromiseTaskSync aAsynchronous)
|
|
{
|
|
if (mResolvePending) {
|
|
return;
|
|
}
|
|
|
|
ResolveInternal(aCx, aValue, aAsynchronous);
|
|
}
|
|
|
|
void
|
|
Promise::MaybeRejectInternal(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue,
|
|
PromiseTaskSync aAsynchronous)
|
|
{
|
|
if (mResolvePending) {
|
|
return;
|
|
}
|
|
|
|
RejectInternal(aCx, aValue, aAsynchronous);
|
|
}
|
|
|
|
void
|
|
Promise::HandleException(JSContext* aCx)
|
|
{
|
|
JS::Rooted<JS::Value> exn(aCx);
|
|
if (JS_GetPendingException(aCx, &exn)) {
|
|
JS_ClearPendingException(aCx);
|
|
RejectInternal(aCx, exn, SyncTask);
|
|
}
|
|
}
|
|
|
|
void
|
|
Promise::ResolveInternal(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue,
|
|
PromiseTaskSync aAsynchronous)
|
|
{
|
|
mResolvePending = true;
|
|
|
|
if (aValue.isObject()) {
|
|
AutoDontReportUncaught silenceReporting(aCx);
|
|
JS::Rooted<JSObject*> valueObj(aCx, &aValue.toObject());
|
|
|
|
// Thenables.
|
|
JS::Rooted<JS::Value> then(aCx);
|
|
if (!JS_GetProperty(aCx, valueObj, "then", &then)) {
|
|
HandleException(aCx);
|
|
return;
|
|
}
|
|
|
|
if (then.isObject() && JS_ObjectIsCallable(aCx, &then.toObject())) {
|
|
JS::Rooted<JSObject*> resolveFunc(aCx,
|
|
CreateThenableFunction(aCx, this, PromiseCallback::Resolve));
|
|
|
|
if (!resolveFunc) {
|
|
HandleException(aCx);
|
|
return;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> rejectFunc(aCx,
|
|
CreateThenableFunction(aCx, this, PromiseCallback::Reject));
|
|
if (!rejectFunc) {
|
|
HandleException(aCx);
|
|
return;
|
|
}
|
|
|
|
LinkThenableCallables(aCx, resolveFunc, rejectFunc);
|
|
|
|
JS::Rooted<JSObject*> thenObj(aCx, &then.toObject());
|
|
nsRefPtr<PromiseInit> thenCallback =
|
|
new PromiseInit(thenObj, mozilla::dom::GetIncumbentGlobal());
|
|
|
|
ErrorResult rv;
|
|
thenCallback->Call(valueObj, resolveFunc, rejectFunc,
|
|
rv, CallbackObject::eRethrowExceptions);
|
|
rv.WouldReportJSException();
|
|
|
|
if (rv.IsJSException()) {
|
|
JS::Rooted<JS::Value> exn(aCx);
|
|
rv.StealJSException(aCx, &exn);
|
|
|
|
bool couldMarkAsCalled = MarkAsCalledIfNotCalledBefore(aCx, resolveFunc);
|
|
|
|
// If we could mark as called, neither of the callbacks had been called
|
|
// when the exception was thrown. So we can reject the Promise.
|
|
if (couldMarkAsCalled) {
|
|
bool ok = JS_WrapValue(aCx, &exn);
|
|
MOZ_ASSERT(ok);
|
|
if (!ok) {
|
|
NS_WARNING("Failed to wrap value into the right compartment.");
|
|
}
|
|
|
|
RejectInternal(aCx, exn, Promise::SyncTask);
|
|
}
|
|
// At least one of resolveFunc or rejectFunc have been called, so ignore
|
|
// the exception. FIXME(nsm): This should be reported to the error
|
|
// console though, for debugging.
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If the synchronous flag is set, process our resolve callbacks with
|
|
// value. Otherwise, the synchronous flag is unset, queue a task to process
|
|
// own resolve callbacks with value. Otherwise, the synchronous flag is
|
|
// unset, queue a task to process our resolve callbacks with value.
|
|
RunResolveTask(aValue, Resolved, aAsynchronous);
|
|
}
|
|
|
|
void
|
|
Promise::RejectInternal(JSContext* aCx,
|
|
JS::Handle<JS::Value> aValue,
|
|
PromiseTaskSync aAsynchronous)
|
|
{
|
|
mResolvePending = true;
|
|
|
|
// If the synchronous flag is set, process our reject callbacks with
|
|
// value. Otherwise, the synchronous flag is unset, queue a task to process
|
|
// promise's reject callbacks with value.
|
|
RunResolveTask(aValue, Rejected, aAsynchronous);
|
|
}
|
|
|
|
void
|
|
Promise::RunResolveTask(JS::Handle<JS::Value> aValue,
|
|
PromiseState aState,
|
|
PromiseTaskSync aAsynchronous)
|
|
{
|
|
// If the synchronous flag is unset, queue a task to process our
|
|
// accept callbacks with value.
|
|
if (aAsynchronous == AsyncTask) {
|
|
if (MOZ_LIKELY(NS_IsMainThread())) {
|
|
nsRefPtr<PromiseResolverTask> task =
|
|
new PromiseResolverTask(this, aValue, aState);
|
|
NS_DispatchToCurrentThread(task);
|
|
} else {
|
|
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(worker);
|
|
nsRefPtr<WorkerPromiseResolverTask> task =
|
|
new WorkerPromiseResolverTask(worker, this, aValue, aState);
|
|
task->Dispatch(worker->GetJSContext());
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Promise.all() or Promise.race() implementations will repeatedly call
|
|
// Resolve/RejectInternal rather than using the Maybe... forms. Stop SetState
|
|
// from asserting.
|
|
if (mState != Pending) {
|
|
return;
|
|
}
|
|
|
|
SetResult(aValue);
|
|
SetState(aState);
|
|
|
|
// If the Promise was rejected, and there is no reject handler already setup,
|
|
// watch for thread shutdown.
|
|
if (aState == PromiseState::Rejected &&
|
|
!mHadRejectCallback &&
|
|
!NS_IsMainThread()) {
|
|
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(worker);
|
|
worker->AssertIsOnWorkerThread();
|
|
|
|
mFeature = new PromiseReportRejectFeature(this);
|
|
if (NS_WARN_IF(!worker->AddFeature(worker->GetJSContext(), mFeature))) {
|
|
// Worker is shutting down, report rejection immediately since it is
|
|
// unlikely that reject callbacks will be added after this point.
|
|
MaybeReportRejected();
|
|
}
|
|
}
|
|
|
|
RunTask();
|
|
}
|
|
|
|
void
|
|
Promise::RemoveFeature()
|
|
{
|
|
if (mFeature) {
|
|
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(worker);
|
|
worker->RemoveFeature(worker->GetJSContext(), mFeature);
|
|
mFeature = nullptr;
|
|
}
|
|
}
|
|
|
|
bool
|
|
PromiseReportRejectFeature::Notify(JSContext* aCx, workers::Status aStatus)
|
|
{
|
|
MOZ_ASSERT(aStatus > workers::Running);
|
|
mPromise->MaybeReportRejectedOnce();
|
|
// After this point, `this` has been deleted by RemoveFeature!
|
|
return true;
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|