diff options
Diffstat (limited to 'dom/promise')
48 files changed, 6926 insertions, 0 deletions
diff --git a/dom/promise/Promise-inl.h b/dom/promise/Promise-inl.h new file mode 100644 index 0000000000..a7a6ebd0fd --- /dev/null +++ b/dom/promise/Promise-inl.h @@ -0,0 +1,341 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef mozilla_dom_Promise_inl_h +#define mozilla_dom_Promise_inl_h + +#include <type_traits> +#include <utility> + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/ResultExtensions.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "nsCycleCollectionParticipant.h" + +namespace mozilla::dom { + +class PromiseNativeThenHandlerBase : public PromiseNativeHandler { + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(PromiseNativeThenHandlerBase) + + PromiseNativeThenHandlerBase(Promise* aPromise) : mPromise(aPromise) {} + + virtual bool HasResolvedCallback() = 0; + virtual bool HasRejectedCallback() = 0; + + MOZ_CAN_RUN_SCRIPT void ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + MOZ_CAN_RUN_SCRIPT void RejectedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + protected: + virtual ~PromiseNativeThenHandlerBase() = default; + + MOZ_CAN_RUN_SCRIPT virtual already_AddRefed<Promise> CallResolveCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) = 0; + MOZ_CAN_RUN_SCRIPT virtual already_AddRefed<Promise> CallRejectCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) = 0; + + virtual void Traverse(nsCycleCollectionTraversalCallback&) = 0; + virtual void Unlink() = 0; + virtual void Trace(const TraceCallbacks& aCallbacks, void* aClosure) = 0; + + RefPtr<Promise> mPromise; +}; + +namespace { + +template <typename T, bool = IsRefcounted<std::remove_pointer_t<T>>::value, + bool = (std::is_convertible_v<T, nsISupports*> || + std::is_convertible_v<T*, nsISupports*>)> +struct StorageTypeHelper { + using Type = T; +}; + +template <typename T> +struct StorageTypeHelper<T, true, true> { + using Type = nsCOMPtr<T>; +}; + +template <typename T> +struct StorageTypeHelper<nsCOMPtr<T>, true, true> { + using Type = nsCOMPtr<T>; +}; + +template <typename T> +struct StorageTypeHelper<T*, true, false> { + using Type = RefPtr<T>; +}; + +template <typename T> +struct StorageTypeHelper<JS::Handle<T>, false, false> { + using Type = JS::Heap<T>; +}; + +template <template <typename> class SmartPtr, typename T> +struct StorageTypeHelper<SmartPtr<T>, true, false> + : std::enable_if<std::is_convertible_v<SmartPtr<T>, T*>, RefPtr<T>> { + using Type = typename StorageTypeHelper::enable_if::type; +}; + +template <typename T> +using StorageType = typename StorageTypeHelper<std::decay_t<T>>::Type; + +// Helpers to choose the correct argument type based on the storage type. Smart +// pointers are converted to the corresponding raw pointer type. Everything else +// is passed by move reference. +// +// Note: We can't just use std::forward for this because the input type may be a +// raw pointer which does not match the argument type, and while the +// spec-compliant behavior there should still give us the expected results, MSVC +// considers it an illegal use of std::forward. +template <template <typename> class SmartPtr, typename T> +decltype(std::declval<SmartPtr<T>>().get()) ArgType(SmartPtr<T>& aVal) { + return aVal.get(); +} + +template <typename T> +T&& ArgType(T& aVal) { + return std::move(aVal); +} + +using ::ImplCycleCollectionUnlink; + +template <typename ResolveCallback, typename RejectCallback, typename ArgsTuple, + typename JSArgsTuple> +class NativeThenHandler; + +template <typename ResolveCallback, typename RejectCallback, typename... Args, + typename... JSArgs> +class NativeThenHandler<ResolveCallback, RejectCallback, std::tuple<Args...>, + std::tuple<JSArgs...>> + final : public PromiseNativeThenHandlerBase { + public: + /** + * @param aPromise A promise that will be settled by the result of the + * callbacks. Any thrown value to ErrorResult passed to those callbacks will + * be used to reject the promise, otherwise the promise will be resolved with + * the return value. + * @param aOnResolve A resolve callback + * @param aOnReject A reject callback + * @param aArgs The custom arguments to be passed to the both callbacks. The + * handler class will grab them to make them live long enough and to allow + * cycle collection. + * @param aJSArgs The JS arguments to be passed to the both callbacks, after + * native arguments. The handler will also grab them and allow garbage + * collection. + * + * XXX(krosylight): ideally there should be two signatures, with or without a + * promise parameter. Unfortunately doing so confuses the compiler and errors + * out, because nothing prevents promise from being ResolveCallback. + */ + NativeThenHandler(Promise* aPromise, Maybe<ResolveCallback>&& aOnResolve, + Maybe<RejectCallback>&& aOnReject, + std::tuple<std::remove_reference_t<Args>...>&& aArgs, + std::tuple<std::remove_reference_t<JSArgs>...>&& aJSArgs) + : PromiseNativeThenHandlerBase(aPromise), + mOnResolve(std::forward<Maybe<ResolveCallback>>(aOnResolve)), + mOnReject(std::forward<Maybe<RejectCallback>>(aOnReject)), + mArgs(std::forward<decltype(aArgs)>(aArgs)), + mJSArgs(std::forward<decltype(aJSArgs)>(aJSArgs)) { + if constexpr (std::tuple_size<decltype(mJSArgs)>::value > 0) { + mozilla::HoldJSObjects(this); + } + } + + protected: + ~NativeThenHandler() override { + if constexpr (std::tuple_size<decltype(mJSArgs)>::value > 0) { + mozilla::DropJSObjects(this); + } + } + + void Traverse(nsCycleCollectionTraversalCallback& cb) override { + auto* tmp = this; + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArgs) + } + + void Unlink() override { + auto* tmp = this; + NS_IMPL_CYCLE_COLLECTION_UNLINK(mArgs) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mJSArgs) + } + + void Trace(const TraceCallbacks& aCallbacks, void* aClosure) override { + std::apply( + [&aCallbacks, aClosure](auto&&... aArgs) { + (aCallbacks.Trace(&aArgs, "mJSArgs[]", aClosure), ...); + }, + mJSArgs); + } + + bool HasResolvedCallback() override { return mOnResolve.isSome(); } + bool HasRejectedCallback() override { return mOnReject.isSome(); } + + MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CallResolveCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) override { + return CallCallback(aCx, *mOnResolve, aValue, aRv); + } + MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CallRejectCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) override { + return CallCallback(aCx, *mOnReject, aValue, aRv); + } + + // mJSArgs are marked with Trace() above, so they can be safely converted to + // Handles. But we should not circumvent the read barrier, so call + // exposeToActiveJS explicitly. + template <typename T> + static JS::Handle<T> GetJSArgHandleForCall(JS::Heap<T>& aArg) { + aArg.exposeToActiveJS(); + return JS::Handle<T>::fromMarkedLocation(aArg.address()); + } + + template <typename TCallback, size_t... Indices, size_t... JSIndices> + MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CallCallback( + JSContext* aCx, const TCallback& aHandler, JS::Handle<JS::Value> aValue, + ErrorResult& aRv, std::index_sequence<Indices...>, + std::index_sequence<JSIndices...>) { + return aHandler(aCx, aValue, aRv, ArgType(std::get<Indices>(mArgs))..., + GetJSArgHandleForCall(std::get<JSIndices>(mJSArgs))...); + } + + template <typename TCallback> + MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CallCallback( + JSContext* aCx, const TCallback& aHandler, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + return CallCallback(aCx, aHandler, aValue, aRv, + std::index_sequence_for<Args...>{}, + std::index_sequence_for<JSArgs...>{}); + } + + Maybe<ResolveCallback> mOnResolve; + Maybe<RejectCallback> mOnReject; + + std::tuple<StorageType<Args>...> mArgs; + std::tuple<StorageType<JSArgs>...> mJSArgs; +}; + +} // anonymous namespace + +template <typename ResolveCallback, typename RejectCallback, typename... Args, + typename... JSArgs> +Result<RefPtr<Promise>, nsresult> +Promise::ThenCatchWithCycleCollectedArgsJSImpl( + Maybe<ResolveCallback>&& aOnResolve, Maybe<RejectCallback>&& aOnReject, + std::tuple<Args...>&& aArgs, std::tuple<JSArgs...>&& aJSArgs) { + using HandlerType = + NativeThenHandler<ResolveCallback, RejectCallback, std::tuple<Args...>, + std::tuple<JSArgs...>>; + + ErrorResult rv; + RefPtr<Promise> promise = Promise::Create(GetParentObject(), rv); + if (rv.Failed()) { + return Err(rv.StealNSResult()); + } + + auto* handler = new (fallible) + HandlerType(promise, std::forward<Maybe<ResolveCallback>>(aOnResolve), + std::forward<Maybe<RejectCallback>>(aOnReject), + std::forward<std::tuple<Args...>>(aArgs), + std::forward<std::tuple<JSArgs...>>(aJSArgs)); + + if (!handler) { + return Err(NS_ERROR_OUT_OF_MEMORY); + } + + AppendNativeHandler(handler); + return std::move(promise); +} + +template <typename ResolveCallback, typename RejectCallback, typename... Args> +Promise::ThenResult<ResolveCallback, Args...> +Promise::ThenCatchWithCycleCollectedArgsImpl( + Maybe<ResolveCallback>&& aOnResolve, Maybe<RejectCallback>&& aOnReject, + Args&&... aArgs) { + return ThenCatchWithCycleCollectedArgsJSImpl( + std::forward<Maybe<ResolveCallback>>(aOnResolve), + std::forward<Maybe<RejectCallback>>(aOnReject), + std::make_tuple(std::forward<Args>(aArgs)...), std::make_tuple()); +} + +template <typename ResolveCallback, typename RejectCallback, typename... Args> +Promise::ThenResult<ResolveCallback, Args...> +Promise::ThenCatchWithCycleCollectedArgs(ResolveCallback&& aOnResolve, + RejectCallback&& aOnReject, + Args&&... aArgs) { + return ThenCatchWithCycleCollectedArgsImpl(Some(aOnResolve), Some(aOnReject), + std::forward<Args>(aArgs)...); +} + +template <typename Callback, typename... Args> +Promise::ThenResult<Callback, Args...> Promise::ThenWithCycleCollectedArgs( + Callback&& aOnResolve, Args&&... aArgs) { + return ThenCatchWithCycleCollectedArgsImpl(Some(aOnResolve), + Maybe<Callback>(Nothing()), + std::forward<Args>(aArgs)...); +} + +template <typename Callback, typename... Args> +Promise::ThenResult<Callback, Args...> Promise::CatchWithCycleCollectedArgs( + Callback&& aOnReject, Args&&... aArgs) { + return ThenCatchWithCycleCollectedArgsImpl(Maybe<Callback>(Nothing()), + Some(aOnReject), + std::forward<Args>(aArgs)...); +} + +template <typename ResolveCallback, typename RejectCallback, typename ArgsTuple, + typename JSArgsTuple> +Result<RefPtr<Promise>, nsresult> Promise::ThenCatchWithCycleCollectedArgsJS( + ResolveCallback&& aOnResolve, RejectCallback&& aOnReject, ArgsTuple&& aArgs, + JSArgsTuple&& aJSArgs) { + return ThenCatchWithCycleCollectedArgsJSImpl( + Some(aOnResolve), Some(aOnReject), std::forward<ArgsTuple>(aArgs), + std::forward<JSArgsTuple>(aJSArgs)); +} + +template <typename Callback, typename ArgsTuple, typename JSArgsTuple> +Result<RefPtr<Promise>, nsresult> Promise::ThenWithCycleCollectedArgsJS( + Callback&& aOnResolve, ArgsTuple&& aArgs, JSArgsTuple&& aJSArgs) { + return ThenCatchWithCycleCollectedArgsJSImpl( + Some(aOnResolve), Maybe<Callback>(Nothing()), + std::forward<ArgsTuple>(aArgs), std::forward<JSArgsTuple>(aJSArgs)); +} + +template <typename ResolveCallback, typename RejectCallback, typename... Args> +void Promise::AddCallbacksWithCycleCollectedArgs(ResolveCallback&& aOnResolve, + RejectCallback&& aOnReject, + Args&&... aArgs) { + auto onResolve = + [aOnResolve](JSContext* aCx, JS::Handle<JS::Value> value, + ErrorResult& aRv, + StorageType<Args>&&... aArgs) -> already_AddRefed<Promise> { + aOnResolve(aCx, value, aRv, aArgs...); + return nullptr; + }; + auto onReject = + [aOnReject](JSContext* aCx, JS::Handle<JS::Value> value, ErrorResult& aRv, + StorageType<Args>&&... aArgs) -> already_AddRefed<Promise> { + aOnReject(aCx, value, aRv, aArgs...); + return nullptr; + }; + + // Note: explicit template parameters for clang<7/gcc<8 without "Template + // argument deduction for class templates" support + AppendNativeHandler( + new NativeThenHandler<decltype(onResolve), decltype(onReject), + std::tuple<Args...>, std::tuple<>>( + nullptr, Some(onResolve), Some(onReject), + std::make_tuple(std::forward<Args>(aArgs)...), std::make_tuple())); +} + +} // namespace mozilla::dom + +#endif // mozilla_dom_Promise_inl_h diff --git a/dom/promise/Promise.cpp b/dom/promise/Promise.cpp new file mode 100644 index 0000000000..fb4989c43d --- /dev/null +++ b/dom/promise/Promise.cpp @@ -0,0 +1,1129 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "mozilla/dom/Promise-inl.h" + +#include "js/Debug.h" + +#include "mozilla/Atomics.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/CycleCollectedJSContext.h" +#include "mozilla/HoldDropJSObjects.h" +#include "mozilla/OwningNonNull.h" +#include "mozilla/Preferences.h" +#include "mozilla/ResultExtensions.h" +#include "mozilla/Unused.h" + +#include "mozilla/dom/AutoEntryScript.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/DOMException.h" +#include "mozilla/dom/DOMExceptionBinding.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/MediaStreamError.h" +#include "mozilla/dom/PromiseBinding.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/UserActivation.h" +#include "mozilla/dom/WorkerPrivate.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/dom/WorkerRef.h" +#include "mozilla/dom/WorkletImpl.h" +#include "mozilla/dom/WorkletGlobalScope.h" + +#include "jsfriendapi.h" +#include "js/Exception.h" // JS::ExceptionStack +#include "js/Object.h" // JS::GetCompartment +#include "js/StructuredClone.h" +#include "nsContentUtils.h" +#include "nsCycleCollectionParticipant.h" +#include "nsDebug.h" +#include "nsGlobalWindowInner.h" +#include "nsIScriptObjectPrincipal.h" +#include "nsJSEnvironment.h" +#include "nsJSPrincipals.h" +#include "nsJSUtils.h" +#include "nsPIDOMWindow.h" +#include "PromiseDebugging.h" +#include "PromiseNativeHandler.h" +#include "PromiseWorkerProxy.h" +#include "WrapperFactory.h" +#include "xpcpublic.h" +#include "xpcprivate.h" + +namespace mozilla::dom { + +// Promise + +NS_IMPL_CYCLE_COLLECTION_SINGLE_ZONE_SCRIPT_HOLDER_CLASS(Promise) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Promise) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal) + NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR + tmp->mPromiseObj = nullptr; +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Promise) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Promise) + // If you add new JS member variables, you may need to stop using + // NS_IMPL_CYCLE_COLLECTION_SINGLE_ZONE_SCRIPT_HOLDER_CLASS. + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mPromiseObj); +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +Promise::Promise(nsIGlobalObject* aGlobal) + : mGlobal(aGlobal), mPromiseObj(nullptr) { + MOZ_ASSERT(mGlobal); + + mozilla::HoldJSObjects(this); +} + +Promise::~Promise() { mozilla::DropJSObjects(this); } + +// static +already_AddRefed<Promise> Promise::Create( + nsIGlobalObject* aGlobal, ErrorResult& aRv, + PropagateUserInteraction aPropagateUserInteraction) { + if (!aGlobal) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + RefPtr<Promise> p = new Promise(aGlobal); + p->CreateWrapper(aRv, aPropagateUserInteraction); + if (aRv.Failed()) { + return nullptr; + } + return p.forget(); +} + +// static +already_AddRefed<Promise> Promise::CreateInfallible( + nsIGlobalObject* aGlobal, + PropagateUserInteraction aPropagateUserInteraction) { + MOZ_ASSERT(aGlobal); + RefPtr<Promise> p = new Promise(aGlobal); + IgnoredErrorResult rv; + p->CreateWrapper(rv, aPropagateUserInteraction); + if (rv.Failed() && rv.ErrorCodeIs(NS_ERROR_OUT_OF_MEMORY)) { + MOZ_CRASH("Out of memory"); + } + + // We may have failed to init the wrapper here, because nsIGlobalObject had + // null GlobalJSObject. In that case we consider the JS realm is dead, which + // means: + // 1. This promise can't be settled. + // 2. Nothing can subscribe this promise anymore from that realm. + // Such condition makes this promise a no-op object. + (void)NS_WARN_IF(!p->PromiseObj()); + + return p.forget(); +} + +bool Promise::MaybePropagateUserInputEventHandling() { + MOZ_ASSERT(mPromiseObj, + "Should be called only if the wrapper is successfully created"); + JS::PromiseUserInputEventHandlingState state = + UserActivation::IsHandlingUserInput() + ? JS::PromiseUserInputEventHandlingState::HadUserInteractionAtCreation + : JS::PromiseUserInputEventHandlingState:: + DidntHaveUserInteractionAtCreation; + JS::Rooted<JSObject*> p(RootingCx(), mPromiseObj); + return JS::SetPromiseUserInputEventHandlingState(p, state); +} + +// static +already_AddRefed<Promise> Promise::Resolve( + nsIGlobalObject* aGlobal, JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv, PropagateUserInteraction aPropagateUserInteraction) { + JSAutoRealm ar(aCx, aGlobal->GetGlobalJSObject()); + JS::Rooted<JSObject*> p(aCx, JS::CallOriginalPromiseResolve(aCx, aValue)); + if (!p) { + aRv.NoteJSContextException(aCx); + return nullptr; + } + + return CreateFromExisting(aGlobal, p, aPropagateUserInteraction); +} + +// static +already_AddRefed<Promise> Promise::Reject(nsIGlobalObject* aGlobal, + JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + JSAutoRealm ar(aCx, aGlobal->GetGlobalJSObject()); + JS::Rooted<JSObject*> p(aCx, JS::CallOriginalPromiseReject(aCx, aValue)); + if (!p) { + aRv.NoteJSContextException(aCx); + return nullptr; + } + + // This promise will never be resolved, so we pass + // eDontPropagateUserInteraction for aPropagateUserInteraction + // unconditionally. + return CreateFromExisting(aGlobal, p, eDontPropagateUserInteraction); +} + +// static +already_AddRefed<Promise> Promise::All( + JSContext* aCx, const nsTArray<RefPtr<Promise>>& aPromiseList, + ErrorResult& aRv, PropagateUserInteraction aPropagateUserInteraction) { + JS::Rooted<JSObject*> globalObj(aCx, JS::CurrentGlobalOrNull(aCx)); + if (!globalObj) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(globalObj); + if (!global) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + JS::RootedVector<JSObject*> promises(aCx); + if (!promises.reserve(aPromiseList.Length())) { + aRv.NoteJSContextException(aCx); + return nullptr; + } + + for (const auto& promise : aPromiseList) { + JS::Rooted<JSObject*> promiseObj(aCx, promise->PromiseObj()); + if (!promiseObj) { + // No-op object will never settle, so we return a no-op Promise here, + // which is equivalent of returning the existing no-op one. + return do_AddRef(promise); + } + // Just in case, make sure these are all in the context compartment. + if (!JS_WrapObject(aCx, &promiseObj)) { + aRv.NoteJSContextException(aCx); + return nullptr; + } + promises.infallibleAppend(promiseObj); + } + + JS::Rooted<JSObject*> result(aCx, JS::GetWaitForAllPromise(aCx, promises)); + if (!result) { + aRv.NoteJSContextException(aCx); + return nullptr; + } + + return CreateFromExisting(global, result, aPropagateUserInteraction); +} + +void Promise::Then(JSContext* aCx, + // aCalleeGlobal may not be in the compartment of aCx, when + // called over Xrays. + JS::Handle<JSObject*> aCalleeGlobal, + AnyCallback* aResolveCallback, AnyCallback* aRejectCallback, + JS::MutableHandle<JS::Value> aRetval, ErrorResult& aRv) { + NS_ASSERT_OWNINGTHREAD(Promise); + + // Let's hope this does the right thing with Xrays... Ensure everything is + // just in the caller compartment; that ought to do the trick. In theory we + // should consider aCalleeGlobal, but in practice our only caller is + // DOMRequest::Then, which is not working with a Promise subclass, so things + // should be OK. + JS::Rooted<JSObject*> promise(aCx, PromiseObj()); + if (!promise) { + // This promise is no-op, so do nothing. + return; + } + + if (!JS_WrapObject(aCx, &promise)) { + aRv.NoteJSContextException(aCx); + return; + } + + JS::Rooted<JSObject*> resolveCallback(aCx); + if (aResolveCallback) { + resolveCallback = aResolveCallback->CallbackOrNull(); + if (!JS_WrapObject(aCx, &resolveCallback)) { + aRv.NoteJSContextException(aCx); + return; + } + } + + JS::Rooted<JSObject*> rejectCallback(aCx); + if (aRejectCallback) { + rejectCallback = aRejectCallback->CallbackOrNull(); + if (!JS_WrapObject(aCx, &rejectCallback)) { + aRv.NoteJSContextException(aCx); + return; + } + } + + JS::Rooted<JSObject*> retval(aCx); + retval = JS::CallOriginalPromiseThen(aCx, promise, resolveCallback, + rejectCallback); + if (!retval) { + aRv.NoteJSContextException(aCx); + return; + } + + aRetval.setObject(*retval); +} + +static void SettlePromise(Promise* aSettlingPromise, Promise* aCallbackPromise, + ErrorResult& aRv) { + if (!aSettlingPromise) { + return; + } + if (aRv.IsUncatchableException()) { + return; + } + if (aRv.Failed()) { + aSettlingPromise->MaybeReject(std::move(aRv)); + return; + } + if (aCallbackPromise) { + aSettlingPromise->MaybeResolve(aCallbackPromise); + } else { + aSettlingPromise->MaybeResolveWithUndefined(); + } +} + +void PromiseNativeThenHandlerBase::ResolvedCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) { + if (!HasResolvedCallback()) { + mPromise->MaybeResolve(aValue); + return; + } + RefPtr<Promise> promise = CallResolveCallback(aCx, aValue, aRv); + SettlePromise(mPromise, promise, aRv); +} + +void PromiseNativeThenHandlerBase::RejectedCallback( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) { + if (!HasRejectedCallback()) { + mPromise->MaybeReject(aValue); + return; + } + RefPtr<Promise> promise = CallRejectCallback(aCx, aValue, aRv); + SettlePromise(mPromise, promise, aRv); +} + +NS_IMPL_CYCLE_COLLECTION_CLASS(PromiseNativeThenHandlerBase) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PromiseNativeThenHandlerBase) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPromise) + tmp->Traverse(cb); +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PromiseNativeThenHandlerBase) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mPromise) + tmp->Unlink(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PromiseNativeThenHandlerBase) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(PromiseNativeThenHandlerBase) + tmp->Trace(aCallbacks, aClosure); +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PromiseNativeThenHandlerBase) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PromiseNativeThenHandlerBase) + +Result<RefPtr<Promise>, nsresult> Promise::ThenWithoutCycleCollection( + const std::function<already_AddRefed<Promise>( + JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv)>& + aCallback) { + return ThenWithCycleCollectedArgs(aCallback); +} + +void Promise::CreateWrapper( + ErrorResult& aRv, PropagateUserInteraction aPropagateUserInteraction) { + AutoJSAPI jsapi; + if (!jsapi.Init(mGlobal)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return; + } + JSContext* cx = jsapi.cx(); + mPromiseObj = JS::NewPromiseObject(cx, nullptr); + if (!mPromiseObj) { + JS_ClearPendingException(cx); + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + if (aPropagateUserInteraction == ePropagateUserInteraction) { + Unused << MaybePropagateUserInputEventHandling(); + } +} + +void Promise::MaybeResolve(JSContext* aCx, JS::Handle<JS::Value> aValue) { + NS_ASSERT_OWNINGTHREAD(Promise); + + JS::Rooted<JSObject*> p(aCx, PromiseObj()); + if (!p || !JS::ResolvePromise(aCx, p, aValue)) { + // Now what? There's nothing sane to do here. + JS_ClearPendingException(aCx); + } +} + +void Promise::MaybeReject(JSContext* aCx, JS::Handle<JS::Value> aValue) { + NS_ASSERT_OWNINGTHREAD(Promise); + + JS::Rooted<JSObject*> p(aCx, PromiseObj()); + if (!p || !JS::RejectPromise(aCx, p, aValue)) { + // Now what? There's nothing sane to do here. + JS_ClearPendingException(aCx); + } +} + +#define SLOT_NATIVEHANDLER 0 +#define SLOT_NATIVEHANDLER_TASK 1 + +enum class NativeHandlerTask : int32_t { Resolve, Reject }; + +MOZ_CAN_RUN_SCRIPT +static bool NativeHandlerCallback(JSContext* aCx, unsigned aArgc, + JS::Value* aVp) { + JS::CallArgs args = CallArgsFromVp(aArgc, aVp); + + JS::Value v = + js::GetFunctionNativeReserved(&args.callee(), SLOT_NATIVEHANDLER); + MOZ_ASSERT(v.isObject()); + + JS::Rooted<JSObject*> obj(aCx, &v.toObject()); + PromiseNativeHandler* handler = nullptr; + if (NS_FAILED(UNWRAP_OBJECT(PromiseNativeHandler, &obj, handler))) { + return Throw(aCx, NS_ERROR_UNEXPECTED); + } + + v = js::GetFunctionNativeReserved(&args.callee(), SLOT_NATIVEHANDLER_TASK); + NativeHandlerTask task = static_cast<NativeHandlerTask>(v.toInt32()); + + ErrorResult rv; + if (task == NativeHandlerTask::Resolve) { + // handler is kept alive by "obj" on the stack. + MOZ_KnownLive(handler)->ResolvedCallback(aCx, args.get(0), rv); + } else { + MOZ_ASSERT(task == NativeHandlerTask::Reject); + // handler is kept alive by "obj" on the stack. + MOZ_KnownLive(handler)->RejectedCallback(aCx, args.get(0), rv); + } + + return !rv.MaybeSetPendingException(aCx); +} + +static JSObject* CreateNativeHandlerFunction(JSContext* aCx, + JS::Handle<JSObject*> aHolder, + NativeHandlerTask aTask) { + JSFunction* func = js::NewFunctionWithReserved(aCx, NativeHandlerCallback, + /* nargs = */ 1, + /* flags = */ 0, nullptr); + if (!func) { + return nullptr; + } + + JS::Rooted<JSObject*> obj(aCx, JS_GetFunctionObject(func)); + + JS::AssertObjectIsNotGray(aHolder); + js::SetFunctionNativeReserved(obj, SLOT_NATIVEHANDLER, + JS::ObjectValue(*aHolder)); + js::SetFunctionNativeReserved(obj, SLOT_NATIVEHANDLER_TASK, + JS::Int32Value(static_cast<int32_t>(aTask))); + + return obj; +} + +namespace { + +class PromiseNativeHandlerShim final : public PromiseNativeHandler { + RefPtr<PromiseNativeHandler> mInner; +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + enum InnerState{ + NotCleared, + ClearedFromResolve, + ClearedFromReject, + ClearedFromCC, + }; + InnerState mState = NotCleared; +#endif + + ~PromiseNativeHandlerShim() = default; + + public: + explicit PromiseNativeHandlerShim(PromiseNativeHandler* aInner) + : mInner(aInner) { + MOZ_DIAGNOSTIC_ASSERT(mInner); + } + + MOZ_CAN_RUN_SCRIPT + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override { +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromResolve); + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromReject); + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromCC); +#else + if (!mInner) { + return; + } +#endif + RefPtr<PromiseNativeHandler> inner = std::move(mInner); + inner->ResolvedCallback(aCx, aValue, aRv); + MOZ_ASSERT(!mInner); +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + mState = ClearedFromResolve; +#endif + } + + MOZ_CAN_RUN_SCRIPT + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override { +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromResolve); + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromReject); + MOZ_DIAGNOSTIC_ASSERT(mState != ClearedFromCC); +#else + if (!mInner) { + return; + } +#endif + RefPtr<PromiseNativeHandler> inner = std::move(mInner); + inner->RejectedCallback(aCx, aValue, aRv); + MOZ_ASSERT(!mInner); +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + mState = ClearedFromReject; +#endif + } + + bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto, + JS::MutableHandle<JSObject*> aWrapper) { + return PromiseNativeHandler_Binding::Wrap(aCx, this, aGivenProto, aWrapper); + } + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(PromiseNativeHandlerShim) +}; + +NS_IMPL_CYCLE_COLLECTION_CLASS(PromiseNativeHandlerShim) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PromiseNativeHandlerShim) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mInner) +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + tmp->mState = ClearedFromCC; +#endif +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PromiseNativeHandlerShim) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInner) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PromiseNativeHandlerShim) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PromiseNativeHandlerShim) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PromiseNativeHandlerShim) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +} // anonymous namespace + +void Promise::AppendNativeHandler(PromiseNativeHandler* aRunnable) { + NS_ASSERT_OWNINGTHREAD(Promise); + + AutoJSAPI jsapi; + if (NS_WARN_IF(!mPromiseObj || !jsapi.Init(mGlobal))) { + // Our API doesn't allow us to return a useful error. Not like this should + // happen anyway. + return; + } + + // The self-hosted promise js may keep the object we pass to it alive + // for quite a while depending on when GC runs. Therefore, pass a shim + // object instead. The shim will free its inner PromiseNativeHandler + // after the promise has settled just like our previous c++ promises did. + RefPtr<PromiseNativeHandlerShim> shim = + new PromiseNativeHandlerShim(aRunnable); + + JSContext* cx = jsapi.cx(); + JS::Rooted<JSObject*> handlerWrapper(cx); + // Note: PromiseNativeHandler is NOT wrappercached. So we can't use + // ToJSValue here, because it will try to do XPConnect wrapping on it, sadly. + if (NS_WARN_IF(!shim->WrapObject(cx, nullptr, &handlerWrapper))) { + // Again, no way to report errors. + jsapi.ClearException(); + return; + } + + JS::Rooted<JSObject*> resolveFunc(cx); + resolveFunc = CreateNativeHandlerFunction(cx, handlerWrapper, + NativeHandlerTask::Resolve); + if (NS_WARN_IF(!resolveFunc)) { + jsapi.ClearException(); + return; + } + + JS::Rooted<JSObject*> rejectFunc(cx); + rejectFunc = CreateNativeHandlerFunction(cx, handlerWrapper, + NativeHandlerTask::Reject); + if (NS_WARN_IF(!rejectFunc)) { + jsapi.ClearException(); + return; + } + + JS::Rooted<JSObject*> promiseObj(cx, PromiseObj()); + if (NS_WARN_IF( + !JS::AddPromiseReactions(cx, promiseObj, resolveFunc, rejectFunc))) { + jsapi.ClearException(); + return; + } +} + +void Promise::HandleException(JSContext* aCx) { + JS::Rooted<JS::Value> exn(aCx); + if (JS_GetPendingException(aCx, &exn)) { + JS_ClearPendingException(aCx); + // Always reject even if this was called in *Resolve. + MaybeReject(aCx, exn); + } +} + +// static +already_AddRefed<Promise> Promise::RejectWithExceptionFromContext( + nsIGlobalObject* aGlobal, JSContext* aCx, ErrorResult& aError) { + JS::Rooted<JS::Value> exn(aCx); + if (!JS_GetPendingException(aCx, &exn)) { + // This is very important: if there is no pending exception here but we're + // ending up in this code, that means the callee threw an uncatchable + // exception. Just propagate that out as-is. + aError.ThrowUncatchableException(); + return nullptr; + } + + JSAutoRealm ar(aCx, aGlobal->GetGlobalJSObject()); + if (!JS_WrapValue(aCx, &exn)) { + // We just give up. + aError.StealExceptionFromJSContext(aCx); + return nullptr; + } + + JS_ClearPendingException(aCx); + + IgnoredErrorResult error; + RefPtr<Promise> promise = Promise::Reject(aGlobal, aCx, exn, error); + if (!promise) { + // We just give up, let's store the exception in the ErrorResult. + aError.ThrowJSException(aCx, exn); + return nullptr; + } + + return promise.forget(); +} + +// static +already_AddRefed<Promise> Promise::CreateFromExisting( + nsIGlobalObject* aGlobal, JS::Handle<JSObject*> aPromiseObj, + PropagateUserInteraction aPropagateUserInteraction) { + MOZ_ASSERT(JS::GetCompartment(aGlobal->GetGlobalJSObjectPreserveColor()) == + JS::GetCompartment(aPromiseObj)); + RefPtr<Promise> p = new Promise(aGlobal); + p->mPromiseObj = aPromiseObj; + if (aPropagateUserInteraction == ePropagateUserInteraction && + !p->MaybePropagateUserInputEventHandling()) { + return nullptr; + } + return p.forget(); +} + +void Promise::MaybeResolveWithUndefined() { + NS_ASSERT_OWNINGTHREAD(Promise); + + MaybeResolve(JS::UndefinedHandleValue); +} + +void Promise::MaybeReject(const RefPtr<MediaStreamError>& aArg) { + NS_ASSERT_OWNINGTHREAD(Promise); + + MaybeSomething(aArg, &Promise::MaybeReject); +} + +void Promise::MaybeRejectWithUndefined() { + NS_ASSERT_OWNINGTHREAD(Promise); + + MaybeSomething(JS::UndefinedHandleValue, &Promise::MaybeReject); +} + +void Promise::ReportRejectedPromise(JSContext* aCx, + JS::Handle<JSObject*> aPromise) { + MOZ_ASSERT(!js::IsWrapper(aPromise)); + + MOZ_ASSERT(JS::GetPromiseState(aPromise) == JS::PromiseState::Rejected); + + bool isChrome = false; + uint64_t innerWindowID = 0; + nsGlobalWindowInner* winForDispatch = nullptr; + if (MOZ_LIKELY(NS_IsMainThread())) { + isChrome = nsContentUtils::ObjectPrincipal(aPromise)->IsSystemPrincipal(); + + if (nsGlobalWindowInner* win = xpc::WindowGlobalOrNull(aPromise)) { + winForDispatch = win; + innerWindowID = win->WindowID(); + } else if (nsGlobalWindowInner* win = xpc::SandboxWindowOrNull( + JS::GetNonCCWObjectGlobal(aPromise), aCx)) { + // Don't dispatch rejections from the sandbox to the associated DOM + // window. + innerWindowID = win->WindowID(); + } + } else if (const WorkerPrivate* wp = GetCurrentThreadWorkerPrivate()) { + isChrome = wp->UsesSystemPrincipal(); + innerWindowID = wp->WindowID(); + } else if (nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(aPromise)) { + if (nsCOMPtr<WorkletGlobalScope> workletGlobal = + do_QueryInterface(global)) { + WorkletImpl* impl = workletGlobal->Impl(); + isChrome = impl->PrincipalInfo().type() == + mozilla::ipc::PrincipalInfo::TSystemPrincipalInfo; + innerWindowID = impl->LoadInfo().InnerWindowID(); + } + } + + JS::Rooted<JS::Value> result(aCx, JS::GetPromiseResult(aPromise)); + // resolutionSite can be null if async stacks are disabled. + JS::Rooted<JSObject*> resolutionSite(aCx, + JS::GetPromiseResolutionSite(aPromise)); + + // We're inspecting the rejection value only to report it to the console, and + // we do so without side-effects, so we can safely unwrap it without regard to + // the privileges of the Promise object that holds it. If we don't unwrap + // before trying to create the error report, we wind up reporting any + // cross-origin objects as "uncaught exception: Object". + RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport(); + { + Maybe<JSAutoRealm> ar; + JS::Rooted<JS::Value> unwrapped(aCx, result); + if (unwrapped.isObject()) { + unwrapped.setObject(*js::UncheckedUnwrap(&unwrapped.toObject())); + ar.emplace(aCx, &unwrapped.toObject()); + } + + JS::ErrorReportBuilder report(aCx); + RefPtr<Exception> exn; + if (unwrapped.isObject() && + (NS_SUCCEEDED(UNWRAP_OBJECT(DOMException, &unwrapped, exn)) || + NS_SUCCEEDED(UNWRAP_OBJECT(Exception, &unwrapped, exn)))) { + xpcReport->Init(aCx, exn, isChrome, innerWindowID); + } else { + // Use the resolution site as the exception stack + JS::ExceptionStack exnStack(aCx, unwrapped, resolutionSite); + if (!report.init(aCx, exnStack, JS::ErrorReportBuilder::NoSideEffects)) { + JS_ClearPendingException(aCx); + return; + } + + xpcReport->Init(report.report(), report.toStringResult().c_str(), + isChrome, innerWindowID); + } + } + + // Used to initialize the similarly named nsISciptError attribute. + xpcReport->mIsPromiseRejection = true; + + // Now post an event to do the real reporting async + RefPtr<AsyncErrorReporter> event = new AsyncErrorReporter(xpcReport); + if (winForDispatch) { + if (!winForDispatch->IsDying()) { + // Exceptions from a dying window will cause the window to leak. + event->SetException(aCx, result); + if (resolutionSite) { + event->SerializeStack(aCx, resolutionSite); + } + } + winForDispatch->Dispatch(event.forget()); + } else { + NS_DispatchToMainThread(event); + } +} + +void Promise::MaybeResolveWithClone(JSContext* aCx, + JS::Handle<JS::Value> aValue) { + JS::Rooted<JSObject*> sourceScope(aCx, JS::CurrentGlobalOrNull(aCx)); + AutoEntryScript aes(GetParentObject(), "Promise resolution"); + JSContext* cx = aes.cx(); + JS::Rooted<JS::Value> value(cx, aValue); + + xpc::StackScopedCloneOptions options; + options.wrapReflectors = true; + if (!StackScopedClone(cx, options, sourceScope, &value)) { + HandleException(cx); + return; + } + MaybeResolve(aCx, value); +} + +void Promise::MaybeRejectWithClone(JSContext* aCx, + JS::Handle<JS::Value> aValue) { + JS::Rooted<JSObject*> sourceScope(aCx, JS::CurrentGlobalOrNull(aCx)); + AutoEntryScript aes(GetParentObject(), "Promise rejection"); + JSContext* cx = aes.cx(); + JS::Rooted<JS::Value> value(cx, aValue); + + xpc::StackScopedCloneOptions options; + options.wrapReflectors = true; + if (!StackScopedClone(cx, options, sourceScope, &value)) { + HandleException(cx); + return; + } + MaybeReject(aCx, value); +} + +// A WorkerRunnable to resolve/reject the Promise on the worker thread. +// Calling thread MUST hold PromiseWorkerProxy's mutex before creating this. +class PromiseWorkerProxyRunnable final : public WorkerRunnable { + public: + PromiseWorkerProxyRunnable(PromiseWorkerProxy* aPromiseWorkerProxy, + PromiseWorkerProxy::RunCallbackFunc aFunc) + : WorkerRunnable(aPromiseWorkerProxy->GetWorkerPrivate(), + "PromiseWorkerProxyRunnable", WorkerThread), + mPromiseWorkerProxy(aPromiseWorkerProxy), + mFunc(aFunc) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mPromiseWorkerProxy); + } + + virtual bool WorkerRun(JSContext* aCx, + WorkerPrivate* aWorkerPrivate) override { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(aWorkerPrivate == mWorkerPrivate); + + MOZ_ASSERT(mPromiseWorkerProxy); + RefPtr<Promise> workerPromise = mPromiseWorkerProxy->GetWorkerPromise(); + // Once Worker had already started shutdown, workerPromise would be nullptr + if (!workerPromise) { + return true; + } + + // Here we convert the buffer to a JS::Value. + JS::Rooted<JS::Value> value(aCx); + if (!mPromiseWorkerProxy->Read(aCx, &value)) { + JS_ClearPendingException(aCx); + return false; + } + + (workerPromise->*mFunc)(aCx, value); + + // Release the Promise because it has been resolved/rejected for sure. + mPromiseWorkerProxy->CleanUp(); + return true; + } + + protected: + ~PromiseWorkerProxyRunnable() = default; + + private: + RefPtr<PromiseWorkerProxy> mPromiseWorkerProxy; + + // Function pointer for calling Promise::{ResolveInternal,RejectInternal}. + PromiseWorkerProxy::RunCallbackFunc mFunc; +}; + +/* static */ +already_AddRefed<PromiseWorkerProxy> PromiseWorkerProxy::Create( + WorkerPrivate* aWorkerPrivate, Promise* aWorkerPromise, + const PromiseWorkerProxyStructuredCloneCallbacks* aCb) { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(aWorkerPromise); + MOZ_ASSERT_IF(aCb, !!aCb->Write && !!aCb->Read); + + RefPtr<PromiseWorkerProxy> proxy = + new PromiseWorkerProxy(aWorkerPromise, aCb); + + // Maintain a reference so that we have a valid object to clean up when + // removing the feature. + proxy.get()->AddRef(); + + // We do this to make sure the worker thread won't shut down before the + // promise is resolved/rejected on the worker thread. + RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create( + aWorkerPrivate, "PromiseWorkerProxy", [proxy]() { proxy->CleanUp(); }); + + if (NS_WARN_IF(!workerRef)) { + // Probably the worker is terminating. We cannot complete the operation + // and we have to release all the resources. CleanUp releases the extra + // ref, too + proxy->CleanUp(); + return nullptr; + } + + proxy->mWorkerRef = new ThreadSafeWorkerRef(workerRef); + + return proxy.forget(); +} + +NS_IMPL_ISUPPORTS0(PromiseWorkerProxy) + +PromiseWorkerProxy::PromiseWorkerProxy( + Promise* aWorkerPromise, + const PromiseWorkerProxyStructuredCloneCallbacks* aCallbacks) + : mWorkerPromise(aWorkerPromise), + mCleanedUp(false), + mCallbacks(aCallbacks), + mCleanUpLock("cleanUpLock") {} + +PromiseWorkerProxy::~PromiseWorkerProxy() { + MOZ_ASSERT(mCleanedUp); + MOZ_ASSERT(!mWorkerPromise); + MOZ_ASSERT(!mWorkerRef); +} + +WorkerPrivate* PromiseWorkerProxy::GetWorkerPrivate() const { +#ifdef DEBUG + if (NS_IsMainThread()) { + mCleanUpLock.AssertCurrentThreadOwns(); + } +#endif + // Safe to check this without a lock since we assert lock ownership on the + // main thread above. + MOZ_ASSERT(!mCleanedUp); + MOZ_ASSERT(mWorkerRef); + + return mWorkerRef->Private(); +} + +bool PromiseWorkerProxy::OnWritingThread() const { + return IsCurrentThreadRunningWorker(); +} + +Promise* PromiseWorkerProxy::GetWorkerPromise() const { + MOZ_ASSERT(IsCurrentThreadRunningWorker()); + return mWorkerPromise; +} + +void PromiseWorkerProxy::RunCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + RunCallbackFunc aFunc) { + MOZ_ASSERT(NS_IsMainThread()); + + MutexAutoLock lock(Lock()); + // If the worker thread's been cancelled we don't need to resolve the Promise. + if (CleanedUp()) { + return; + } + + // The |aValue| is written into the StructuredCloneHolderBase. + if (!Write(aCx, aValue)) { + JS_ClearPendingException(aCx); + MOZ_ASSERT(false, + "cannot serialize the value with the StructuredCloneAlgorithm!"); + } + + RefPtr<PromiseWorkerProxyRunnable> runnable = + new PromiseWorkerProxyRunnable(this, aFunc); + + runnable->Dispatch(); +} + +void PromiseWorkerProxy::ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + RunCallback(aCx, aValue, &Promise::MaybeResolve); +} + +void PromiseWorkerProxy::RejectedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + RunCallback(aCx, aValue, &Promise::MaybeReject); +} + +void PromiseWorkerProxy::CleanUp() { + // Can't release Mutex while it is still locked, so scope the lock. + { + MutexAutoLock lock(Lock()); + + if (CleanedUp()) { + return; + } + + // We can be called if we failed to get a WorkerRef + if (mWorkerRef) { + mWorkerRef->Private()->AssertIsOnWorkerThread(); + } + + // Release the Promise and remove the PromiseWorkerProxy from the holders of + // the worker thread since the Promise has been resolved/rejected or the + // worker thread has been cancelled. + mCleanedUp = true; + mWorkerPromise = nullptr; + mWorkerRef = nullptr; + + // Clear the StructuredCloneHolderBase class. + Clear(); + } + Release(); +} + +JSObject* PromiseWorkerProxy::CustomReadHandler( + JSContext* aCx, JSStructuredCloneReader* aReader, + const JS::CloneDataPolicy& aCloneDataPolicy, uint32_t aTag, + uint32_t aIndex) { + if (NS_WARN_IF(!mCallbacks)) { + return nullptr; + } + + return mCallbacks->Read(aCx, aReader, this, aTag, aIndex); +} + +bool PromiseWorkerProxy::CustomWriteHandler(JSContext* aCx, + JSStructuredCloneWriter* aWriter, + JS::Handle<JSObject*> aObj, + bool* aSameProcessScopeRequired) { + if (NS_WARN_IF(!mCallbacks)) { + return false; + } + + return mCallbacks->Write(aCx, aWriter, this, aObj); +} + +// Specializations of MaybeRejectBrokenly we actually support. +template <> +void Promise::MaybeRejectBrokenly(const RefPtr<DOMException>& aArg) { + MaybeSomething(aArg, &Promise::MaybeReject); +} +template <> +void Promise::MaybeRejectBrokenly(const nsAString& aArg) { + MaybeSomething(aArg, &Promise::MaybeReject); +} + +Promise::PromiseState Promise::State() const { + JS::Rooted<JSObject*> p(RootingCx(), PromiseObj()); + const JS::PromiseState state = JS::GetPromiseState(p); + + if (state == JS::PromiseState::Fulfilled) { + return PromiseState::Resolved; + } + + if (state == JS::PromiseState::Rejected) { + return PromiseState::Rejected; + } + + return PromiseState::Pending; +} + +bool Promise::SetSettledPromiseIsHandled() { + if (!mPromiseObj) { + // Do nothing as it's a no-op promise + return false; + } + AutoAllowLegacyScriptExecution exemption; + AutoEntryScript aes(mGlobal, "Set settled promise handled"); + JSContext* cx = aes.cx(); + JS::Rooted<JSObject*> promiseObj(cx, mPromiseObj); + return JS::SetSettledPromiseIsHandled(cx, promiseObj); +} + +bool Promise::SetAnyPromiseIsHandled() { + if (!mPromiseObj) { + // Do nothing as it's a no-op promise + return false; + } + AutoAllowLegacyScriptExecution exemption; + AutoEntryScript aes(mGlobal, "Set any promise handled"); + JSContext* cx = aes.cx(); + JS::Rooted<JSObject*> promiseObj(cx, mPromiseObj); + return JS::SetAnyPromiseIsHandled(cx, promiseObj); +} + +/* static */ +already_AddRefed<Promise> Promise::CreateResolvedWithUndefined( + nsIGlobalObject* global, ErrorResult& aRv) { + RefPtr<Promise> returnPromise = Promise::Create(global, aRv); + if (aRv.Failed()) { + return nullptr; + } + returnPromise->MaybeResolveWithUndefined(); + return returnPromise.forget(); +} + +already_AddRefed<Promise> Promise::CreateRejected( + nsIGlobalObject* aGlobal, JS::Handle<JS::Value> aRejectionError, + ErrorResult& aRv) { + RefPtr<Promise> promise = Promise::Create(aGlobal, aRv); + if (aRv.Failed()) { + return nullptr; + } + promise->MaybeReject(aRejectionError); + return promise.forget(); +} + +already_AddRefed<Promise> Promise::CreateRejectedWithTypeError( + nsIGlobalObject* aGlobal, const nsACString& aMessage, ErrorResult& aRv) { + RefPtr<Promise> returnPromise = Promise::Create(aGlobal, aRv); + if (aRv.Failed()) { + return nullptr; + } + returnPromise->MaybeRejectWithTypeError(aMessage); + return returnPromise.forget(); +} + +already_AddRefed<Promise> Promise::CreateRejectedWithErrorResult( + nsIGlobalObject* aGlobal, ErrorResult& aRejectionError) { + RefPtr<Promise> returnPromise = Promise::Create(aGlobal, IgnoreErrors()); + if (!returnPromise) { + return nullptr; + } + returnPromise->MaybeReject(std::move(aRejectionError)); + return returnPromise.forget(); +} + +nsresult Promise::TryExtractNSResultFromRejectionValue( + JS::Handle<JS::Value> aValue) { + if (aValue.isInt32()) { + return nsresult(aValue.toInt32()); + } + + if (aValue.isObject()) { + RefPtr<DOMException> domException; + UNWRAP_OBJECT(DOMException, aValue, domException); + if (domException) { + return domException->GetResult(); + } + } + + return NS_ERROR_DOM_NOT_NUMBER_ERR; +} + +} // namespace mozilla::dom + +extern "C" { + +// These functions are used in the implementation of ffi bindings for +// dom::Promise from Rust. + +void DomPromise_AddRef(mozilla::dom::Promise* aPromise) { + MOZ_ASSERT(aPromise); + aPromise->AddRef(); +} + +void DomPromise_Release(mozilla::dom::Promise* aPromise) { + MOZ_ASSERT(aPromise); + aPromise->Release(); +} + +#define DOM_PROMISE_FUNC_WITH_VARIANT(name, func) \ + void name(mozilla::dom::Promise* aPromise, nsIVariant* aVariant) { \ + MOZ_ASSERT(aPromise); \ + MOZ_ASSERT(aVariant); \ + mozilla::dom::AutoEntryScript aes(aPromise->GetGlobalObject(), \ + "Promise resolution or rejection"); \ + JSContext* cx = aes.cx(); \ + \ + JS::Rooted<JS::Value> val(cx); \ + nsresult rv = NS_OK; \ + if (!XPCVariant::VariantDataToJS(cx, aVariant, &rv, &val)) { \ + aPromise->MaybeRejectWithTypeError( \ + "Failed to convert nsIVariant to JS"); \ + return; \ + } \ + aPromise->func(val); \ + } + +DOM_PROMISE_FUNC_WITH_VARIANT(DomPromise_RejectWithVariant, MaybeReject) +DOM_PROMISE_FUNC_WITH_VARIANT(DomPromise_ResolveWithVariant, MaybeResolve) + +#undef DOM_PROMISE_FUNC_WITH_VARIANT +} diff --git a/dom/promise/Promise.h b/dom/promise/Promise.h new file mode 100644 index 0000000000..76c657d5a6 --- /dev/null +++ b/dom/promise/Promise.h @@ -0,0 +1,460 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef mozilla_dom_Promise_h +#define mozilla_dom_Promise_h + +#include <functional> +#include <type_traits> +#include <utility> +#include "ErrorList.h" +#include "js/RootingAPI.h" +#include "js/TypeDecls.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/RefPtr.h" +#include "mozilla/Result.h" +#include "mozilla/WeakPtr.h" +#include "mozilla/dom/AutoEntryScript.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/ToJSValue.h" +#include "nsCycleCollectionParticipant.h" +#include "nsError.h" +#include "nsISupports.h" +#include "nsString.h" + +class nsCycleCollectionTraversalCallback; +class nsIGlobalObject; + +namespace JS { +class Value; +} + +namespace mozilla::dom { + +class AnyCallback; +class MediaStreamError; +class PromiseInit; +class PromiseNativeHandler; +class PromiseDebugging; + +class Promise : public SupportsWeakPtr { + friend class PromiseTask; + friend class PromiseWorkerProxy; + friend class PromiseWorkerProxyRunnable; + + public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(Promise) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(Promise) + + enum PropagateUserInteraction { + eDontPropagateUserInteraction, + ePropagateUserInteraction + }; + + // Promise creation tries to create a JS reflector for the Promise, so is + // fallible. Furthermore, we don't want to do JS-wrapping on a 0-refcount + // object, so we addref before doing that and return the addrefed pointer + // here. + // Pass ePropagateUserInteraction for aPropagateUserInteraction if you want + // the promise resolve handler to be called as if we were handling user + // input events in case we are currently handling user input events. + static already_AddRefed<Promise> Create( + nsIGlobalObject* aGlobal, ErrorResult& aRv, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + // Same as Promise::Create but never throws, but instead: + // 1. Causes crash on OOM (as nearly every other web APIs do) + // 2. Silently creates a no-op Promise if the JS context is shut down + // This can be useful for implementations that produce promises but do not + // care whether the current global is alive to consume them. + // Note that PromiseObj() can return a nullptr if created this way. + static already_AddRefed<Promise> CreateInfallible( + nsIGlobalObject* aGlobal, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + // Reports a rejected Promise by sending an error report. + static void ReportRejectedPromise(JSContext* aCx, + JS::Handle<JSObject*> aPromise); + + using MaybeFunc = void (Promise::*)(JSContext*, JS::Handle<JS::Value>); + + // Helpers for using Promise from C++. + // Most DOM objects are handled already. To add a new type T, add a + // ToJSValue overload in ToJSValue.h. + // aArg is a const reference so we can pass rvalues like integer constants + template <typename T> + void MaybeResolve(T&& aArg) { + MaybeSomething(std::forward<T>(aArg), &Promise::MaybeResolve); + } + + void MaybeResolveWithUndefined(); + + void MaybeReject(JS::Handle<JS::Value> aValue) { + MaybeSomething(aValue, &Promise::MaybeReject); + } + + // This method is deprecated. Consumers should MaybeRejectWithDOMException if + // they are rejecting with a DOMException, or use one of the other + // MaybeReject* methods otherwise. If they have a random nsresult which may + // or may not correspond to a DOMException type, they should consider using an + // appropriate DOMException-type nsresult with an informative message and + // calling MaybeRejectWithDOMException. + inline void MaybeReject(nsresult aArg) { + MOZ_ASSERT(NS_FAILED(aArg)); + MaybeSomething(aArg, &Promise::MaybeReject); + } + + inline void MaybeReject(ErrorResult&& aArg) { + MOZ_ASSERT(aArg.Failed()); + MaybeSomething(std::move(aArg), &Promise::MaybeReject); + // That should have consumed aArg. + MOZ_ASSERT(!aArg.Failed()); + } + + void MaybeReject(const RefPtr<MediaStreamError>& aArg); + + void MaybeRejectWithUndefined(); + + void MaybeResolveWithClone(JSContext* aCx, JS::Handle<JS::Value> aValue); + void MaybeRejectWithClone(JSContext* aCx, JS::Handle<JS::Value> aValue); + + // Facilities for rejecting with various spec-defined exception values. +#define DOMEXCEPTION(name, err) \ + inline void MaybeRejectWith##name(const nsACString& aMessage) { \ + ErrorResult res; \ + res.Throw##name(aMessage); \ + MaybeReject(std::move(res)); \ + } \ + template <int N> \ + void MaybeRejectWith##name(const char(&aMessage)[N]) { \ + MaybeRejectWith##name(nsLiteralCString(aMessage)); \ + } + +#include "mozilla/dom/DOMExceptionNames.h" + +#undef DOMEXCEPTION + + template <ErrNum errorNumber, typename... Ts> + void MaybeRejectWithTypeError(Ts&&... aMessageArgs) { + ErrorResult res; + res.ThrowTypeError<errorNumber>(std::forward<Ts>(aMessageArgs)...); + MaybeReject(std::move(res)); + } + + inline void MaybeRejectWithTypeError(const nsACString& aMessage) { + ErrorResult res; + res.ThrowTypeError(aMessage); + MaybeReject(std::move(res)); + } + + template <int N> + void MaybeRejectWithTypeError(const char (&aMessage)[N]) { + MaybeRejectWithTypeError(nsLiteralCString(aMessage)); + } + + template <ErrNum errorNumber, typename... Ts> + void MaybeRejectWithRangeError(Ts&&... aMessageArgs) { + ErrorResult res; + res.ThrowRangeError<errorNumber>(std::forward<Ts>(aMessageArgs)...); + MaybeReject(std::move(res)); + } + + inline void MaybeRejectWithRangeError(const nsACString& aMessage) { + ErrorResult res; + res.ThrowRangeError(aMessage); + MaybeReject(std::move(res)); + } + + template <int N> + void MaybeRejectWithRangeError(const char (&aMessage)[N]) { + MaybeRejectWithRangeError(nsLiteralCString(aMessage)); + } + + // DO NOT USE MaybeRejectBrokenly with in new code. Promises should be + // rejected with Error instances. + // Note: MaybeRejectBrokenly is a template so we can use it with DOMException + // without instantiating the DOMException specialization of MaybeSomething in + // every translation unit that includes this header, because that would + // require use to include DOMException.h either here or in all those + // translation units. + template <typename T> + void MaybeRejectBrokenly(const T& aArg); // Not implemented by default; see + // specializations in the .cpp for + // the T values we support. + + // Mark a settled promise as already handled so that rejections will not + // be reported as unhandled. + bool SetSettledPromiseIsHandled(); + + // Mark a promise as handled so that rejections will not be reported as + // unhandled. Consider using SetSettledPromiseIsHandled if this promise is + // expected to be settled. + [[nodiscard]] bool SetAnyPromiseIsHandled(); + + // WebIDL + + nsIGlobalObject* GetParentObject() const { return GetGlobalObject(); } + + // Do the equivalent of Promise.resolve in the compartment of aGlobal. The + // compartment of aCx is ignored. Errors are reported on the ErrorResult; if + // aRv comes back !Failed(), this function MUST return a non-null value. + // Pass ePropagateUserInteraction for aPropagateUserInteraction if you want + // the promise resolve handler to be called as if we were handling user + // input events in case we are currently handling user input events. + static already_AddRefed<Promise> Resolve( + nsIGlobalObject* aGlobal, JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + // Do the equivalent of Promise.reject in the compartment of aGlobal. The + // compartment of aCx is ignored. Errors are reported on the ErrorResult; if + // aRv comes back !Failed(), this function MUST return a non-null value. + static already_AddRefed<Promise> Reject(nsIGlobalObject* aGlobal, + JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv); + + template <typename T> + static already_AddRefed<Promise> Reject(nsIGlobalObject* aGlobal, T&& aValue, + ErrorResult& aError) { + AutoJSAPI jsapi; + if (!jsapi.Init(aGlobal)) { + aError.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + JSContext* cx = jsapi.cx(); + JS::Rooted<JS::Value> val(cx); + if (!ToJSValue(cx, std::forward<T>(aValue), &val)) { + return Promise::RejectWithExceptionFromContext(aGlobal, cx, aError); + } + + return Reject(aGlobal, cx, val, aError); + } + + static already_AddRefed<Promise> RejectWithExceptionFromContext( + nsIGlobalObject* aGlobal, JSContext* aCx, ErrorResult& aError); + + // Do the equivalent of Promise.all in the current compartment of aCx. Errors + // are reported on the ErrorResult; if aRv comes back !Failed(), this function + // MUST return a non-null value. + // Pass ePropagateUserInteraction for aPropagateUserInteraction if you want + // the promise resolve handler to be called as if we were handling user + // input events in case we are currently handling user input events. + static already_AddRefed<Promise> All( + JSContext* aCx, const nsTArray<RefPtr<Promise>>& aPromiseList, + ErrorResult& aRv, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + void Then(JSContext* aCx, + // aCalleeGlobal may not be in the compartment of aCx, when called + // over Xrays. + JS::Handle<JSObject*> aCalleeGlobal, AnyCallback* aResolveCallback, + AnyCallback* aRejectCallback, JS::MutableHandle<JS::Value> aRetval, + ErrorResult& aRv); + + template <typename Callback, typename... Args> + using IsHandlerCallback = + std::is_same<already_AddRefed<Promise>, + decltype(std::declval<Callback>()( + (JSContext*)(nullptr), + std::declval<JS::Handle<JS::Value>>(), + std::declval<ErrorResult&>(), std::declval<Args>()...))>; + + template <typename Callback, typename... Args> + using ThenResult = + std::enable_if_t<IsHandlerCallback<Callback, Args...>::value, + Result<RefPtr<Promise>, nsresult>>; + + // Similar to the JavaScript then() function. Accepts two lambda function + // arguments, which it attaches as native resolve/reject handlers, and + // returns a new promise which: + // 1. if the ErrorResult contains an error value, rejects with it. + // 2. else, resolves with a return value. + // + // Any additional arguments passed after the callback functions are stored and + // passed as additional arguments to the functions when it is called. These + // values will participate in cycle collection for the promise handler, and + // therefore may safely form reference cycles with the promise chain. + // + // Any strong references required by the callbacks should be passed in this + // manner, rather than using lambda capture, lambda captures do not support + // cycle collection, and can easily lead to leaks. + template <typename ResolveCallback, typename RejectCallback, typename... Args> + ThenResult<ResolveCallback, Args...> ThenCatchWithCycleCollectedArgs( + ResolveCallback&& aOnResolve, RejectCallback&& aOnReject, + Args&&... aArgs); + + // Same as ThenCatchWithCycleCollectedArgs, except the rejection error will + // simply be propagated. + template <typename Callback, typename... Args> + ThenResult<Callback, Args...> ThenWithCycleCollectedArgs( + Callback&& aOnResolve, Args&&... aArgs); + + // Same as ThenCatchWithCycleCollectedArgs, except the resolved value will + // simply be propagated. + template <typename Callback, typename... Args> + ThenResult<Callback, Args...> CatchWithCycleCollectedArgs( + Callback&& aOnReject, Args&&... aArgs); + + // Same as Then[Catch]CycleCollectedArgs but the arguments are gathered into + // an `std::tuple` and there is an additional `std::tuple` for JS arguments + // after that. + template <typename ResolveCallback, typename RejectCallback, + typename ArgsTuple, typename JSArgsTuple> + Result<RefPtr<Promise>, nsresult> ThenCatchWithCycleCollectedArgsJS( + ResolveCallback&& aOnResolve, RejectCallback&& aOnReject, + ArgsTuple&& aArgs, JSArgsTuple&& aJSArgs); + template <typename Callback, typename ArgsTuple, typename JSArgsTuple> + Result<RefPtr<Promise>, nsresult> ThenWithCycleCollectedArgsJS( + Callback&& aOnResolve, ArgsTuple&& aArgs, JSArgsTuple&& aJSArgs); + + Result<RefPtr<Promise>, nsresult> ThenWithoutCycleCollection( + const std::function<already_AddRefed<Promise>( + JSContext*, JS::Handle<JS::Value>, ErrorResult& aRv)>& aCallback); + + // Similar to ThenCatchWithCycleCollectedArgs but doesn't care with return + // values of the callbacks and does not return a new promise. + template <typename ResolveCallback, typename RejectCallback, typename... Args> + void AddCallbacksWithCycleCollectedArgs(ResolveCallback&& aOnResolve, + RejectCallback&& aOnReject, + Args&&... aArgs); + + // This can be null if this promise is made after the corresponding JSContext + // is dead. + JSObject* PromiseObj() const { return mPromiseObj; } + + void AppendNativeHandler(PromiseNativeHandler* aRunnable); + + nsIGlobalObject* GetGlobalObject() const { return mGlobal; } + + // Create a dom::Promise from a given SpiderMonkey Promise object. + // aPromiseObj MUST be in the compartment of aGlobal's global JS object. + // Pass ePropagateUserInteraction for aPropagateUserInteraction if you want + // the promise resolve handler to be called as if we were handling user + // input events in case we are currently handling user input events. + static already_AddRefed<Promise> CreateFromExisting( + nsIGlobalObject* aGlobal, JS::Handle<JSObject*> aPromiseObj, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + enum class PromiseState { Pending, Resolved, Rejected }; + + PromiseState State() const; + + static already_AddRefed<Promise> CreateResolvedWithUndefined( + nsIGlobalObject* aGlobal, ErrorResult& aRv); + + static already_AddRefed<Promise> CreateRejected( + nsIGlobalObject* aGlobal, JS::Handle<JS::Value> aRejectionError, + ErrorResult& aRv); + + static already_AddRefed<Promise> CreateRejectedWithTypeError( + nsIGlobalObject* aGlobal, const nsACString& aMessage, ErrorResult& aRv); + + // The rejection error will be consumed if the promise is successfully + // created, else the error will remain and rv.Failed() will keep being true. + // This intentionally is not an overload of CreateRejected to prevent + // accidental omission of the second argument. (See also bug 1762233 about + // removing its third argument.) + static already_AddRefed<Promise> CreateRejectedWithErrorResult( + nsIGlobalObject* aGlobal, ErrorResult& aRejectionError); + + // Converts an integer or DOMException to nsresult, or otherwise returns + // NS_ERROR_DOM_NOT_NUMBER_ERR (which is exclusive for this function). + // Can be used to convert JS::Value passed to rejection handler so that native + // error handlers e.g. MozPromise can consume it. + static nsresult TryExtractNSResultFromRejectionValue( + JS::Handle<JS::Value> aValue); + + protected: + template <typename ResolveCallback, typename RejectCallback, typename... Args, + typename... JSArgs> + Result<RefPtr<Promise>, nsresult> ThenCatchWithCycleCollectedArgsJSImpl( + Maybe<ResolveCallback>&& aOnResolve, Maybe<RejectCallback>&& aOnReject, + std::tuple<Args...>&& aArgs, std::tuple<JSArgs...>&& aJSArgs); + template <typename ResolveCallback, typename RejectCallback, typename... Args> + ThenResult<ResolveCallback, Args...> ThenCatchWithCycleCollectedArgsImpl( + Maybe<ResolveCallback>&& aOnResolve, Maybe<RejectCallback>&& aOnReject, + Args&&... aArgs); + + // Legacy method for throwing DOMExceptions. Only used by media code at this + // point, via DetailedPromise. Do NOT add new uses! When this is removed, + // remove the friend declaration in ErrorResult.h. + inline void MaybeRejectWithDOMException(nsresult rv, + const nsACString& aMessage) { + ErrorResult res; + res.ThrowDOMException(rv, aMessage); + MaybeReject(std::move(res)); + } + + struct PromiseCapability; + + // Do NOT call this unless you're Promise::Create or + // Promise::CreateFromExisting. I wish we could enforce that from inside this + // class too, somehow. + explicit Promise(nsIGlobalObject* aGlobal); + + virtual ~Promise(); + + // Do JS-wrapping after Promise creation. + // Pass ePropagateUserInteraction for aPropagateUserInteraction if you want + // the promise resolve handler to be called as if we were handling user + // input events in case we are currently handling user input events. + void CreateWrapper(ErrorResult& aRv, + PropagateUserInteraction aPropagateUserInteraction = + eDontPropagateUserInteraction); + + private: + void MaybeResolve(JSContext* aCx, JS::Handle<JS::Value> aValue); + void MaybeReject(JSContext* aCx, JS::Handle<JS::Value> aValue); + + template <typename T> + void MaybeSomething(T&& aArgument, MaybeFunc aFunc) { + MOZ_ASSERT(PromiseObj()); // It was preserved! + + AutoAllowLegacyScriptExecution exemption; + AutoEntryScript aes(mGlobal, "Promise resolution or rejection"); + JSContext* cx = aes.cx(); + + JS::Rooted<JS::Value> val(cx); + if (!ToJSValue(cx, std::forward<T>(aArgument), &val)) { + HandleException(cx); + return; + } + + (this->*aFunc)(cx, val); + } + + void HandleException(JSContext* aCx); + + bool MaybePropagateUserInputEventHandling(); + + RefPtr<nsIGlobalObject> mGlobal; + + JS::Heap<JSObject*> mPromiseObj; +}; + +} // namespace mozilla::dom + +extern "C" { +// These functions are used in the implementation of ffi bindings for +// dom::Promise from Rust in xpcom crate. +void DomPromise_AddRef(mozilla::dom::Promise* aPromise); +void DomPromise_Release(mozilla::dom::Promise* aPromise); +void DomPromise_RejectWithVariant(mozilla::dom::Promise* aPromise, + nsIVariant* aVariant); +void DomPromise_ResolveWithVariant(mozilla::dom::Promise* aPromise, + nsIVariant* aVariant); +} + +#endif // mozilla_dom_Promise_h diff --git a/dom/promise/PromiseDebugging.cpp b/dom/promise/PromiseDebugging.cpp new file mode 100644 index 0000000000..b27661ef5e --- /dev/null +++ b/dom/promise/PromiseDebugging.cpp @@ -0,0 +1,296 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "js/Value.h" +#include "nsThreadUtils.h" + +#include "mozilla/CycleCollectedJSContext.h" +#include "mozilla/RefPtr.h" +#include "mozilla/SchedulerGroup.h" +#include "mozilla/ThreadLocal.h" +#include "mozilla/TimeStamp.h" + +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseBinding.h" +#include "mozilla/dom/PromiseDebugging.h" +#include "mozilla/dom/PromiseDebuggingBinding.h" + +namespace mozilla::dom { + +class FlushRejections : public DiscardableRunnable { + public: + FlushRejections() : DiscardableRunnable("dom::FlushRejections") {} + + static void Init() { + if (!sDispatched.init()) { + MOZ_CRASH("Could not initialize FlushRejections::sDispatched"); + } + sDispatched.set(false); + } + + static void DispatchNeeded() { + if (sDispatched.get()) { + // An instance of `FlushRejections` has already been dispatched + // and not run yet. No need to dispatch another one. + return; + } + sDispatched.set(true); + + // Dispatch the runnable to the current thread where + // the Promise was rejected, e.g. workers or worklets. + NS_DispatchToCurrentThread(new FlushRejections()); + } + + static void FlushSync() { + sDispatched.set(false); + + // Call the callbacks if necessary. + // Note that these callbacks may in turn cause Promise to turn + // uncaught or consumed. Since `sDispatched` is `false`, + // `FlushRejections` will be called once again, on an ulterior + // tick. + PromiseDebugging::FlushUncaughtRejectionsInternal(); + } + + NS_IMETHOD Run() override { + FlushSync(); + return NS_OK; + } + + private: + // `true` if an instance of `FlushRejections` is currently dispatched + // and has not been executed yet. + static MOZ_THREAD_LOCAL(bool) sDispatched; +}; + +/* static */ MOZ_THREAD_LOCAL(bool) FlushRejections::sDispatched; + +/* static */ +void PromiseDebugging::GetState(GlobalObject& aGlobal, + JS::Handle<JSObject*> aPromise, + PromiseDebuggingStateHolder& aState, + ErrorResult& aRv) { + JSContext* cx = aGlobal.Context(); + // CheckedUnwrapStatic is fine, since we're looking for promises only. + JS::Rooted<JSObject*> obj(cx, js::CheckedUnwrapStatic(aPromise)); + if (!obj || !JS::IsPromiseObject(obj)) { + aRv.ThrowTypeError<MSG_IS_NOT_PROMISE>(); + return; + } + switch (JS::GetPromiseState(obj)) { + case JS::PromiseState::Pending: + aState.mState = PromiseDebuggingState::Pending; + break; + case JS::PromiseState::Fulfilled: + aState.mState = PromiseDebuggingState::Fulfilled; + aState.mValue = JS::GetPromiseResult(obj); + break; + case JS::PromiseState::Rejected: + aState.mState = PromiseDebuggingState::Rejected; + aState.mReason = JS::GetPromiseResult(obj); + break; + } +} + +/* static */ +void PromiseDebugging::GetPromiseID(GlobalObject& aGlobal, + JS::Handle<JSObject*> aPromise, + nsString& aID, ErrorResult& aRv) { + JSContext* cx = aGlobal.Context(); + // CheckedUnwrapStatic is fine, since we're looking for promises only. + JS::Rooted<JSObject*> obj(cx, js::CheckedUnwrapStatic(aPromise)); + if (!obj || !JS::IsPromiseObject(obj)) { + aRv.ThrowTypeError<MSG_IS_NOT_PROMISE>(); + return; + } + uint64_t promiseID = JS::GetPromiseID(obj); + aID = sIDPrefix; + aID.AppendInt(promiseID); +} + +/* static */ +void PromiseDebugging::GetAllocationStack(GlobalObject& aGlobal, + JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv) { + JSContext* cx = aGlobal.Context(); + // CheckedUnwrapStatic is fine, since we're looking for promises only. + JS::Rooted<JSObject*> obj(cx, js::CheckedUnwrapStatic(aPromise)); + if (!obj || !JS::IsPromiseObject(obj)) { + aRv.ThrowTypeError<MSG_IS_NOT_PROMISE>(); + return; + } + aStack.set(JS::GetPromiseAllocationSite(obj)); +} + +/* static */ +void PromiseDebugging::GetRejectionStack(GlobalObject& aGlobal, + JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv) { + JSContext* cx = aGlobal.Context(); + // CheckedUnwrapStatic is fine, since we're looking for promises only. + JS::Rooted<JSObject*> obj(cx, js::CheckedUnwrapStatic(aPromise)); + if (!obj || !JS::IsPromiseObject(obj)) { + aRv.ThrowTypeError<MSG_IS_NOT_PROMISE>(); + return; + } + aStack.set(JS::GetPromiseResolutionSite(obj)); +} + +/* static */ +void PromiseDebugging::GetFullfillmentStack(GlobalObject& aGlobal, + JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv) { + JSContext* cx = aGlobal.Context(); + // CheckedUnwrapStatic is fine, since we're looking for promises only. + JS::Rooted<JSObject*> obj(cx, js::CheckedUnwrapStatic(aPromise)); + if (!obj || !JS::IsPromiseObject(obj)) { + aRv.ThrowTypeError<MSG_IS_NOT_PROMISE>(); + return; + } + aStack.set(JS::GetPromiseResolutionSite(obj)); +} + +/*static */ +nsString PromiseDebugging::sIDPrefix; + +/* static */ +void PromiseDebugging::Init() { + FlushRejections::Init(); + + // Generate a prefix for identifiers: "PromiseDebugging.$processid." + sIDPrefix = u"PromiseDebugging."_ns; + if (XRE_IsContentProcess()) { + sIDPrefix.AppendInt(ContentChild::GetSingleton()->GetID()); + sIDPrefix.Append('.'); + } else { + sIDPrefix.AppendLiteral("0."); + } +} + +/* static */ +void PromiseDebugging::Shutdown() { sIDPrefix.SetIsVoid(true); } + +/* static */ +void PromiseDebugging::FlushUncaughtRejections() { + MOZ_ASSERT(!NS_IsMainThread()); + FlushRejections::FlushSync(); +} + +/* static */ +void PromiseDebugging::AddUncaughtRejectionObserver( + GlobalObject&, UncaughtRejectionObserver& aObserver) { + CycleCollectedJSContext* storage = CycleCollectedJSContext::Get(); + nsTArray<nsCOMPtr<nsISupports>>& observers = + storage->mUncaughtRejectionObservers; + observers.AppendElement(&aObserver); +} + +/* static */ +bool PromiseDebugging::RemoveUncaughtRejectionObserver( + GlobalObject&, UncaughtRejectionObserver& aObserver) { + CycleCollectedJSContext* storage = CycleCollectedJSContext::Get(); + nsTArray<nsCOMPtr<nsISupports>>& observers = + storage->mUncaughtRejectionObservers; + for (size_t i = 0; i < observers.Length(); ++i) { + UncaughtRejectionObserver* observer = + static_cast<UncaughtRejectionObserver*>(observers[i].get()); + if (*observer == aObserver) { + observers.RemoveElementAt(i); + return true; + } + } + return false; +} + +/* static */ +void PromiseDebugging::AddUncaughtRejection(JS::Handle<JSObject*> aPromise) { + // This might OOM, but won't set a pending exception, so we'll just ignore it. + if (CycleCollectedJSContext::Get()->mUncaughtRejections.append(aPromise)) { + FlushRejections::DispatchNeeded(); + } +} + +/* void */ +void PromiseDebugging::AddConsumedRejection(JS::Handle<JSObject*> aPromise) { + // If the promise is in our list of uncaught rejections, we haven't yet + // reported it as unhandled. In that case, just remove it from the list + // and don't add it to the list of consumed rejections. + auto& uncaughtRejections = + CycleCollectedJSContext::Get()->mUncaughtRejections; + for (size_t i = 0; i < uncaughtRejections.length(); i++) { + if (uncaughtRejections[i] == aPromise) { + // To avoid large amounts of memmoves, we don't shrink the vector here. + // Instead, we filter out nullptrs when iterating over the vector later. + uncaughtRejections[i].set(nullptr); + return; + } + } + // This might OOM, but won't set a pending exception, so we'll just ignore it. + if (CycleCollectedJSContext::Get()->mConsumedRejections.append(aPromise)) { + FlushRejections::DispatchNeeded(); + } +} + +/* static */ +void PromiseDebugging::FlushUncaughtRejectionsInternal() { + CycleCollectedJSContext* storage = CycleCollectedJSContext::Get(); + + auto& uncaught = storage->mUncaughtRejections; + auto& consumed = storage->mConsumedRejections; + + AutoJSAPI jsapi; + jsapi.Init(); + JSContext* cx = jsapi.cx(); + + // Notify observers of uncaught Promise. + auto& observers = storage->mUncaughtRejectionObservers; + + for (size_t i = 0; i < uncaught.length(); i++) { + JS::Rooted<JSObject*> promise(cx, uncaught[i]); + // Filter out nullptrs which might've been added by + // PromiseDebugging::AddConsumedRejection. + if (!promise) { + continue; + } + + bool suppressReporting = false; + for (size_t j = 0; j < observers.Length(); ++j) { + RefPtr<UncaughtRejectionObserver> obs = + static_cast<UncaughtRejectionObserver*>(observers[j].get()); + + if (obs->OnLeftUncaught(promise, IgnoreErrors())) { + suppressReporting = true; + } + } + + if (!suppressReporting) { + JSAutoRealm ar(cx, promise); + Promise::ReportRejectedPromise(cx, promise); + } + } + storage->mUncaughtRejections.clear(); + + // Notify observers of consumed Promise. + + for (size_t i = 0; i < consumed.length(); i++) { + JS::Rooted<JSObject*> promise(cx, consumed[i]); + + for (size_t j = 0; j < observers.Length(); ++j) { + RefPtr<UncaughtRejectionObserver> obs = + static_cast<UncaughtRejectionObserver*>(observers[j].get()); + + obs->OnConsumed(promise, IgnoreErrors()); + } + } + storage->mConsumedRejections.clear(); +} + +} // namespace mozilla::dom diff --git a/dom/promise/PromiseDebugging.h b/dom/promise/PromiseDebugging.h new file mode 100644 index 0000000000..ed14e2215b --- /dev/null +++ b/dom/promise/PromiseDebugging.h @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef mozilla_dom_PromiseDebugging_h +#define mozilla_dom_PromiseDebugging_h + +#include "js/TypeDecls.h" +#include "nsTArray.h" +#include "mozilla/RefPtr.h" + +namespace mozilla { + +class ErrorResult; + +namespace dom { +class Promise; +struct PromiseDebuggingStateHolder; +class GlobalObject; +class UncaughtRejectionObserver; +class FlushRejections; +class WorkerPrivate; + +void TriggerFlushRejections(); + +class PromiseDebugging { + public: + static void Init(); + static void Shutdown(); + + static void GetState(GlobalObject&, JS::Handle<JSObject*> aPromise, + PromiseDebuggingStateHolder& aState, ErrorResult& aRv); + + static void GetPromiseID(GlobalObject&, JS::Handle<JSObject*>, nsString&, + ErrorResult&); + + static void GetAllocationStack(GlobalObject&, JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv); + static void GetRejectionStack(GlobalObject&, JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv); + static void GetFullfillmentStack(GlobalObject&, + JS::Handle<JSObject*> aPromise, + JS::MutableHandle<JSObject*> aStack, + ErrorResult& aRv); + + // Mechanism for watching uncaught instances of Promise. + static void AddUncaughtRejectionObserver( + GlobalObject&, UncaughtRejectionObserver& aObserver); + static bool RemoveUncaughtRejectionObserver( + GlobalObject&, UncaughtRejectionObserver& aObserver); + + // Mark a Promise as having been left uncaught at script completion. + static void AddUncaughtRejection(JS::Handle<JSObject*>); + // Mark a Promise previously added with `AddUncaughtRejection` as + // eventually consumed. + static void AddConsumedRejection(JS::Handle<JSObject*>); + // Propagate the informations from AddUncaughtRejection + // and AddConsumedRejection to observers. + static void FlushUncaughtRejections(); + + protected: + static void FlushUncaughtRejectionsInternal(); + friend class FlushRejections; + friend class mozilla::dom::WorkerPrivate; + + private: + // Identity of the process. + // This property is: + // - set during initialization of the layout module, + // prior to any Worker using it; + // - read by both the main thread and the Workers; + // - unset during shutdown of the layout module, + // after any Worker has been shutdown. + static nsString sIDPrefix; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_PromiseDebugging_h diff --git a/dom/promise/PromiseNativeHandler.cpp b/dom/promise/PromiseNativeHandler.cpp new file mode 100644 index 0000000000..7f29581b06 --- /dev/null +++ b/dom/promise/PromiseNativeHandler.cpp @@ -0,0 +1,18 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "PromiseNativeHandler.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/DOMException.h" +#include "mozilla/dom/DOMExceptionBinding.h" +#include "nsISupportsImpl.h" + +namespace mozilla::dom { + +NS_IMPL_ISUPPORTS0(MozPromiseRejectOnDestructionBase) + +} // namespace mozilla::dom diff --git a/dom/promise/PromiseNativeHandler.h b/dom/promise/PromiseNativeHandler.h new file mode 100644 index 0000000000..f311f2d29e --- /dev/null +++ b/dom/promise/PromiseNativeHandler.h @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef mozilla_dom_PromiseNativeHandler_h +#define mozilla_dom_PromiseNativeHandler_h + +#include <functional> +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/Maybe.h" +#include "nsISupports.h" + +namespace mozilla::dom { + +/* + * PromiseNativeHandler allows C++ to react to a Promise being + * rejected/resolved. A PromiseNativeHandler can be appended to a Promise using + * Promise::AppendNativeHandler(). + */ +class PromiseNativeHandler : public nsISupports { + protected: + virtual ~PromiseNativeHandler() = default; + + public: + MOZ_CAN_RUN_SCRIPT + virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) = 0; + + MOZ_CAN_RUN_SCRIPT + virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) = 0; +}; + +// This base class exists solely to use NS_IMPL_ISUPPORTS because it doesn't +// support template classes. +class MozPromiseRejectOnDestructionBase : public PromiseNativeHandler { + NS_DECL_ISUPPORTS + + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override {} + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override {} + + protected: + ~MozPromiseRejectOnDestructionBase() override = default; +}; + +// Use this when you subscribe to a JS promise to settle a MozPromise that is +// not guaranteed to be settled by anyone else. +template <typename T> +class MozPromiseRejectOnDestruction final + : public MozPromiseRejectOnDestructionBase { + public: + // (Accepting RefPtr<T> instead of T* because compiler fails to implicitly + // convert it at call sites) + MozPromiseRejectOnDestruction(const RefPtr<T>& aMozPromise, + const char* aCallSite) + : mMozPromise(aMozPromise), mCallSite(aCallSite) { + MOZ_ASSERT(aMozPromise); + } + + protected: + ~MozPromiseRejectOnDestruction() override { + // Rejecting will be no-op if the promise is already settled + mMozPromise->Reject(NS_BINDING_ABORTED, mCallSite); + } + + RefPtr<T> mMozPromise; + const char* mCallSite; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PromiseNativeHandler_h diff --git a/dom/promise/PromiseWorkerProxy.h b/dom/promise/PromiseWorkerProxy.h new file mode 100644 index 0000000000..026fdd091f --- /dev/null +++ b/dom/promise/PromiseWorkerProxy.h @@ -0,0 +1,219 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef mozilla_dom_PromiseWorkerProxy_h +#define mozilla_dom_PromiseWorkerProxy_h + +#include <cstdint> +#include "js/TypeDecls.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Mutex.h" +#include "mozilla/RefPtr.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "nsISupports.h" + +struct JSStructuredCloneReader; +struct JSStructuredCloneWriter; + +namespace JS { +class CloneDataPolicy; +} // namespace JS + +namespace mozilla::dom { + +class ThreadSafeWorkerRef; +class WorkerPrivate; + +// A proxy to (eventually) mirror a resolved/rejected Promise's result from the +// main thread to a Promise on the worker thread. +// +// How to use: +// +// 1. Create a Promise on the worker thread and return it to the content +// script: +// +// RefPtr<Promise> promise = +// Promise::Create(workerPrivate->GlobalScope(), aRv); +// if (aRv.Failed()) { +// return nullptr; +// } +// +// 2. Create a PromiseWorkerProxy wrapping the Promise. If this fails, the +// worker is shutting down and you should fail the original call. This is +// only likely to happen in (Gecko-specific) worker onclose handlers. +// +// RefPtr<PromiseWorkerProxy> proxy = +// PromiseWorkerProxy::Create(workerPrivate, promise); +// if (!proxy) { +// // You may also reject the Promise with an AbortError or similar. +// return nullptr; +// } +// +// 3. Dispatch a runnable to the main thread, with a reference to the proxy to +// perform the main thread operation. PromiseWorkerProxy is thread-safe +// refcounted. +// +// 4. Return the worker thread promise to the JS caller: +// +// return promise.forget(); +// +// 5. In your main thread runnable Run(), obtain a Promise on +// the main thread and call its AppendNativeHandler(PromiseNativeHandler*) +// to bind the PromiseWorkerProxy created at #2. +// +// 4. Then the Promise results returned by ResolvedCallback/RejectedCallback +// will be dispatched as a WorkerRunnable to the worker thread to +// resolve/reject the Promise created at #1. +// +// PromiseWorkerProxy can also be used in situations where there is no main +// thread Promise, or where special handling is required on the worker thread +// for promise resolution. Create a PromiseWorkerProxy as in steps 1 to 3 +// above. When the main thread is ready to resolve the worker thread promise: +// +// 1. Acquire the mutex before attempting to access the worker private. +// +// AssertIsOnMainThread(); +// MutexAutoLock lock(proxy->Lock()); +// if (proxy->CleanedUp()) { +// // Worker has already shut down, can't access worker private. +// return; +// } +// +// 2. Dispatch a runnable to the worker. Use GetWorkerPrivate() to acquire the +// worker. +// +// RefPtr<FinishTaskWorkerRunnable> runnable = +// new FinishTaskWorkerRunnable(proxy->GetWorkerPrivate(), proxy, +// result); +// if (!r->Dispatch()) { +// // Worker is alive but not Running any more, so the Promise can't +// // be resolved, give up. The proxy will get Release()d at some +// // point. +// +// // Usually do nothing, but you may want to log the fact. +// } +// +// 3. In the WorkerRunnable's WorkerRun() use GetWorkerPromise() to access the +// Promise and resolve/reject it. Then call CleanUp(). +// +// bool +// WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override +// { +// aWorkerPrivate->AssertIsOnWorkerThread(); +// RefPtr<Promise> promise = mProxy->GetWorkerPromise(); +// promise->MaybeResolve(mResult); +// mProxy->CleanUp(); +// } +// +// Note: If a PromiseWorkerProxy is not cleaned up by a WorkerRunnable - this +// can happen if the main thread Promise is never fulfilled - it will +// stay alive till the worker reaches a Canceling state, even if all external +// references to it are dropped. + +class PromiseWorkerProxy : public PromiseNativeHandler, + public StructuredCloneHolderBase, + public SingleWriterLockOwner { + friend class PromiseWorkerProxyRunnable; + + NS_DECL_THREADSAFE_ISUPPORTS + + public: + typedef JSObject* (*ReadCallbackOp)(JSContext* aCx, + JSStructuredCloneReader* aReader, + const PromiseWorkerProxy* aProxy, + uint32_t aTag, uint32_t aData); + typedef bool (*WriteCallbackOp)(JSContext* aCx, + JSStructuredCloneWriter* aWorker, + PromiseWorkerProxy* aProxy, + JS::Handle<JSObject*> aObj); + + bool OnWritingThread() const override; + + struct PromiseWorkerProxyStructuredCloneCallbacks { + ReadCallbackOp Read; + WriteCallbackOp Write; + }; + + static already_AddRefed<PromiseWorkerProxy> Create( + WorkerPrivate* aWorkerPrivate, Promise* aWorkerPromise, + const PromiseWorkerProxyStructuredCloneCallbacks* aCallbacks = nullptr); + + // Main thread callers must hold Lock() and check CleanUp() before calling + // this. Worker thread callers, this will assert that the proxy has not been + // cleaned up. + WorkerPrivate* GetWorkerPrivate() const MOZ_NO_THREAD_SAFETY_ANALYSIS; + + // This should only be used within WorkerRunnable::WorkerRun() running on the + // worker thread! If this method is called after CleanUp(), return nullptr. + Promise* GetWorkerPromise() const; + + // Worker thread only. Calling this invalidates several assumptions, so be + // sure this is the last thing you do. + // 1. WorkerPrivate() will no longer return a valid worker. + // 2. GetWorkerPromise() will return null! + void CleanUp(); + + Mutex& Lock() MOZ_RETURN_CAPABILITY(mCleanUpLock) { return mCleanUpLock; } + + bool CleanedUp() const MOZ_REQUIRES(mCleanUpLock) { + mCleanUpLock.AssertCurrentThreadOwns(); + return mCleanedUp; + } + + // StructuredCloneHolderBase + + JSObject* CustomReadHandler(JSContext* aCx, JSStructuredCloneReader* aReader, + const JS::CloneDataPolicy& aCloneDataPolicy, + uint32_t aTag, uint32_t aIndex) override; + + bool CustomWriteHandler(JSContext* aCx, JSStructuredCloneWriter* aWriter, + JS::Handle<JSObject*> aObj, + bool* aSameProcessScopeRequired) override; + + protected: + virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + private: + explicit PromiseWorkerProxy( + Promise* aWorkerPromise, + const PromiseWorkerProxyStructuredCloneCallbacks* aCallbacks = nullptr); + + virtual ~PromiseWorkerProxy(); + + // Function pointer for calling Promise::{ResolveInternal,RejectInternal}. + typedef void (Promise::*RunCallbackFunc)(JSContext*, JS::Handle<JS::Value>); + + void RunCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + RunCallbackFunc aFunc); + + // Any thread with appropriate checks. + RefPtr<ThreadSafeWorkerRef> mWorkerRef; + + // Worker thread only. + RefPtr<Promise> mWorkerPromise; + + // Modified on the worker thread. + // It is ok to *read* this without a lock on the worker. + // Main thread must always acquire a lock. + bool mCleanedUp MOZ_GUARDED_BY( + mCleanUpLock); // To specify if the cleanUp() has been done. + + const PromiseWorkerProxyStructuredCloneCallbacks* mCallbacks; + + // Ensure the worker and the main thread won't race to access |mCleanedUp|. + // Should be a MutexSingleWriter, but that causes a lot of issues when you + // expose the lock via Lock(). + Mutex mCleanUpLock; +}; +} // namespace mozilla::dom + +#endif // mozilla_dom_PromiseWorkerProxy_h diff --git a/dom/promise/gtest/NativeThenHandler.cpp b/dom/promise/gtest/NativeThenHandler.cpp new file mode 100644 index 0000000000..13ed6d2c11 --- /dev/null +++ b/dom/promise/gtest/NativeThenHandler.cpp @@ -0,0 +1,160 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "gtest/gtest.h" + +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Promise-inl.h" +#include "xpcpublic.h" + +using namespace mozilla; +using namespace mozilla::dom; + +struct TraceCounts { + int32_t mValue = 0; + int32_t mId = 0; + int32_t mObject = 0; + int32_t mWrapperCache = 0; + int32_t mTenuredHeapObject = 0; + int32_t mString = 0; + int32_t mScript = 0; + int32_t mFunction = 0; +}; + +struct DummyCallbacks final : public TraceCallbacks { + void Trace(JS::Heap<JS::Value>*, const char*, void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mValue++; + } + + void Trace(JS::Heap<jsid>*, const char*, void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mId++; + } + + void Trace(JS::Heap<JSObject*>*, const char*, void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mObject++; + } + + void Trace(nsWrapperCache*, const char* aName, + void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mWrapperCache++; + } + + void Trace(JS::TenuredHeap<JSObject*>*, const char*, + void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mTenuredHeapObject++; + } + + void Trace(JS::Heap<JSString*>*, const char*, void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mString++; + } + + void Trace(JS::Heap<JSScript*>*, const char*, void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mScript++; + } + + void Trace(JS::Heap<JSFunction*>*, const char*, + void* aClosure) const override { + static_cast<TraceCounts*>(aClosure)->mFunction++; + } +}; + +TEST(NativeThenHandler, TraceValue) +{ + auto onResolve = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + JS::Handle<JS::Value>) -> already_AddRefed<Promise> { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + JS::Handle<JS::Value>) -> already_AddRefed<Promise> { + return nullptr; + }; + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler<decltype(onResolve), decltype(onReject), std::tuple<>, + std::tuple<JS::HandleValue>>; + RefPtr<HandlerType> handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), std::make_tuple(), + std::make_tuple(JS::UndefinedHandleValue)); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mValue, 1); +} + +TEST(NativeThenHandler, TraceObject) +{ + auto onResolve = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + JS::Handle<JSObject*>) -> already_AddRefed<Promise> { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + JS::Handle<JSObject*>) -> already_AddRefed<Promise> { + return nullptr; + }; + + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler<decltype(onResolve), decltype(onReject), std::tuple<>, + std::tuple<JS::HandleObject>>; + RefPtr<HandlerType> handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), std::make_tuple(), + std::make_tuple(JS::HandleObject(obj))); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mObject, 1); +} + +TEST(NativeThenHandler, TraceMixed) +{ + auto onResolve = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + nsIGlobalObject*, Promise*, JS::Handle<JS::Value>, + JS::Handle<JSObject*>) -> already_AddRefed<Promise> { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, + nsIGlobalObject*, Promise*, JS::Handle<JS::Value>, + JS::Handle<JSObject*>) -> already_AddRefed<Promise> { + return nullptr; + }; + + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr<nsIGlobalObject> global = xpc::CurrentNativeGlobal(cx); + JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler<decltype(onResolve), decltype(onReject), + std::tuple<nsCOMPtr<nsIGlobalObject>, RefPtr<Promise>>, + std::tuple<JS::HandleValue, JS::HandleObject>>; + RefPtr<HandlerType> handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mValue, 1); + EXPECT_EQ(counts.mObject, 1); +} diff --git a/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp b/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp new file mode 100644 index 0000000000..31b9fde3ca --- /dev/null +++ b/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp @@ -0,0 +1,158 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "gtest/gtest.h" + +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Promise-inl.h" +#include "xpcpublic.h" + +using namespace mozilla; +using namespace mozilla::dom; + +TEST(ThenWithCycleCollectedArgsJS, Empty) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&) { return nullptr; }, + std::make_tuple(), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, nsCOMPtr) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + std::make_tuple(global), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, RefPtr) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, Promise*) { + return nullptr; + }, + std::make_tuple(promise), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, RefPtrAndJSHandle) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value> v, ErrorResult&, Promise*, + JS::Handle<JS::Value>) { return nullptr; }, + std::make_tuple(promise), std::make_tuple(JS::UndefinedHandleValue)); +} + +TEST(ThenWithCycleCollectedArgsJS, Mixed) +{ + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr<nsIGlobalObject> global = xpc::CurrentNativeGlobal(cx); + JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle<JS::Value>, + JS::Handle<JSObject*>) { return nullptr; }, + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, Empty) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&) { return nullptr; }, + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&) { return nullptr; }, + std::make_tuple(), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, nsCOMPtr) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + std::make_tuple(global), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, RefPtr) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, Promise*) { + return nullptr; + }, + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, Promise*) { + return nullptr; + }, + std::make_tuple(promise), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, RefPtrAndJSHandle) +{ + nsCOMPtr<nsIGlobalObject> global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value> v, ErrorResult&, Promise*, + JS::Handle<JS::Value>) { return nullptr; }, + [](JSContext*, JS::Handle<JS::Value> v, ErrorResult&, Promise*, + JS::Handle<JS::Value>) { return nullptr; }, + std::make_tuple(promise), std::make_tuple(JS::UndefinedHandleValue)); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, Mixed) +{ + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr<nsIGlobalObject> global = xpc::CurrentNativeGlobal(cx); + JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); + + RefPtr<Promise> promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle<JS::Value>, + JS::Handle<JSObject*>) { return nullptr; }, + [](JSContext*, JS::Handle<JS::Value>, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle<JS::Value>, + JS::Handle<JSObject*>) { return nullptr; }, + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); +} diff --git a/dom/promise/gtest/moz.build b/dom/promise/gtest/moz.build new file mode 100644 index 0000000000..a220822834 --- /dev/null +++ b/dom/promise/gtest/moz.build @@ -0,0 +1,14 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +UNIFIED_SOURCES += [ + "NativeThenHandler.cpp", + "ThenWithCycleCollectedArgsJS.cpp", +] + +LOCAL_INCLUDES += ["/dom/promise"] + +FINAL_LIBRARY = "xul-gtest" diff --git a/dom/promise/moz.build b/dom/promise/moz.build new file mode 100644 index 0000000000..843eb93d83 --- /dev/null +++ b/dom/promise/moz.build @@ -0,0 +1,42 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Core & HTML") + +EXPORTS.mozilla.dom += [ + "Promise-inl.h", + "Promise.h", + "PromiseDebugging.h", + "PromiseNativeHandler.h", + "PromiseWorkerProxy.h", +] + +UNIFIED_SOURCES += [ + "Promise.cpp", + "PromiseDebugging.cpp", + "PromiseNativeHandler.cpp", +] + +LOCAL_INCLUDES += [ + "../base", + "../ipc", + "/js/xpconnect/src", +] + +TEST_DIRS += [ + "gtest", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" + +MOCHITEST_MANIFESTS += ["tests/mochitest.toml"] + +MOCHITEST_CHROME_MANIFESTS += ["tests/chrome.toml"] + +XPCSHELL_TESTS_MANIFESTS += ["tests/unit/xpcshell.toml"] diff --git a/dom/promise/tests/chrome.toml b/dom/promise/tests/chrome.toml new file mode 100644 index 0000000000..9b85c2de69 --- /dev/null +++ b/dom/promise/tests/chrome.toml @@ -0,0 +1,27 @@ +[DEFAULT] + +["test_on_new_promise.html"] + +["test_on_promise_settled.html"] + +["test_on_promise_settled_duplicates.html"] + +["test_promise_argument_xrays.html"] +support-files = [ + "file_promise_xrays.html", + "file_promise_argument_tests.js", +] +skip-if = ["!debug"] + +["test_promise_job_with_bind_from_discarded_iframe.html"] +support-files = ["file_promise_job_with_bind_from_discarded_iframe.html"] + +["test_promise_retval_xrays.html"] +support-files = [ + "file_promise_xrays.html", + "file_promise_retval_tests.js" +] +skip-if = ["debug == false"] + +["test_promise_xrays.html"] +support-files = ["file_promise_xrays.html"] diff --git a/dom/promise/tests/file_promise_and_timeout_ordering.js b/dom/promise/tests/file_promise_and_timeout_ordering.js new file mode 100644 index 0000000000..734621eae0 --- /dev/null +++ b/dom/promise/tests/file_promise_and_timeout_ordering.js @@ -0,0 +1,18 @@ +var log = []; +var resolvedPromise = Promise.resolve(null); +function schedulePromiseTask(f) { + resolvedPromise.then(f); +} + +setTimeout(function () { + log.push("t1start"); + schedulePromiseTask(function () { + log.push("promise"); + }); + log.push("t1end"); +}, 10); + +setTimeout(function () { + log.push("t2"); + postMessage(log.join(", ")); +}, 10); diff --git a/dom/promise/tests/file_promise_argument_tests.js b/dom/promise/tests/file_promise_argument_tests.js new file mode 100644 index 0000000000..2a3b4e78c9 --- /dev/null +++ b/dom/promise/tests/file_promise_argument_tests.js @@ -0,0 +1,175 @@ +/* + * This file is meant to provide common infrastructure for several consumers. + * The consumer is expected to define the following things: + * + * 1) An verifyPromiseGlobal function which does whatever test the consumer + * wants. + * 2) An isXrayArgumentTest global boolean, because some of these tests act + * differenly based on that boolean. + * 3) A function named getPromise. This function is given a global object and a + * single argument to use for getting the promise. The getPromise function + * is expected to trigger the canonical Promise.resolve for the given global + * with the given argument in some way that depends on the test, and return + * the result. + * 4) A subframe (frames[0]) which can be used as a second global for creating + * promises. + */ + +/* global verifyPromiseGlobal, getPromise, isXrayArgumentTest */ + +var label = "parent"; + +function passBasicPromise() { + var p1 = Promise.resolve(); + verifyPromiseGlobal(p1, window, "Promise.resolve return value 1"); + var p2 = getPromise(window, p1); + is(p1, p2, "Basic promise should just pass on through"); + return p2; +} + +function passPrimitive(global) { + var p = getPromise(global, 5); + verifyPromiseGlobal(p, global, "Promise wrapping primitive"); + return p.then(function (arg) { + is(arg, 5, "Should have the arg we passed in"); + }); +} + +function passThenable(global) { + var called = false; + var thenable = { + then(f) { + called = true; + f(7); + }, + }; + var p = getPromise(global, thenable); + verifyPromiseGlobal(p, global, "Promise wrapping thenable"); + return p.then(function (arg) { + ok(called, "Thenable should have been called"); + is(arg, 7, "Should have the arg our thenable passed in"); + }); +} + +function passWrongPromiseWithMatchingConstructor() { + var p1 = Promise.resolve(); + verifyPromiseGlobal(p1, window, "Promise.resolve() return value 2"); + p1.constructor = frames[0].Promise; + var p2 = getPromise(frames[0], p1); + // The behavior here will depend on whether we're touching frames[0] via Xrays + // or not. If we are not, the current compartment while getting our promise + // will be that of frames[0]. If we are, it will be our window's compartment. + if (isXrayArgumentTest) { + isnot( + p1, + p2, + "Should have wrapped the Promise in a new promise, because its constructor is not matching the current-compartment Promise constructor" + ); + verifyPromiseGlobal( + p2, + window, + "Promise wrapping xrayed promise with therefore non-matching constructor" + ); + } else { + is( + p1, + p2, + "Should have left the Promise alone because its constructor matched" + ); + } + return p2; +} + +function passCorrectPromiseWithMismatchedConstructor() { + var p1 = Promise.resolve(9); + verifyPromiseGlobal(p1, window, "Promise.resolve() return value 3"); + p1.constructor = frames[0].Promise; + var p2 = getPromise(window, p1); + isnot( + p1, + p2, + "Should have wrapped promise in a new promise, since its .constructor was wrong" + ); + verifyPromiseGlobal( + p2, + window, + "Promise wrapping passed-in promise with mismatched constructor" + ); + return p2.then(function (arg) { + is(arg, 9, "Should have propagated along our resolution value"); + }); +} + +function passPromiseToOtherGlobal() { + var p1 = Promise.resolve(); + verifyPromiseGlobal(p1, window, "Promise.resolve() return value 4"); + var p2 = getPromise(frames[0], p1); + // The behavior here will depend on whether we're touching frames[0] via Xrays + // or not. If we are not, the current compartment while getting our promise + // will be that of frames[0]. If we are, it will be our window's compartment. + if (isXrayArgumentTest) { + is( + p1, + p2, + "Should have left the Promise alone, because its constructor matches the current compartment's constructor" + ); + } else { + isnot( + p1, + p2, + "Should have wrapped promise in a promise from the other global" + ); + verifyPromiseGlobal( + p2, + frames[0], + "Promise wrapping passed-in basic promise" + ); + } + return p2; +} + +function passPromiseSubclass() { + class PromiseSubclass extends Promise { + constructor(func) { + super(func); + } + } + + var p1 = PromiseSubclass.resolve(11); + verifyPromiseGlobal(p1, window, "PromiseSubclass.resolve() return value"); + var p2 = getPromise(window, p1); + isnot(p1, p2, "Should have wrapped promise subclass in a new promise"); + verifyPromiseGlobal( + p2, + window, + "Promise wrapping passed-in promise subclass" + ); + return p2.then(function (arg) { + is( + arg, + 11, + "Should have propagated along our resolution value from subclass" + ); + }); +} + +function runPromiseArgumentTests(finishFunc) { + Promise.resolve() + .then(passBasicPromise) + .then(passPrimitive.bind(undefined, window)) + .then(passPrimitive.bind(undefined, frames[0])) + .then(passThenable.bind(undefined, window)) + .then(passThenable.bind(undefined, frames[0])) + .then(passWrongPromiseWithMatchingConstructor) + .then(passCorrectPromiseWithMismatchedConstructor) + .then(passPromiseToOtherGlobal) + .then(passPromiseSubclass) + .then(finishFunc) + .catch(function (e) { + ok( + false, + `Exception thrown: ${e}@${location.pathname}:${e.lineNumber}:${e.columnNumber}` + ); + finishFunc(); + }); +} diff --git a/dom/promise/tests/file_promise_job_with_bind_from_discarded_iframe.html b/dom/promise/tests/file_promise_job_with_bind_from_discarded_iframe.html new file mode 100644 index 0000000000..352cf6623e --- /dev/null +++ b/dom/promise/tests/file_promise_job_with_bind_from_discarded_iframe.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<html> +<head> +<title>iframe in http</title> +</head> +<body> +<div id="result"></div> +<script type="text/javascript"> +if (typeof SpecialPowers !== "undefined") { + document.getElementById("result").textContent = "ok"; +} +</script> +</body> +</html> diff --git a/dom/promise/tests/file_promise_retval_tests.js b/dom/promise/tests/file_promise_retval_tests.js new file mode 100644 index 0000000000..37ede9e514 --- /dev/null +++ b/dom/promise/tests/file_promise_retval_tests.js @@ -0,0 +1,56 @@ +/* + * This file is meant to provide common infrastructure for several consumers. + * The consumer is expected to define the following things: + * + * 1) A verifyPromiseGlobal function which does whatever test the consumer + * wants. This function is passed a promise and the global whose + * TestFunctions was used to get the promise. + * 2) A expectedExceptionGlobal function which is handed the global whose + * TestFunctions was used to trigger the exception and should return the + * global the exception is expected to live in. + * 3) A subframe (frames[0]) which can be used as a second global for creating + * promises. + */ + +/* global verifyPromiseGlobal, expectedExceptionGlobal */ + +var label = "parent"; + +function testThrownException(global) { + var p = global.TestFunctions.throwToRejectPromise(); + verifyPromiseGlobal(p, global, "throwToRejectPromise return value"); + return p + .then(() => {}) + .catch(err => { + var expected = expectedExceptionGlobal(global); + is( + SpecialPowers.unwrap(SpecialPowers.Cu.getGlobalForObject(err)), + expected, + "Should have an exception object from the right global too" + ); + ok( + err instanceof expected.DOMException, + "Should have a DOMException here" + ); + is( + Object.getPrototypeOf(err), + expected.DOMException.prototype, + "Should have a DOMException from the right global" + ); + is(err.name, "InvalidStateError", "Should have the right DOMException"); + }); +} + +function runPromiseRetvalTests(finishFunc) { + Promise.resolve() + .then(testThrownException.bind(undefined, window)) + .then(testThrownException.bind(undefined, frames[0])) + .then(finishFunc) + .catch(function (e) { + ok( + false, + `Exception thrown: ${e}@${location.pathname}:${e.lineNumber}:${e.columnNumber}` + ); + finishFunc(); + }); +} diff --git a/dom/promise/tests/file_promise_xrays.html b/dom/promise/tests/file_promise_xrays.html new file mode 100644 index 0000000000..e08014a337 --- /dev/null +++ b/dom/promise/tests/file_promise_xrays.html @@ -0,0 +1,34 @@ +<!DOCTYPE html> +<html> + <script> + function vendGetter(name) { + // eslint-disable-next-line no-throw-literal + return function() { throw "Getting " + String(name); }; + } + function vendSetter(name) { + // eslint-disable-next-line no-throw-literal + return function() { throw "Setting " + String(name); }; + } + var setupThrew = false; + try { + // Neuter everything we can think of on Promise. + for (var obj of [Promise, Promise.prototype]) { + let propNames = Object.getOwnPropertyNames(obj); + propNames = propNames.concat(Object.getOwnPropertySymbols(obj)); + for (var propName of propNames) { + if ((propName == "prototype" || + propName == Symbol.hasInstance) && + obj == Promise) { + // They're not configurable. + continue; + } + Object.defineProperty(obj, propName, + { get: vendGetter(propName), set: vendSetter(propName) }); + } + } + } catch (e) { + // Something went wrong. Save that info so the test can check for it. + setupThrew = e; + } + </script> +</html> diff --git a/dom/promise/tests/mochitest.toml b/dom/promise/tests/mochitest.toml new file mode 100644 index 0000000000..e7171b5ccf --- /dev/null +++ b/dom/promise/tests/mochitest.toml @@ -0,0 +1,44 @@ +[DEFAULT] +support-files = ["promise_uncatchable_exception.js"] + +["test_bug883683.html"] + +["test_promise.html"] + +["test_promise_and_timeout_ordering.html"] +support-files = ["file_promise_and_timeout_ordering.js"] + +["test_promise_and_timeout_ordering_workers.html"] +support-files = ["file_promise_and_timeout_ordering.js"] + +["test_promise_argument.html"] +support-files = ["file_promise_argument_tests.js"] +skip-if = ["!debug"] + +["test_promise_callback_retval.html"] +support-files = ["file_promise_argument_tests.js"] +skip-if = ["!debug"] + +["test_promise_retval.html"] +support-files = ["file_promise_retval_tests.js"] +skip-if = ["!debug"] + +["test_promise_uncatchable_exception.html"] +skip-if = ["!debug"] + +["test_promise_utils.html"] + +["test_resolve.html"] + +["test_resolver_return_value.html"] + +["test_species_getter.html"] + +["test_thenable_vs_promise_ordering.html"] + +["test_webassembly_compile.html"] +support-files = [ + "test_webassembly_compile_sample.wasm", + "test_webassembly_compile_worker.js", + "test_webassembly_compile_worker_terminate.js", +] diff --git a/dom/promise/tests/promise_uncatchable_exception.js b/dom/promise/tests/promise_uncatchable_exception.js new file mode 100644 index 0000000000..eafc9e5448 --- /dev/null +++ b/dom/promise/tests/promise_uncatchable_exception.js @@ -0,0 +1,11 @@ +/* global TestFunctions */ + +postMessage("Done", "*"); + +var p = new Promise(function (resolve, reject) { + TestFunctions.throwUncatchableException(); + ok(false, "Shouldn't get here!"); +}).catch(function (exception) { + ok(false, "Shouldn't get here!"); +}); +ok(false, "Shouldn't get here!"); diff --git a/dom/promise/tests/test_bug883683.html b/dom/promise/tests/test_bug883683.html new file mode 100644 index 0000000000..1b31e32330 --- /dev/null +++ b/dom/promise/tests/test_bug883683.html @@ -0,0 +1,41 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Promise - bug 883683</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"><!-- + +function runTest() { + [{}, {}, {}, {}, {}].reduce(Promise.reject.bind(Promise)); + ok(true, "No leaks with reject?"); + + [{}, {}, {}, {}, {}].reduce(Promise.resolve.bind(Promise)); + ok(true, "No leaks with resolve?"); + + [{}, {}, {}, {}, {}].reduce(function(a, b, c, d) { return new Promise(function(r1, r2) { throw a; }); }); + ok(true, "No leaks with exception?"); + + [{}, {}, {}, {}, {}].reduce(function(a, b, c, d) { return new Promise(function(r1, r2) { }); }); + ok(true, "No leaks with empty promise?"); + + SimpleTest.finish(); +} + +SimpleTest.waitForExplicitFinish(); +runTest(); +// --> +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_on_new_promise.html b/dom/promise/tests/test_on_new_promise.html new file mode 100644 index 0000000000..195707f1d7 --- /dev/null +++ b/dom/promise/tests/test_on_new_promise.html @@ -0,0 +1,45 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> + +<!-- +Bug 1083210 - Sanity test for interaction between DOM promises and +Debugger.prototype.onNewPromise. +--> + +<html> +<head> + <title>Test for interaction with SpiderMonkey's Debugger.prototype.onNewPromise</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> + <script type="application/javascript"> + is(Object.prototype.toString.call(new Promise(function() {})), + "[object Promise]", + "We should have the native DOM promise implementation."); + + const {addDebuggerToGlobal} = ChromeUtils.importESModule("resource://gre/modules/jsdebugger.sys.mjs"); + var dbgGlobal = new Cu.Sandbox(document.nodePrincipal, + {freshCompartment: true}); + addDebuggerToGlobal(dbgGlobal); + var dbg = new dbgGlobal.Debugger(this); + + var wrappedPromise; + dbg.onNewPromise = function(wp) { wrappedPromise = wp; }; + + var promise = new Promise(function() {}); + // eslint-disable-next-line no-debugger + debugger; + ok(wrappedPromise); + is(wrappedPromise.unsafeDereference(), promise); + </script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_on_promise_settled.html b/dom/promise/tests/test_on_promise_settled.html new file mode 100644 index 0000000000..b40475206b --- /dev/null +++ b/dom/promise/tests/test_on_promise_settled.html @@ -0,0 +1,53 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> + +<!-- +Bug 1084065 - Sanity test for interaction between DOM promises and +Debugger.prototype.onPromiseResolved. +--> + +<html> +<head> + <title>Test for interaction with SpiderMonkey's Debugger.prototype.onNewPromise</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> + <script type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + is(Object.prototype.toString.call(new Promise(function() {})), + "[object Promise]", + "We should have the native DOM promise implementation."); + + const {addDebuggerToGlobal} = ChromeUtils.importESModule("resource://gre/modules/jsdebugger.sys.mjs"); + var dbgGlobal = new Cu.Sandbox(document.nodePrincipal, + {freshCompartment: true}); + addDebuggerToGlobal(dbgGlobal); + var dbg = new dbgGlobal.Debugger(this); + + var wrappedPromise; + dbg.onPromiseSettled = function(wp) { wrappedPromise = wp; }; + + var promise = Promise.resolve(); + promise + .then(function() { + ok(wrappedPromise); + is(wrappedPromise.unsafeDereference(), promise); + dbg.onPromiseSettled = undefined; + }) + .catch(function(e) { + ok(false, "Got an unexpected error: " + e); + }) + .then(SimpleTest.finish); + </script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_on_promise_settled_duplicates.html b/dom/promise/tests/test_on_promise_settled_duplicates.html new file mode 100644 index 0000000000..e11f4eaa60 --- /dev/null +++ b/dom/promise/tests/test_on_promise_settled_duplicates.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> + +<!-- +Bug 1084065 - Test that Debugger.prototype.onPromiseResolved doesn't get dupes. +--> + +<html> +<head> + <title>Test for interaction with SpiderMonkey's Debugger.prototype.onNewPromise</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> + <script type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + is(Object.prototype.toString.call(new Promise(function() {})), + "[object Promise]", + "We should have the native DOM promise implementation."); + + const {addDebuggerToGlobal} = ChromeUtils.importESModule("resource://gre/modules/jsdebugger.sys.mjs"); + var dbgGlobal = new Cu.Sandbox(document.nodePrincipal, + {freshCompartment: true}); + addDebuggerToGlobal(dbgGlobal); + var dbg = new dbgGlobal.Debugger(this); + + var seen = new Set(); + dbg.onPromiseSettled = function(wp) { + is(seen.has(wp), false); + seen.add(wp); + }; + + var promise = new Promise(function(fulfill, reject) { + fulfill(1); + fulfill(2); + fulfill(3); + }); + + promise + .then(function() { + dbg.onPromiseSettled = undefined; + }) + .catch(function(e) { + ok(false, "Got an unexpected error: " + e); + }) + .then(SimpleTest.finish); + </script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise.html b/dom/promise/tests/test_promise.html new file mode 100644 index 0000000000..7c724daf51 --- /dev/null +++ b/dom/promise/tests/test_promise.html @@ -0,0 +1,844 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Basic Promise Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"><!-- + +function promiseResolve() { + ok(Promise, "Promise object should exist"); + + var promise = new Promise(function(resolve, reject) { + ok(resolve, "Promise.resolve exists"); + ok(reject, "Promise.reject exists"); + + resolve(42); + }); + promise.then(function(what) { + ok(true, "Then - resolveCb has been called"); + is(what, 42, "ResolveCb received 42"); + runTest(); + }, function() { + ok(false, "Then - rejectCb has been called"); + runTest(); + }); +} + +function promiseResolveNoArg() { + var promise = new Promise(function(resolve, reject) { + ok(resolve, "Promise.resolve exists"); + ok(reject, "Promise.reject exists"); + + resolve(); + }); + promise.then(function(what) { + ok(true, "Then - resolveCb has been called"); + is(what, undefined, "ResolveCb received undefined"); + runTest(); + }, function() { + ok(false, "Then - rejectCb has been called"); + runTest(); + }); +} + +function promiseReject() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + promise.then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, 42, "RejectCb received 42"); + runTest(); + }); +} + +function promiseRejectNoHandler() { + // This test only checks that the code that reports unhandled errors in the + // Promises implementation does not crash or leak. + + new Promise(function(res, rej) { + // eslint-disable-next-line no-undef + noSuchMethod(); + }); + runTest(); +} + +function promiseRejectNoArg() { + var promise = new Promise(function(resolve, reject) { + reject(); + }); + promise.then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, undefined, "RejectCb received undefined"); + runTest(); + }); +} + +function promiseException() { + var promise = new Promise(function(resolve, reject) { + // eslint-disable-next-line no-throw-literal + throw 42; + }); + promise.then(function(what) { + ok(false, "Then - resolveCb has been called"); + runTest(); + }, function(what) { + ok(true, "Then - rejectCb has been called"); + is(what, 42, "RejectCb received 42"); + runTest(); + }); +} + +function promiseGC() { + var resolve; + var promise = new Promise(function(r1, r2) { + resolve = r1; + }); + promise.then(function(what) { + ok(true, "Then - promise is still alive"); + runTest(); + }); + + promise = null; + + SpecialPowers.gc(); + SpecialPowers.forceGC(); + SpecialPowers.forceCC(); + + resolve(42); +} + +function promiseAsync_TimeoutResolveThen() { + var handlerExecuted = false; + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + Promise.resolve().then(function() { + handlerExecuted = true; + }); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_ResolveTimeoutThen() { + var handlerExecuted = false; + + var promise = Promise.resolve(); + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + promise.then(function() { + handlerExecuted = true; + }); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_ResolveThenTimeout() { + var handlerExecuted = false; + + Promise.resolve().then(function() { + handlerExecuted = true; + }); + + setTimeout(function() { + ok(handlerExecuted, "Handler should have been called before the timeout."); + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }, 0); + + ok(!handlerExecuted, "Handlers are not called before 'then' returns."); +} + +function promiseAsync_SyncXHR() { + var handlerExecuted = false; + + Promise.resolve().then(function() { + handlerExecuted = true; + + // Allow other assertions to run so the test could fail before the next one. + setTimeout(runTest, 0); + }); + + ok(!handlerExecuted, "Handlers are not called until the next microtask."); + + var xhr = new XMLHttpRequest(); + xhr.open("GET", "testXHR.txt", false); + xhr.send(null); + + ok(!handlerExecuted, "Sync XHR should not trigger microtask execution."); +} + +function promiseDoubleThen() { + var steps = 0; + var promise = new Promise(function(r1, r2) { + r1(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + steps++; + }, function(what) { + ok(false, "Then.reject has been called"); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(steps, 1, "Then.resolve - step == 1"); + is(what, 42, "Value == 42"); + runTest(); + }, function(what) { + ok(false, "Then.reject has been called"); + }); +} + +function promiseThenException() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + // eslint-disable-next-line no-throw-literal + throw "booh"; + }).catch(function(e) { + ok(true, "window.onerror has been called!"); + runTest(); + }); +} + +function promiseThenCatchThen() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + var promise2 = promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + return what + 1; + }, function(what) { + ok(false, "Then.reject has been called"); + }); + + isnot(promise, promise2, "These 2 promise objs are different"); + + promise2.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + return what + 1; + }, function(what) { + ok(false, "Then.reject has been called"); + }).catch(function() { + ok(false, "Catch has been called"); + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }, function(what) { + ok(false, "Then.reject has been called"); + }); +} + +function promiseThenNoArg() { + var promise = new Promise(function(resolve, reject) { + resolve(42); + }); + + var clone = promise.then(); + isnot(promise, clone, "These 2 promise objs are different"); + promise.then(function(v) { + clone.then(function(cv) { + is(v, cv, "Both resolve to the same value"); + runTest(); + }); + }); +} + +function promiseThenUndefinedResolveFunction() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + try { + promise.then(undefined, function(v) { + is(v, 42, "Promise rejected with 42"); + runTest(); + }); + } catch (e) { + ok(false, "then should not throw on undefined resolve function"); + } +} + +function promiseThenNullResolveFunction() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + try { + promise.then(null, function(v) { + is(v, 42, "Promise rejected with 42"); + runTest(); + }); + } catch (e) { + ok(false, "then should not throw on null resolve function"); + } +} + +function promiseRejectThenCatchThen() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + var promise2 = promise.then(function(what) { + ok(false, "Then.resolve has been called"); + }, function(what) { + ok(true, "Then.reject has been called"); + is(what, 42, "Value == 42"); + return what + 1; + }); + + isnot(promise, promise2, "These 2 promise objs are different"); + + promise2.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + return what + 1; + }).catch(function(what) { + ok(false, "Catch has been called"); + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }); +} + +function promiseRejectThenCatchThen2() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + promise.then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 42, "Value == 42"); + return what + 1; + }).catch(function(what) { + is(what, 42, "Value == 42"); + ok(true, "Catch has been called"); + return what + 1; + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 43, "Value == 43"); + runTest(); + }); +} + +function promiseRejectThenCatchExceptionThen() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + promise.then(function(what) { + ok(false, "Then.resolve has been called"); + }, function(what) { + ok(true, "Then.reject has been called"); + is(what, 42, "Value == 42"); + // eslint-disable-next-line no-throw-literal + throw (what + 1); + }).catch(function(what) { + ok(true, "Catch has been called"); + is(what, 43, "Value == 43"); + return what + 1; + }).then(function(what) { + ok(true, "Then.resolve has been called"); + is(what, 44, "Value == 44"); + runTest(); + }); +} + +function promiseThenCatchOrderingResolve() { + var global = 0; + var f = new Promise(function(r1, r2) { + r1(42); + }); + + f.then(function() { + f.then(function() { + global++; + }); + f.catch(function() { + global++; + }); + f.then(function() { + global++; + }); + setTimeout(function() { + is(global, 2, "Many steps... should return 2"); + runTest(); + }, 0); + }); +} + +function promiseThenCatchOrderingReject() { + var global = 0; + var f = new Promise(function(r1, r2) { + r2(42); + }); + + f.then(function() {}, function() { + f.then(function() { + global++; + }); + f.catch(function() { + global++; + }); + f.then(function() {}, function() { + global++; + }); + setTimeout(function() { + is(global, 2, "Many steps... should return 2"); + runTest(); + }, 0); + }); +} + +function promiseCatchNoArg() { + var promise = new Promise(function(resolve, reject) { + reject(42); + }); + + var clone = promise.catch(); + isnot(promise, clone, "These 2 promise objs are different"); + promise.catch(function(v) { + clone.catch(function(cv) { + is(v, cv, "Both reject to the same value"); + runTest(); + }); + }); +} + +function promiseNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(res, rej) { + ok(true, "Nested promise is executed"); + res(42); + })); + }).then(function(value) { + is(value, 42, "Nested promise is executed and then == 42"); + runTest(); + }); +} + +function promiseNestedNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(res, rej) { + ok(true, "Nested promise is executed"); + res(42); + }).then(function(what) { return what + 1; })); + }).then(function(value) { + is(value, 43, "Nested promise is executed and then == 43"); + runTest(); + }); +} + +function promiseWrongNestedPromise() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(r, r2) { + ok(true, "Nested promise is executed"); + r(42); + })); + reject(42); + }).then(function(value) { + is(value, 42, "Nested promise is executed and then == 42"); + runTest(); + }, function(value) { + ok(false, "This is wrong"); + }); +} + +function promiseLoop() { + new Promise(function(resolve, reject) { + resolve(new Promise(function(res, rej) { + ok(true, "Nested promise is executed"); + res(new Promise(function(resInner, rejInner) { + ok(true, "Nested nested promise is executed"); + resInner(42); + })); + })); + }).then(function(value) { + is(value, 42, "Nested nested promise is executed and then == 42"); + runTest(); + }, function(value) { + ok(false, "This is wrong"); + }); +} + +function promiseStaticReject() { + var promise = Promise.reject(42); + promise.then(function(what) { + ok(false, "This should not be called"); + }, function(what) { + is(what, 42, "Value == 42"); + runTest(); + }); +} + +function promiseStaticResolve() { + var promise = Promise.resolve(42); + promise.then(function(what) { + is(what, 42, "Value == 42"); + runTest(); + }, function() { + ok(false, "This should not be called"); + }); +} + +function promiseResolveNestedPromise() { + var promise = Promise.resolve(new Promise(function(r, r2) { + ok(true, "Nested promise is executed"); + r(42); + }, function() { + ok(false, "This should not be called"); + })); + promise.then(function(what) { + is(what, 42, "Value == 42"); + runTest(); + }, function() { + ok(false, "This should not be called"); + }); +} + +function promiseSimpleThenableResolve() { + var thenable = { then(resolve) { resolve(5); } }; + var promise = new Promise(function(resolve, reject) { + resolve(thenable); + }); + + promise.then(function(v) { + ok(v === 5, "promiseSimpleThenableResolve"); + runTest(); + }, function(e) { + ok(false, "promiseSimpleThenableResolve: Should not reject"); + }); +} + +function promiseSimpleThenableReject() { + var thenable = { then(resolve, reject) { reject(5); } }; + var promise = new Promise(function(resolve, reject) { + resolve(thenable); + }); + + promise.then(function() { + ok(false, "promiseSimpleThenableReject: Should not resolve"); + runTest(); + }, function(e) { + ok(e === 5, "promiseSimpleThenableReject"); + runTest(); + }); +} + +function promiseThenableThrowsBeforeCallback() { + var thenable = { then(resolve) { + throw new TypeError("Hi there"); + + // eslint-disable-next-line no-unreachable + resolve(5); + }}; + + var promise = Promise.resolve(thenable); + promise.then(function(v) { + ok(false, "promiseThenableThrowsBeforeCallback: Should've rejected"); + runTest(); + }, function(e) { + ok(e instanceof TypeError, "promiseThenableThrowsBeforeCallback"); + runTest(); + }); +} + +function promiseThenableThrowsAfterCallback() { + var thenable = { then(resolve) { + resolve(5); + throw new TypeError("Hi there"); + }}; + + var promise = Promise.resolve(thenable); + promise.then(function(v) { + ok(v === 5, "promiseThenableThrowsAfterCallback"); + runTest(); + }, function(e) { + ok(false, "promiseThenableThrowsAfterCallback: Should've resolved"); + runTest(); + }); +} + +function promiseThenableRejectThenResolve() { + var thenable = { then(resolve, reject) { + reject(new TypeError("Hi there")); + resolve(5); + }}; + + var promise = Promise.resolve(thenable); + promise.then(function(v) { + ok(false, "promiseThenableRejectThenResolve should have rejected"); + runTest(); + }, function(e) { + ok(e instanceof TypeError, "promiseThenableRejectThenResolve"); + runTest(); + }); +} + +function promiseWithThenReplaced() { + // Ensure that we call the 'then' on the promise and not the internal then. + var promise = new Promise(function(resolve, reject) { + resolve(5); + }); + + // Rogue `then` always rejects. + promise.then = function(onFulfill, onReject) { + onReject(new TypeError("Foo")); + }; + + var promise2 = Promise.resolve(promise); + promise2.then(function(v) { + ok(false, "promiseWithThenReplaced: Should've rejected"); + runTest(); + }, function(e) { + ok(e instanceof TypeError, "promiseWithThenReplaced"); + runTest(); + }); +} + +function promiseStrictHandlers() { + var promise = Promise.resolve(5); + promise.then(function() { + "use strict"; + ok(this === undefined, "Strict mode callback should have this === undefined."); + runTest(); + }); +} + +function promiseStrictExecutorThisArg() { + new Promise(function(resolve, reject) { + "use strict"; + ok(this === undefined, "thisArg should be undefined."); + runTest(); + }); +} + +function promiseResolveArray() { + var p = Promise.resolve([1, 2, 3]); + ok(p instanceof Promise, "Should return a Promise."); + p.then(function(v) { + ok(Array.isArray(v), "Resolved value should be an Array"); + is(v.length, 3, "Length should match"); + is(v[0], 1, "Resolved value should match original"); + is(v[1], 2, "Resolved value should match original"); + is(v[2], 3, "Resolved value should match original"); + runTest(); + }); +} + +function promiseResolveThenable() { + var p = Promise.resolve({ then(onFulfill, onReject) { onFulfill(2); } }); + ok(p instanceof Promise, "Should cast to a Promise."); + p.then(function(v) { + is(v, 2, "Should resolve to 2."); + runTest(); + }, function(e) { + ok(false, "promiseResolveThenable should've resolved"); + runTest(); + }); +} + +function promiseResolvePromise() { + var original = Promise.resolve(true); + var cast = Promise.resolve(original); + + ok(cast instanceof Promise, "Should cast to a Promise."); + is(cast, original, "Should return original Promise."); + cast.then(function(v) { + is(v, true, "Should resolve to true."); + runTest(); + }); +} + +// Bug 1009569. +// Ensure that thenables are run on a clean stack asynchronously. +// Test case adopted from +// https://gist.github.com/getify/d64bb01751b50ed6b281#file-bug1-js. +function promiseResolveThenableCleanStack() { + function immed(s) { x++; s(); } + function incX() { x++; } + + var x = 0; + var thenable = { then: immed }; + var results = []; + + var p = Promise.resolve(thenable).then(incX); + results.push(x); + + // check what happens after all "next cycle" steps + // have had a chance to complete + setTimeout(function() { + // Result should be [0, 2] since `thenable` will be called async. + is(results[0], 0, "Expected thenable to be called asynchronously"); + // See Bug 1023547 comment 13 for why this check has to be gated on p. + p.then(function() { + results.push(x); + is(results[1], 2, "Expected thenable to be called asynchronously"); + runTest(); + }); + }, 1000); +} + +// Bug 1008467 - Promise fails with "too much recursion". +// The bug was that the callbacks passed to a thenable would resolve the +// promise synchronously when the fulfill handler returned a non-thenable. +// +// For example: +// var p = new Promise(function(resolve) { +// resolve(5); +// }); +// var m = Promise.resolve(p); +// +// At this point `m` is a Promise that is resolved with a thenable `p`, so it +// calls `p.then()` with two callbacks, both of which would synchronously resolve +// `m` when `p` invoked them (on account of itself being resolved, possibly +// synchronously. A chain of these 'Promise resolved by a Promise' would lead to +// stack overflow. +function promiseTestAsyncThenableResolution() { + var k = 3000; + Promise.resolve().then(function next() { + k--; + if (k > 0) return Promise.resolve().then(next); + return undefined; + }).then(function() { + ok(true, "Resolution of a chain of thenables should not be synchronous."); + runTest(); + }); +} + +// Bug 1062323 +function promiseWrapperAsyncResolution() { + var p = new Promise(function(resolve, reject) { + resolve(); + }); + + var results = []; + var q = p.then(function() { + results.push("1-1"); + }).then(function() { + results.push("1-2"); + }).then(function() { + results.push("1-3"); + }); + + var r = p.then(function() { + results.push("2-1"); + }).then(function() { + results.push("2-2"); + }).then(function() { + results.push("2-3"); + }); + + Promise.all([q, r]).then(function() { + var match = results[0] == "1-1" && + results[1] == "2-1" && + results[2] == "1-2" && + results[3] == "2-2" && + results[4] == "1-3" && + results[5] == "2-3"; + info(results); + ok(match, "Chained promises should resolve asynchronously."); + runTest(); + }, function() { + ok(false, "promiseWrapperAsyncResolution: One of the promises failed."); + runTest(); + }); +} + +var tests = [ promiseResolve, promiseReject, + promiseException, promiseGC, + promiseAsync_TimeoutResolveThen, + promiseAsync_ResolveTimeoutThen, + promiseAsync_ResolveThenTimeout, + promiseAsync_SyncXHR, + promiseDoubleThen, promiseThenException, + promiseThenCatchThen, promiseRejectThenCatchThen, + promiseRejectThenCatchThen2, + promiseRejectThenCatchExceptionThen, + promiseThenCatchOrderingResolve, + promiseThenCatchOrderingReject, + promiseNestedPromise, promiseNestedNestedPromise, + promiseWrongNestedPromise, promiseLoop, + promiseStaticReject, promiseStaticResolve, + promiseResolveNestedPromise, + promiseResolveNoArg, + promiseRejectNoArg, + promiseThenNoArg, + promiseThenUndefinedResolveFunction, + promiseThenNullResolveFunction, + promiseCatchNoArg, + promiseRejectNoHandler, + promiseSimpleThenableResolve, + promiseSimpleThenableReject, + promiseThenableThrowsBeforeCallback, + promiseThenableThrowsAfterCallback, + promiseThenableRejectThenResolve, + promiseWithThenReplaced, + promiseStrictHandlers, + promiseStrictExecutorThisArg, + promiseResolveArray, + promiseResolveThenable, + promiseResolvePromise, + promiseResolveThenableCleanStack, + promiseTestAsyncThenableResolution, + promiseWrapperAsyncResolution, + ]; + +function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); +} + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestFlakyTimeout("untriaged"); +runTest(); +// --> +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_and_timeout_ordering.html b/dom/promise/tests/test_promise_and_timeout_ordering.html new file mode 100644 index 0000000000..e92e928e75 --- /dev/null +++ b/dom/promise/tests/test_promise_and_timeout_ordering.html @@ -0,0 +1,16 @@ +<!DOCTYPE html> +<meta charset=utf-8> +<title>Test for promise and timeout ordering</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<div id="log"></div> +<script> +/* global async_test, assert_equals */ +var t = async_test("Promise callbacks should run immediately after the setTimeout handler that enqueues them"); +var origPostMessage = window.postMessage; +window.postMessage = function(msg) { origPostMessage.call(window, msg, "*"); }; +window.onmessage = t.step_func_done(function(e) { + assert_equals(e.data, "t1start, t1end, promise, t2"); +}); +</script> +<script src="file_promise_and_timeout_ordering.js"></script> diff --git a/dom/promise/tests/test_promise_and_timeout_ordering_workers.html b/dom/promise/tests/test_promise_and_timeout_ordering_workers.html new file mode 100644 index 0000000000..85fd4c0019 --- /dev/null +++ b/dom/promise/tests/test_promise_and_timeout_ordering_workers.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<meta charset=utf-8> +<title>Test for promise and timeout ordering in workers</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<div id="log"></div> +<script> +/* global async_test, assert_equals */ +var t = async_test("Promise callbacks in workers should run immediately after the setTimeout handler that enqueues them"); +var w = new Worker("file_promise_and_timeout_ordering.js"); +w.onmessage = t.step_func_done(function(e) { + assert_equals(e.data, "t1start, t1end, promise, t2"); +}); +</script> diff --git a/dom/promise/tests/test_promise_argument.html b/dom/promise/tests/test_promise_argument.html new file mode 100644 index 0000000000..22343ef00f --- /dev/null +++ b/dom/promise/tests/test_promise_argument.html @@ -0,0 +1,49 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1323324 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1323324</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script src="file_promise_argument_tests.js"></script> + <script type="application/javascript"> + /** Test for Bug 1323324 **/ + SimpleTest.waitForExplicitFinish(); + + var globalWrapper; + function verifyPromiseGlobal(p, global, msg) { + // SpecialPowers.Cu.getGlobalForObject returns a SpecialPowers wrapper for + // the actual global. We want to grab the underlying object. + globalWrapper = SpecialPowers.Cu.getGlobalForObject(p); + is(SpecialPowers.unwrap(globalWrapper), global, + msg + " should come from " + global.label); + } + + const isXrayArgumentTest = false; + + function getPromise(global, arg) { + return global.TestFunctions.passThroughPromise(arg); + } + + addLoadEvent(function() { + frames[0].label = "child"; + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + runPromiseArgumentTests.bind(undefined, + SimpleTest.finish)); + }); + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1323324">Mozilla Bug 1323324</a> +<p id="display"></p> +<div id="content" style="display: none"> + <!-- A subframe so we have another global to work with --> + <iframe></iframe> +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_argument_xrays.html b/dom/promise/tests/test_promise_argument_xrays.html new file mode 100644 index 0000000000..f3a234cf6d --- /dev/null +++ b/dom/promise/tests/test_promise_argument_xrays.html @@ -0,0 +1,90 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1233324 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1233324</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://global/skin"/> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1233324">Mozilla Bug 1233324</a> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe id="t" src="http://example.org/chrome/dom/promise/tests/file_promise_xrays.html"></iframe> +</div> + +<pre id="test"> +<script src="file_promise_argument_tests.js"></script> +<script type="application/javascript"> + +var win = $("t").contentWindow; + +/** Test for Bug 1233324 **/ +SimpleTest.waitForExplicitFinish(); + +function testLoadComplete() { + is(win.location.href, $("t").src, "Should have loaded the right thing"); + nextTest(); +} + +function testHaveXray() { + is(typeof win.Promise.race, "function", "Should see a race() function"); + var exception; + try { + win.Promise.wrappedJSObject.race; + } catch (e) { + exception = e; + } + is(exception, "Getting race", "Should have thrown the right exception"); + is(win.wrappedJSObject.setupThrew, false, "Setup should not have thrown"); + nextTest(); +} + +function verifyPromiseGlobal(p, _, msg) { + // SpecialPowers.Cu.getGlobalForObject returns a SpecialPowers wrapper for + // the actual global. We want to grab the underlying object. + var global = SpecialPowers.unwrap(SpecialPowers.Cu.getGlobalForObject(p)); + + // We expect our global to always be "window" here, because we're working over + // Xrays. + is(global, window, msg + " should come from " + window.label); +} + +const isXrayArgumentTest = true; + +function getPromise(global, arg) { + return global.TestFunctions.passThroughPromise(arg); +} + +function testPromiseArgumentConversions() { + runPromiseArgumentTests(nextTest); +} + +var tests = [ + testLoadComplete, + testHaveXray, + testPromiseArgumentConversions, +]; + +function nextTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + tests.shift()(); +} + +addLoadEvent(function() { + frames[0].label = "child"; + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + nextTest); +}); + +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_callback_retval.html b/dom/promise/tests/test_promise_callback_retval.html new file mode 100644 index 0000000000..332c370a3e --- /dev/null +++ b/dom/promise/tests/test_promise_callback_retval.html @@ -0,0 +1,53 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1323324 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1323324</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script src="file_promise_argument_tests.js"></script> + <script type="application/javascript"> + /* global TestFunctions */ + + /** Test for Bug 1323324 **/ + SimpleTest.waitForExplicitFinish(); + + var globalWrapper; + function verifyPromiseGlobal(p, global, msg) { + // SpecialPowers.Cu.getGlobalForObject returns a SpecialPowers wrapper for + // the actual global. We want to grab the underlying object. + globalWrapper = SpecialPowers.Cu.getGlobalForObject(p); + is(SpecialPowers.unwrap(globalWrapper), global, + msg + " should come from " + global.label); + } + + const isXrayArgumentTest = false; + + var func; + function getPromise(global, arg) { + func = new global.Function("x", "return x").bind(undefined, arg); + return TestFunctions.passThroughCallbackPromise(func); + } + + addLoadEvent(function() { + frames[0].label = "child"; + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + runPromiseArgumentTests.bind(undefined, + SimpleTest.finish)); + }); + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1323324">Mozilla Bug 1323324</a> +<p id="display"></p> +<div id="content" style="display: none"> + <!-- A subframe so we have another global to work with --> + <iframe></iframe> +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_job_with_bind_from_discarded_iframe.html b/dom/promise/tests/test_promise_job_with_bind_from_discarded_iframe.html new file mode 100644 index 0000000000..1cea250072 --- /dev/null +++ b/dom/promise/tests/test_promise_job_with_bind_from_discarded_iframe.html @@ -0,0 +1,63 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1723124. +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1723124.</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://global/skin"/> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1723124.">Mozilla Bug 1723124.</a> + +<iframe id="frame" src="http://example.org/chrome/dom/promise/tests/file_promise_job_with_bind_from_discarded_iframe.html"></iframe> + +<pre id="test"> +<script type="text/javascript"> +/** Test for Bug 1723124. **/ +SimpleTest.waitForExplicitFinish(); + +var frame = document.getElementById("frame"); + +SimpleTest.waitForCondition(() => { + var result = frame.contentDocument.getElementById("result"); + if (!result) { + return false; + } + // Wait for the iframe's script to check if it has no access to SpecialPowers. + return result.textContent == "ok"; +}, () => { + var iframe_bind = frame.contentWindow.Function.prototype.bind; + // Removing iframe from the tree discards the browsing context, + // and promise jobs in the iframe global stops working. + frame.remove(); + + Promise.resolve(10) + .then(function (v) { + // Handler in top-level realm, without bind. + // + // This job is created with the top-level realm, and should be called. + is(v, 10, "normal function should get the value from promise"); + return 20; + }, function () { + ok(false, "unexpectedly rejected"); + }) + .then(iframe_bind.call(function (bound_arg, v) { + // Handler in top-level realm, with bind in discarded iframe. + // + // This job is also created with the top-level realm, and should be + // called. + is(v, 20, "bound function should get the value from promise"); + is(bound_arg, 30, "bound function should get the arguments from bind"); + SimpleTest.finish(); + }, this, 30), function () { + ok(false, "unexpectedly rejected"); + }); +}); +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_retval.html b/dom/promise/tests/test_promise_retval.html new file mode 100644 index 0000000000..e425b8e203 --- /dev/null +++ b/dom/promise/tests/test_promise_retval.html @@ -0,0 +1,51 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1436276. +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1436276.</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script src="file_promise_retval_tests.js"></script> + <script type="application/javascript"> + /** Test for Bug 1436276. **/ + SimpleTest.waitForExplicitFinish(); + + function verifyPromiseGlobal(p, global, msg) { + // SpecialPowers.Cu.getGlobalForObject returns a SpecialPowers wrapper for + // the actual global. We want to grab the underlying object. + var globalWrapper = SpecialPowers.Cu.getGlobalForObject(p); + is(SpecialPowers.unwrap(globalWrapper), global, + msg + " should come from " + global.label); + } + + function expectedExceptionGlobal(global) { + // We should end up with an exception from "global". + return global; + } + + function getPromise(global, arg) { + return global.TestFunctions.passThroughPromise(arg); + } + + addLoadEvent(function() { + frames[0].label = "child"; + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + runPromiseRetvalTests.bind(undefined, + SimpleTest.finish)); + }); + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1323324">Mozilla Bug 1323324</a> +<p id="display"></p> +<div id="content" style="display: none"> + <!-- A subframe so we have another global to work with --> + <iframe></iframe> +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_retval_xrays.html b/dom/promise/tests/test_promise_retval_xrays.html new file mode 100644 index 0000000000..1270e3a3bb --- /dev/null +++ b/dom/promise/tests/test_promise_retval_xrays.html @@ -0,0 +1,94 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1436276. +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1436276.</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://global/skin"/> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1436276.">Mozilla Bug 1436276.</a> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe id="t" src="http://example.org/chrome/dom/promise/tests/file_promise_xrays.html"></iframe> +</div> + +<pre id="test"> +<script src="file_promise_retval_tests.js"></script> +<script type="application/javascript"> + +var win = $("t").contentWindow; + +/** Test for Bug 1233324 **/ +SimpleTest.waitForExplicitFinish(); + +function testLoadComplete() { + is(win.location.href, $("t").src, "Should have loaded the right thing"); + nextTest(); +} + +function testHaveXray() { + is(typeof win.Promise.race, "function", "Should see a race() function"); + var exception; + try { + win.Promise.wrappedJSObject.race; + } catch (e) { + exception = e; + } + is(exception, "Getting race", "Should have thrown the right exception"); + is(win.wrappedJSObject.setupThrew, false, "Setup should not have thrown"); + nextTest(); +} + +function verifyPromiseGlobal(p, _, msg) { + // SpecialPowers.Cu.getGlobalForObject returns a SpecialPowers wrapper for + // the actual global. We want to grab the underlying object. + var global = SpecialPowers.unwrap(SpecialPowers.Cu.getGlobalForObject(p)); + + // We expect our global to always be "window" here, because we're working over + // Xrays. + is(global, window, msg + " should come from " + window.label); +} + +function expectedExceptionGlobal(_) { + // We should end up with an exception from "window" no matter what global + // was involved to start with, because we're working over Xrays. + return window; +} + +function getPromise(global, arg) { + return global.TestFunctions.passThroughPromise(arg); +} + +function testPromiseRetvals() { + runPromiseRetvalTests(nextTest); +} + +var tests = [ + testLoadComplete, + testHaveXray, + testPromiseRetvals, +]; + +function nextTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + tests.shift()(); +} + +addLoadEvent(function() { + frames[0].label = "child"; + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + nextTest); +}); + +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_uncatchable_exception.html b/dom/promise/tests/test_promise_uncatchable_exception.html new file mode 100644 index 0000000000..2bb6f1fe17 --- /dev/null +++ b/dom/promise/tests/test_promise_uncatchable_exception.html @@ -0,0 +1,35 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Promise - uncatchable exceptions</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"> + +onmessage = function(evt) { + ok(true, "finished"); + SimpleTest.finish(); +}; + +function go() { + var script = document.createElement("script"); + script.src = "promise_uncatchable_exception.js"; + document.body.appendChild(script); +} + +SimpleTest.waitForExplicitFinish(); +SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, go); +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_utils.html b/dom/promise/tests/test_promise_utils.html new file mode 100644 index 0000000000..b20d909351 --- /dev/null +++ b/dom/promise/tests/test_promise_utils.html @@ -0,0 +1,313 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Test for Promise.all, Promise.race</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"><!-- + +function promiseUtilitiesDefined() { + ok(Promise.all, "Promise.all must be defined when Promise is enabled."); + ok(Promise.race, "Promise.race must be defined when Promise is enabled."); + runTest(); +} + +function promiseAllEmptyArray() { + var p = Promise.all([]); + ok(p instanceof Promise, "Return value of Promise.all should be a Promise."); + p.then(function(values) { + ok(Array.isArray(values), "Resolved value should be an array."); + is(values.length, 0, "Resolved array length should match iterable's length."); + runTest(); + }, function() { + ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises."); + runTest(); + }); +} + +function promiseAllArray() { + var p = Promise.all([1, new Date(), Promise.resolve("firefox")]); + ok(p instanceof Promise, "Return value of Promise.all should be a Promise."); + p.then(function(values) { + ok(Array.isArray(values), "Resolved value should be an array."); + is(values.length, 3, "Resolved array length should match iterable's length."); + is(values[0], 1, "Array values should match."); + ok(values[1] instanceof Date, "Array values should match."); + is(values[2], "firefox", "Array values should match."); + runTest(); + }, function() { + ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises."); + runTest(); + }); +} + +function promiseAllIterable() { + function* promiseGen() { + var i = 3; + while (--i) { + yield Promise.resolve(i); + } + + yield new Promise(function(resolve) { + setTimeout(resolve, 10); + }); + } + + Promise.all(promiseGen()).then(function(values) { + is(values.length, 3, "Resolved array length should match iterable's length."); + is(values[0], 2, "Array values should match."); + is(values[1], 1, "Array values should match."); + is(values[2], undefined, "Array values should match."); + runTest(); + }, function(e) { + ok(false, "Promise.all shouldn't fail when an iterable is passed."); + runTest(); + }); +} + +function promiseAllWaitsForAllPromises() { + var arr = [ + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 1), 50); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 2), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, new Promise(function(resolve2) { + resolve2(3); + })), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 4), 20); + }), + ]; + + var p = Promise.all(arr); + p.then(function(values) { + ok(Array.isArray(values), "Resolved value should be an array."); + is(values.length, 4, "Resolved array length should match iterable's length."); + is(values[0], 1, "Array values should match."); + is(values[1], 2, "Array values should match."); + is(values[2], 3, "Array values should match."); + is(values[3], 4, "Array values should match."); + runTest(); + }, function() { + ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises."); + runTest(); + }); +} + +function promiseAllRejectFails() { + var arr = [ + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 1), 50); + }), + new Promise(function(resolve, reject) { + setTimeout(reject.bind(undefined, 2), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 3), 10); + }), + new Promise(function(resolve) { + setTimeout(resolve.bind(undefined, 4), 20); + }), + ]; + + var p = Promise.all(arr); + p.then(function(values) { + ok(false, "Promise.all shouldn't resolve when iterable has rejected Promises."); + runTest(); + }, function(e) { + ok(true, "Promise.all should reject when iterable has rejected Promises."); + is(e, 2, "Rejection value should match."); + runTest(); + }); +} + +function promiseAllCastError() { + var p = Promise.all([Promise.resolve(2), { then() { + throw new ReferenceError("placeholder for nonexistent function call"); + } }]); + ok(p instanceof Promise, "Should cast to a Promise."); + p.then(function(v) { + ok(false, "promiseAllCastError: should've rejected."); + runTest(); + }, function(e) { + ok(e instanceof ReferenceError, "promiseCastThenableError"); + runTest(); + }); +} + +// Check that the resolved array is enumerable. +function promiseAllEnumerable() { + var p = Promise.all([1, new Date(), Promise.resolve("firefox")]); + p.then(function(v) { + var count = 0; + for (let key in v) { + ++count; + ok(v[key] === 1 || v[key] instanceof Date || v[key] === "firefox", + "Enumerated properties don't match."); + } + is(count, 3, "Resolved array from Promise.all should be enumerable"); + runTest(); + }, function(e) { + ok(false, "promiseAllEnumerable: should've resolved."); + runTest(); + }); +} + +function promiseRaceEmpty() { + var p = Promise.race([]); + ok(p instanceof Promise, "Should return a Promise."); + p.then(function() { + ok(false, "Should not resolve"); + }, function() { + ok(false, "Should not reject"); + }); + // Per spec, An empty race never resolves or rejects. + setTimeout(function() { + ok(true); + runTest(); + }, 50); +} + +function promiseRaceValuesArray() { + var p = Promise.race([true, new Date(), 3]); + ok(p instanceof Promise, "Should return a Promise."); + p.then(function(winner) { + is(winner, true, "First value should win."); + runTest(); + }, function(err) { + ok(false, "Should not fail " + err + "."); + runTest(); + }); +} + +function promiseRacePromiseArray() { + var arr = [ + new Promise(function(resolve) { + resolve("first"); + }), + Promise.resolve("second"), + new Promise(function() {}), + new Promise(function(resolve) { + setTimeout(function() { + setTimeout(function() { + resolve("fourth"); + }, 0); + }, 0); + }), + ]; + + var p = Promise.race(arr); + p.then(function(winner) { + is(winner, "first", "First queued resolution should win the race."); + runTest(); + }); +} + +function promiseRaceIterable() { + function* participants() { + yield new Promise(function(resolve) { + setTimeout(resolve, 10, 10); + }); + yield new Promise(function(resolve) { + setTimeout(resolve, 20, 20); + }); + } + + Promise.race(participants()).then(function(winner) { + is(winner, 10, "Winner should be the one that finished earlier."); + runTest(); + }, function(e) { + ok(false, "Promise.race shouldn't throw when an iterable is passed!"); + runTest(); + }); +} + +function promiseRaceReject() { + var p = Promise.race([ + Promise.reject(new Error("Fail bad!")), + new Promise(function(resolve) { + setTimeout(resolve, 0); + }), + ]); + + p.then(function() { + ok(false, "Should not resolve when winning Promise rejected."); + runTest(); + }, function(e) { + ok(true, "Should be rejected"); + ok(e instanceof Error, "Should reject with Error."); + ok(e.message == "Fail bad!", "Message should match."); + runTest(); + }); +} + +function promiseRaceThrow() { + var p = Promise.race([ + new Promise(function(resolve) { + throw new ReferenceError("placeholder for nonexistent function call"); + }), + new Promise(function(resolve) { + setTimeout(resolve, 0); + }), + ]); + + p.then(function() { + ok(false, "Should not resolve when winning Promise had an error."); + runTest(); + }, function(e) { + ok(true, "Should be rejected"); + ok(e instanceof ReferenceError, "Should reject with ReferenceError for function nonExistent()."); + runTest(); + }); +} + +var tests = [ + promiseUtilitiesDefined, + promiseAllEmptyArray, + promiseAllArray, + promiseAllIterable, + promiseAllWaitsForAllPromises, + promiseAllRejectFails, + promiseAllCastError, + promiseAllEnumerable, + + promiseRaceEmpty, + promiseRaceValuesArray, + promiseRacePromiseArray, + promiseRaceIterable, + promiseRaceReject, + promiseRaceThrow, + ]; + +function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); +} + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestFlakyTimeout("untriaged"); +runTest(); +// --> +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_promise_xrays.html b/dom/promise/tests/test_promise_xrays.html new file mode 100644 index 0000000000..8559dbb2a4 --- /dev/null +++ b/dom/promise/tests/test_promise_xrays.html @@ -0,0 +1,365 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1170760 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1170760</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://global/skin"/> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1170760">Mozilla Bug 1170760</a> +<p id="display"></p> +<div id="content" style="display: none"> +<iframe id="t" src="http://example.org/chrome/dom/promise/tests/file_promise_xrays.html"></iframe> +</div> + +<pre id="test"> +<script type="application/javascript"> + +var win = $("t").contentWindow; + +/** Test for Bug 1170760 **/ +SimpleTest.waitForExplicitFinish(); + +function testLoadComplete() { + is(win.location.href, $("t").src, "Should have loaded the right thing"); + nextTest(); +} + +function testHaveXray() { + is(typeof win.Promise.race, "function", "Should see a race() function"); + var exception; + try { + win.Promise.wrappedJSObject.race; + } catch (e) { + exception = e; + } + is(exception, "Getting race", "Should have thrown the right exception"); + is(win.wrappedJSObject.setupThrew, false, "Setup should not have thrown"); + nextTest(); +} + +function testConstructor1() { + var p = new win.Promise(function(resolve, reject) { resolve(win.Promise.resolve(5)); }); + p.then( + function(arg) { + is(arg, 5, "Content Promise constructor resolved with content promise should work"); + }, + function(e) { + ok(false, "Content Promise constructor resolved with content promise should not fail"); + } + ).then(nextTest); +} + +function testConstructor2() { + var p = new win.Promise(function(resolve, reject) { resolve(Promise.resolve(5)); }); + p.then( + function(arg) { + is(arg, 5, "Content Promise constructor resolved with chrome promise should work"); + }, + function(e) { + ok(false, "Content Promise constructor resolved with chrome promise should not fail"); + } + ).then(nextTest); +} + +function testRace1() { + var p = win.Promise.race(new win.Array(1, 2)); + p.then( + function(arg) { + ok(arg == 1 || arg == 2, + "Should get the right value when racing content-side array"); + }, + function(e) { + ok(false, "testRace1 threw exception: " + e); + } + ).then(nextTest); +} + +function testRace2() { + var p = win.Promise.race( + [win.Promise.resolve(1), win.Promise.resolve(2)]); + p.then( + function(arg) { + ok(arg == 1 || arg == 2, + "Should get the right value when racing content-side array of explicit Promises"); + }, + function(e) { + ok(false, "testRace2 threw exception: " + e); + } + ).then(nextTest); +} + +function testRace3() { + // This works with a chrome-side array because we do the iteration + // while still in the Xray compartment. + var p = win.Promise.race([1, 2]); + p.then( + function(arg) { + ok(arg == 1 || arg == 2, + "Should get the right value when racing chrome-side array"); + }, + function(e) { + ok(false, "testRace3 threw exception: " + e); + } + ).then(nextTest); +} + +function testRace4() { + // This works with both content-side and chrome-side Promises because we want + // it to and go to some lengths to make it work. + var p = win.Promise.race([Promise.resolve(1), win.Promise.resolve(2)]); + p.then( + function(arg) { + ok(arg == 1 || arg == 2, + "Should get the right value when racing chrome-side promises"); + }, + function(e) { + ok(false, "testRace4 threw exception: " + e); + } + ).then(nextTest); +} + +function testAll1() { + var p = win.Promise.all(new win.Array(1, 2)); + p.then( + function(arg) { + ok(arg instanceof win.Array, "Should get an Array from Promise.all (1)"); + is(arg[0], 1, "First entry of Promise.all return value should be correct (1)"); + is(arg[1], 2, "Second entry of Promise.all return value should be correct (1)"); + }, + function(e) { + ok(false, "testAll1 threw exception: " + e); + } + ).then(nextTest); +} + +function testAll2() { + var p = win.Promise.all( + [win.Promise.resolve(1), win.Promise.resolve(2)]); + p.then( + function(arg) { + ok(arg instanceof win.Array, "Should get an Array from Promise.all (2)"); + is(arg[0], 1, "First entry of Promise.all return value should be correct (2)"); + is(arg[1], 2, "Second entry of Promise.all return value should be correct (2)"); + }, + function(e) { + ok(false, "testAll2 threw exception: " + e); + } + ).then(nextTest); +} + +function testAll3() { + // This works with a chrome-side array because we do the iteration + // while still in the Xray compartment. + var p = win.Promise.all([1, 2]); + p.then( + function(arg) { + ok(arg instanceof win.Array, "Should get an Array from Promise.all (3)"); + is(arg[0], 1, "First entry of Promise.all return value should be correct (3)"); + is(arg[1], 2, "Second entry of Promise.all return value should be correct (3)"); + }, + function(e) { + ok(false, "testAll3 threw exception: " + e); + } + ).then(nextTest); +} + +function testAll4() { + // This works with both content-side and chrome-side Promises because we want + // it to and go to some lengths to make it work. + var p = win.Promise.all([Promise.resolve(1), win.Promise.resolve(2)]); + p.then( + function(arg) { + ok(arg instanceof win.Array, "Should get an Array from Promise.all (4)"); + is(arg[0], 1, "First entry of Promise.all return value should be correct (4)"); + is(arg[1], 2, "Second entry of Promise.all return value should be correct (4)"); + }, + function(e) { + ok(false, "testAll4 threw exception: " + e); + } + ).then(nextTest); +} + +function testAll5() { + var p = win.Promise.all(new win.Array()); + p.then( + function(arg) { + ok(arg instanceof win.Array, "Should get an Array from Promise.all (5)"); + }, + function(e) { + ok(false, "testAll5 threw exception: " + e); + } + ).then(nextTest); +} + +function testResolve1() { + var p = win.Promise.resolve(5); + ok(p instanceof win.Promise, "Promise.resolve should return a promise"); + p.then( + function(arg) { + is(arg, 5, "Should get correct Promise.resolve value"); + }, + function(e) { + ok(false, "testAll5 threw exception: " + e); + } + ).then(nextTest); +} + +function testResolve2() { + var p = win.Promise.resolve(5); + var q = win.Promise.resolve(p); + is(q, p, "Promise.resolve should just pass through Promise values"); + nextTest(); +} + +function testResolve3() { + var p = win.Promise.resolve(Promise.resolve(5)); + p.then( + function(arg) { + is(arg, 5, "Promise.resolve with chrome Promise should work"); + }, + function(e) { + ok(false, "Promise.resolve with chrome Promise should not fail"); + } + ).then(nextTest); +} + +function testResolve4() { + var p = new win.Promise((res, rej) => {}); + Cu.getJSTestingFunctions().resolvePromise(p, 42); + p.then( + function(arg) { + is(arg, 42, "Resolving an Xray to a promise with TestingFunctions resolvePromise should work"); + }, + function(e) { + ok(false, "Resolving an Xray to a promise with TestingFunctions resolvePromise should not fail"); + } + ).then(nextTest); +} + +function testReject1() { + var p = win.Promise.reject(5); + ok(p instanceof win.Promise, "Promise.reject should return a promise"); + p.then( + function(arg) { + ok(false, "Promise should be rejected"); + }, + function(e) { + is(e, 5, "Should get correct Promise.reject value"); + } + ).then(nextTest); +} + +function testReject2() { + var p = new win.Promise((res, rej) => {}); + Cu.getJSTestingFunctions().rejectPromise(p, 42); + p.then( + function(arg) { + ok(false, "Rejecting an Xray to a promise with TestingFunctions rejectPromise should trigger catch handler"); + }, + function(e) { + is(e, 42, "Rejecting an Xray to a promise with TestingFunctions rejectPromise should work"); + } + ).then(nextTest); +} + +function testThen1() { + var p = win.Promise.resolve(5); + var q = p.then((x) => x * x); + ok(q instanceof win.Promise, + "Promise.then should return a promise from the right global"); + q.then( + function(arg) { + is(arg, 25, "Promise.then should work"); + }, + function(e) { + ok(false, "Promise.then should not fail"); + } + ).then(nextTest); +} + +function testThen2() { + var p = win.Promise.resolve(5); + var q = p.then((x) => Promise.resolve(x * x)); + ok(q instanceof win.Promise, + "Promise.then should return a promise from the right global"); + q.then( + function(arg) { + is(arg, 25, "Promise.then resolved with chrome promise should work"); + }, + function(e) { + ok(false, "Promise.then resolved with chrome promise should not fail"); + } + ).then(nextTest); +} + +function testCatch1() { + var p = win.Promise.reject(5); + ok(p instanceof win.Promise, "Promise.reject should return a promise"); + var q = p.catch((x) => x * x); + ok(q instanceof win.Promise, + "Promise.catch should return a promise from the right global"); + q.then( + function(arg) { + is(arg, 25, "Promise.catch should work"); + }, + function(e) { + ok(false, "Promise.catch should not fail"); + } + ).then(nextTest); +} + +function testToStringTag1() { + is(win.Promise.prototype[Symbol.toStringTag], "Promise", "@@toStringTag was incorrect"); + var p = win.Promise.resolve(); + is(String(p), "[object Promise]", "String() result was incorrect"); + is(p.toString(), "[object Promise]", "toString result was incorrect"); + is(Object.prototype.toString.call(p), "[object Promise]", "second toString result was incorrect"); + nextTest(); +} + +var tests = [ + testLoadComplete, + testHaveXray, + testConstructor1, + testConstructor2, + testRace1, + testRace2, + testRace3, + testRace4, + testAll1, + testAll2, + testAll3, + testAll4, + testAll5, + testResolve1, + testResolve2, + testResolve3, + testResolve4, + testReject1, + testReject2, + testThen1, + testThen2, + testCatch1, + testToStringTag1, +]; + +function nextTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + tests.shift()(); +} + +addLoadEvent(nextTest); + +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_resolve.html b/dom/promise/tests/test_resolve.html new file mode 100644 index 0000000000..7e4745b47a --- /dev/null +++ b/dom/promise/tests/test_resolve.html @@ -0,0 +1,66 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>Promise.resolve(anything) Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script type="application/javascript"><!-- + +var tests = [ + null, + 42, + "hello world", + true, + false, + {}, + { a: 42 }, + [ 1, 2, 3, 4, null, true, "hello world" ], + function() {}, + window, + undefined, + document.createElement("input"), + new Date(), +]; + +function cbError() { + ok(false, "Nothing should arrive here!"); +} + +function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.pop(); + + new Promise(function(resolve, reject) { + resolve(test); + }).then(function(what) { + ok(test === what, "What is: " + what); + }, cbError).then(function() { + new Promise(function(resolve, reject) { + reject(test); + }).then(cbError, function(what) { + ok(test === what, "What is: " + what); + }).then(runTest, cbError); + }); +} + +SimpleTest.waitForExplicitFinish(); +runTest(); +// --> +</script> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_resolver_return_value.html b/dom/promise/tests/test_resolver_return_value.html new file mode 100644 index 0000000000..82e8793824 --- /dev/null +++ b/dom/promise/tests/test_resolver_return_value.html @@ -0,0 +1,40 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1120235 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1120235</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript"> + + /** Test for Bug 1120235 **/ + var res, rej; + var p = new Promise(function(resolve, reject) { res = resolve; rej = reject; }); + is(res(1), undefined, "Resolve function should return undefined"); + is(rej(2), undefined, "Reject function should return undefined"); + + var thenable = { + then(resolve, reject) { + is(resolve(3), undefined, "Thenable resolve argument should return undefined"); + is(reject(4), undefined, "Thenable reject argument should return undefined"); + SimpleTest.finish(); + }, + }; + + SimpleTest.waitForExplicitFinish(); + p = Promise.resolve(thenable); + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1120235">Mozilla Bug 1120235</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/promise/tests/test_species_getter.html b/dom/promise/tests/test_species_getter.html new file mode 100644 index 0000000000..23cb7d8ae0 --- /dev/null +++ b/dom/promise/tests/test_species_getter.html @@ -0,0 +1,25 @@ +<!DOCTYPE html> +<meta charset=utf-8> +<title>Test for ...</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<div id="log"></div> +<script> +test(function() { + /* global test, assert_not_equals, assert_equals */ + + var desc = Object.getOwnPropertyDescriptor(Promise, Symbol.species); + assert_not_equals(desc, undefined, "Should have a property"); + + assert_equals(desc.configurable, true, "Property should be configurable"); + assert_equals(desc.enumerable, false, "Property should not be enumerable"); + assert_equals(desc.set, undefined, "Should not have a setter"); + var getter = desc.get; + + var things = [undefined, null, 5, "xyz", Promise, Object]; + for (var thing of things) { + assert_equals(getter.call(thing), thing, + "Getter should return its this value"); + } +}, "Promise should have an @@species getter that works per spec"); +</script> diff --git a/dom/promise/tests/test_thenable_vs_promise_ordering.html b/dom/promise/tests/test_thenable_vs_promise_ordering.html new file mode 100644 index 0000000000..a537490b16 --- /dev/null +++ b/dom/promise/tests/test_thenable_vs_promise_ordering.html @@ -0,0 +1,29 @@ +<!DOCTYPE html> +<meta charset=utf-8> +<title>Test for promise resolution ordering with thenables and promises</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<div id="log"></div> +<script> +/* global async_test, assert_true, assert_equals */ + +var t = async_test("A promise resolved first (with a thenable) should trigger its callbacks before a promise resolved second (with a promise)."); +t.step(function() { + var customThenCalled = false; + var p0 = Promise.resolve(); + p0.then = function(resolved, rejected) { + customThenCalled = true; + Promise.prototype.then.call(this, resolved, rejected); + }; + var p1 = new Promise(function(r) { r(p0); }); + delete p0.then; + var p2 = new Promise(function(r) { r(p0); }); + var resolutionOrder = ""; + Promise.all([ p1.then(function() { resolutionOrder += "1"; }), + p2.then(function() { resolutionOrder += "2"; }) ]) + .then(t.step_func_done(function() { + assert_true(customThenCalled, "Should have called custom then"); + assert_equals(resolutionOrder, "12"); + })); +}); +</script> diff --git a/dom/promise/tests/test_webassembly_compile.html b/dom/promise/tests/test_webassembly_compile.html new file mode 100644 index 0000000000..351f0f4ae4 --- /dev/null +++ b/dom/promise/tests/test_webassembly_compile.html @@ -0,0 +1,446 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<html> +<head> + <title>WebAssembly.compile Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<script> +const testingFunctions = SpecialPowers.Cu.getJSTestingFunctions(); +const wasmIsSupported = SpecialPowers.unwrap(testingFunctions.wasmIsSupported); +const wasmHasTier2CompilationCompleted = SpecialPowers.unwrap(testingFunctions.wasmHasTier2CompilationCompleted); +const wasmLoadedFromCache = SpecialPowers.unwrap(testingFunctions.wasmLoadedFromCache); +const isCachingEnabled = SpecialPowers.getBoolPref("javascript.options.wasm_caching"); + +// The test_webassembly_compile_sample.wasm is a medium-sized module with 100 +// functions that call each other recursively, returning a computed sum. +// Any other non-trivial module could be generated and used. +var sampleCode; +const sampleURL = "test_webassembly_compile_sample.wasm"; +const sampleFileSize = 16053; +const sampleURLWithRandomQuery = () => sampleURL + "?id=" + String(Math.ceil(Math.random()*100000)); +const sampleExportName = "run"; +const sampleResult = 1275; + +function checkSampleModule(m) { + ok(m instanceof WebAssembly.Module, "got a module"); + var i = new WebAssembly.Instance(m); + ok(i instanceof WebAssembly.Instance, "got an instance"); + ok(i.exports[sampleExportName]() === sampleResult, "got result"); +} + +function checkSampleInstance(i) { + ok(i instanceof WebAssembly.Instance, "got a module"); + ok(i.exports[sampleExportName]() === sampleResult, "got result"); +} + +function fetchSampleModuleCode() { + fetch(sampleURL) + .then(response => response.arrayBuffer()) + .then(buffer => { sampleCode = buffer; runTest(); }) + .catch(err => ok(false, String(err))); +} + +function propertiesExist() { + if (!wasmIsSupported()) { + ok(!this.WebAssembly, "If the device doesn't support, there will be no WebAssembly object"); + SimpleTest.finish(); + return; + } + + ok(WebAssembly, "WebAssembly object should exist"); + ok(WebAssembly.compile, "WebAssembly.compile function should exist"); + runTest(); +} + +function compileFail() { + WebAssembly.compile().then( + () => { ok(false, "should have failed"); runTest(); } + ).catch( + err => { ok(err instanceof TypeError, "empty compile failed"); runTest(); } + ); +} + +function compileSuccess() { + WebAssembly.compile(sampleCode).then( + m => { checkSampleModule(m); runTest(); } + ).catch( + err => { ok(false, String(err)); runTest(); } + ); +} + +function compileManySuccess() { + const N = 100; + + var arr = []; + for (var i = 0; i < N; i++) + arr.push(WebAssembly.compile(sampleCode)); + + SpecialPowers.gc(); + + Promise.all(arr).then(ms => { + ok(ms.length === N, "got the right number"); + for (var j = 0; j < N; j++) + checkSampleModule(ms[j]); + runTest(); + }).catch( + err => { ok(false, String(err)); runTest(); } + ); +} + +function terminateCompileInWorker() { + var w = new Worker(`data:text/plain, + var sampleCode; + function spawnWork() { + const N = 100; + var arr = []; + for (var i = 0; i < N; i++) + arr.push(WebAssembly.compile(sampleCode)); + Promise.all(arr).then(spawnWork); + } + onmessage = e => { + sampleCode = e.data; + spawnWork(); + postMessage("ok"); + } + `); + w.postMessage(sampleCode); + w.onmessage = e => { + ok(e.data === "ok", "worker finished first step"); + w.terminate(); + runTest(); + }; +} + +function instantiateFail() { + WebAssembly.instantiate().then( + () => { ok(false, "should have failed"); runTest(); } + ).catch( + err => { ok(err instanceof TypeError, "empty compile failed"); runTest(); } + ); +} + +function instantiateSuccess() { + WebAssembly.instantiate(sampleCode).then( + r => { checkSampleModule(r.module); checkSampleInstance(r.instance); runTest(); } + ).catch( + err => { ok(false, String(err)); runTest(); } + ); +} + +function chainSuccess() { + WebAssembly.compile(sampleCode).then( + m => WebAssembly.instantiate(m) + ).then( + i => { checkSampleInstance(i); runTest(); } + ).catch( + err => { ok(false, String(err)); runTest(); } + ); +} + +function compileStreamingNonResponse() { + WebAssembly.compileStreaming({}) + .then(() => { ok(false); }) + .catch(err => { ok(err instanceof TypeError, "rejected {}"); runTest(); }); +} + +function compileStreamingNoMime() { + WebAssembly.compileStreaming(new Response(new ArrayBuffer())) + .then(() => { ok(false); }) + .catch(err => { ok(err instanceof TypeError, "rejected no MIME type"); runTest(); }); +} + +function compileStreamingBadMime() { + var badMimes = [ + "", + "application/js", + "application/js;application/wasm", + "application/wasm;application/js", + "application/wasm;", + "application/wasm1", + ]; + var promises = []; + for (let mimeType of badMimes) { + var init = { headers: { "Content-Type": mimeType } }; + promises.push( + WebAssembly.compileStreaming(new Response(sampleCode, init)) + .then(() => Promise.reject(), err => { + is(err.message, + `WebAssembly: Response has unsupported MIME type '${mimeType}' expected 'application/wasm'`, + "correct MIME type error message"); + return Promise.resolve(); + }) + ); + } + Promise.all(promises) + .then(() => { ok(true, "all bad MIME types rejected"); runTest(); }); +} + +function compileStreamingGoodMime() { + var badMimes = [ + "application/wasm", + " application/wasm ", + "application/wasm ", + ]; + var promises = []; + for (let mimeType of badMimes) { + var init = { headers: { "Content-Type": mimeType } }; + promises.push( + WebAssembly.compileStreaming(new Response(sampleCode, init)) + ); + } + Promise.all(promises) + .then(() => { ok(true, "all good MIME types accepted"); runTest(); }); +} + +function compileStreamingDoubleUseFail() { + fetch(sampleURL) + .then(response => { + WebAssembly.compileStreaming(response) + .then(m => { + checkSampleModule(m); + return WebAssembly.compileStreaming(response); + }) + .then( + () => ok(false, "should have failed on second use"), + err => { ok(true, "failed on second use"); runTest(); } + ); + }); +} + +function compileStreamingNullBody() { + var init = { headers: { "Content-Type": "application/wasm" } }; + WebAssembly.compileStreaming(new Response(undefined, init)) + .then(() => { ok(false); }) + .catch(err => { ok(err instanceof WebAssembly.CompileError, "null body"); runTest(); }); +} + +function compileStreamingFetch() { + WebAssembly.compileStreaming(fetch(sampleURL)) + .then(m => { checkSampleModule(m); runTest(); }) + .catch(err => { ok(false, String(err)); }); +} + +function compileCachedBasic() { + const url = sampleURLWithRandomQuery(); + WebAssembly.compileStreaming(fetch(url)) + .then(module => { + checkSampleModule(module); + ok(!wasmLoadedFromCache(module), "not cached yet"); + while(!wasmHasTier2CompilationCompleted(module)); + return WebAssembly.compileStreaming(fetch(url)); + }) + .then(module => { + checkSampleModule(module); + ok(wasmLoadedFromCache(module), "loaded from cache"); + }) + .then(() => runTest()) + .catch(err => { ok(false, String(err)) }); +} + +function compileCachedCompressed() { + const url = sampleURLWithRandomQuery(); + + // It is a rough estimate that compilation code is about + // 2-4 times of the wasm file size. After it compression + // it will be less (about 60% ?) + const EstimatedCompilationArtifactSize = 2 * sampleFileSize; + const EstimatedCompressedArtifactSize = 0.6 * EstimatedCompilationArtifactSize; + + // Set limit on cache entry so it will fail if it is not + // compressed. + const cleanup = () => { + SpecialPowers.clearUserPref("browser.cache.disk.max_entry_size") + }; + Promise.resolve(SpecialPowers.setIntPref("browser.cache.disk.max_entry_size", + Math.round(EstimatedCompressedArtifactSize / 1024) /* kb */)) + .then(() => WebAssembly.compileStreaming(fetch(url))) + .then(module => { + checkSampleModule(module); + ok(!wasmLoadedFromCache(module), "not cached yet"); + while(!wasmHasTier2CompilationCompleted(module)); + return WebAssembly.compileStreaming(fetch(url)); + }) + .then(module => { + checkSampleModule(module); + ok(wasmLoadedFromCache(module), "loaded from cache"); + }) + .then(() => { cleanup(); runTest() }) + .catch(err => { cleanup(); ok(false, String(err)) }); +} + +function compileCachedTooLargeForCache() { + const url = sampleURLWithRandomQuery(); + // Set unreasonable limit, caching will fail. + // Bug 1719508 can change name of pref, this and + // compileCachedCompressed tests will become invalid. + const cleanup = () => { + SpecialPowers.clearUserPref("browser.cache.disk.max_entry_size") + }; + Promise.resolve(SpecialPowers.setIntPref("browser.cache.disk.max_entry_size", 1 /* kb */)) + .then(() => WebAssembly.compileStreaming(fetch(url))) + .then(module => { + console.log(module) + checkSampleModule(module); + ok(!wasmLoadedFromCache(module), "not cached yet"); + while(!wasmHasTier2CompilationCompleted(module)); + return WebAssembly.compileStreaming(fetch(url)); + }) + .then(module => { + checkSampleModule(module); + ok(!wasmLoadedFromCache(module), "not cached (size limit)"); + }) + .then(() => { cleanup(); runTest() }) + .catch(err => { cleanup(); ok(false, String(err)) }); +} + +const Original = "original"; +const Clone = "clone"; + +function compileCachedBothClonesHitCache(which) { + const url = sampleURLWithRandomQuery(); + WebAssembly.compileStreaming(fetch(url)) + .then(module => { + checkSampleModule(module); + ok(!wasmLoadedFromCache(module), "not cached yet"); + while(!wasmHasTier2CompilationCompleted(module)); + return fetch(url); + }) + .then(original => { + let clone = original.clone(); + if (which === Clone) [clone, original] = [original, clone]; + return Promise.all([ + WebAssembly.compileStreaming(original), + WebAssembly.compileStreaming(clone) + ]); + }) + .then(([m1, m2]) => { + checkSampleModule(m1); + ok(wasmLoadedFromCache(m1), "clone loaded from cache"); + checkSampleModule(m2); + ok(wasmLoadedFromCache(m2), "original loaded from cache"); + }) + .then(() => runTest()) + .catch(err => { ok(false, String(err)) }); +} + +function compileCachedCacheThroughClone(which) { + const url = sampleURLWithRandomQuery(); + fetch(url) + .then(original => { + ok(true, "fun time"); + let clone = original.clone(); + if (which === Clone) [clone, original] = [original, clone]; + return Promise.all([ + WebAssembly.compileStreaming(original), + clone.arrayBuffer() + ]); + }) + .then(([module, buffer]) => { + ok(!wasmLoadedFromCache(module), "not cached yet"); + ok(buffer instanceof ArrayBuffer); + while(!wasmHasTier2CompilationCompleted(module)); + return WebAssembly.compileStreaming(fetch(url)); + }) + .then(m => { + ok(wasmLoadedFromCache(m), "cache hit of " + which); + }) + .then(() => runTest()) + .catch(err => { ok(false, String(err)) }); +} + +function instantiateStreamingFetch() { + WebAssembly.instantiateStreaming(fetch(sampleURL)) + .then(({module, instance}) => { checkSampleModule(module); checkSampleInstance(instance); runTest(); }) + .catch(err => { ok(false, String(err)); }); +} + +function compileManyStreamingFetch() { + const N = 20; + + var arr = []; + for (var i = 0; i < N; i++) + arr.push(WebAssembly.compileStreaming(fetch(sampleURL))); + + SpecialPowers.gc(); + + Promise.all(arr).then(ms => { + ok(ms.length === N, "got the right number"); + for (var j = 0; j < N; j++) + checkSampleModule(ms[j]); + runTest(); + }).catch( + err => { ok(false, String(err)); runTest(); } + ); +} + +function runWorkerTests() { + var w = new Worker("test_webassembly_compile_worker.js"); + w.postMessage(sampleCode); + w.onmessage = e => { + ok(e.data === "ok", "worker test: " + e.data); + runTest(); + }; +} + +function terminateCompileStreamingInWorker() { + var w = new Worker("test_webassembly_compile_worker_terminate.js"); + w.onmessage = e => { + ok(e.data === "ok", "worker streaming terminate test: " + e.data); + w.terminate(); + runTest(); + }; +} + +var tests = [ propertiesExist, + compileFail, + compileSuccess, + compileManySuccess, + terminateCompileInWorker, + instantiateFail, + instantiateSuccess, + chainSuccess, + compileStreamingNonResponse, + compileStreamingNoMime, + compileStreamingBadMime, + compileStreamingGoodMime, + compileStreamingDoubleUseFail, + compileStreamingNullBody, + compileStreamingFetch, + ...(isCachingEnabled ? [ + compileCachedBasic, + compileCachedCompressed, + compileCachedTooLargeForCache, + compileCachedBothClonesHitCache.bind(Original), + compileCachedBothClonesHitCache.bind(Clone), + compileCachedCacheThroughClone.bind(Original), + compileCachedCacheThroughClone.bind(Clone), + ]: []), + instantiateStreamingFetch, + compileManyStreamingFetch, + runWorkerTests, + terminateCompileStreamingInWorker, + ]; + +// This initialization must always run +tests.unshift(fetchSampleModuleCode); + +function runTest() { + if (!tests.length) { + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); +} + +SimpleTest.waitForExplicitFinish(); +runTest(); +</script> +</body> +</html> diff --git a/dom/promise/tests/test_webassembly_compile_sample.wasm b/dom/promise/tests/test_webassembly_compile_sample.wasm Binary files differnew file mode 100644 index 0000000000..787e19a5df --- /dev/null +++ b/dom/promise/tests/test_webassembly_compile_sample.wasm diff --git a/dom/promise/tests/test_webassembly_compile_worker.js b/dom/promise/tests/test_webassembly_compile_worker.js new file mode 100644 index 0000000000..90c3551137 --- /dev/null +++ b/dom/promise/tests/test_webassembly_compile_worker.js @@ -0,0 +1,55 @@ +const sampleURL = "test_webassembly_compile_sample.wasm"; +const sampleExportName = "run"; +const sampleResult = 1275; + +/* eslint-disable no-throw-literal */ + +function checkSampleModule(m) { + if (!(m instanceof WebAssembly.Module)) { + throw "not a module"; + } + var i = new WebAssembly.Instance(m); + if (!(i instanceof WebAssembly.Instance)) { + throw "not an instance"; + } + if (i.exports[sampleExportName]() !== sampleResult) { + throw "wrong result"; + } +} + +function checkSampleInstance(i) { + if (!(i instanceof WebAssembly.Instance)) { + throw "not an instance"; + } + if (i.exports[sampleExportName]() !== sampleResult) { + throw "wrong result"; + } +} + +const initObj = { headers: { "Content-Type": "application/wasm" } }; + +onmessage = e => { + WebAssembly.compile(e.data) + .then(m => checkSampleModule(m)) + .then(() => WebAssembly.instantiate(e.data)) + .then(({ module, instance }) => { + checkSampleModule(module); + checkSampleInstance(instance); + }) + .then(() => WebAssembly.compileStreaming(new Response(e.data, initObj))) + .then(m => checkSampleModule(m)) + .then(() => WebAssembly.instantiateStreaming(new Response(e.data, initObj))) + .then(({ module, instance }) => { + checkSampleModule(module); + checkSampleInstance(instance); + }) + .then(() => WebAssembly.compileStreaming(fetch(sampleURL))) + .then(m => checkSampleModule(m)) + .then(() => WebAssembly.instantiateStreaming(fetch(sampleURL))) + .then(({ module, instance }) => { + checkSampleModule(module); + checkSampleInstance(instance); + }) + .then(() => postMessage("ok")) + .catch(err => postMessage("fail: " + err)); +}; diff --git a/dom/promise/tests/test_webassembly_compile_worker_terminate.js b/dom/promise/tests/test_webassembly_compile_worker_terminate.js new file mode 100644 index 0000000000..5b96c9034b --- /dev/null +++ b/dom/promise/tests/test_webassembly_compile_worker_terminate.js @@ -0,0 +1,13 @@ +const sampleURL = "test_webassembly_compile_sample.wasm"; + +function spawnWork() { + const N = 50; + var arr = []; + for (var i = 0; i < N; i++) { + arr.push(WebAssembly.compileStreaming(fetch(sampleURL))); + } + Promise.all(arr).then(spawnWork); +} + +spawnWork(); +postMessage("ok"); diff --git a/dom/promise/tests/unit/test_monitor_uncaught.js b/dom/promise/tests/unit/test_monitor_uncaught.js new file mode 100644 index 0000000000..afa328cb97 --- /dev/null +++ b/dom/promise/tests/unit/test_monitor_uncaught.js @@ -0,0 +1,322 @@ +/* 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/. */ + +"use strict"; + +const { setTimeout } = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" +); +const { PromiseTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/PromiseTestUtils.sys.mjs" +); + +// Prevent test failures due to the unhandled rejections in this test file. +PromiseTestUtils.disableUncaughtRejectionObserverForSelfTest(); + +add_task(async function test_globals() { + Assert.notEqual( + PromiseDebugging, + undefined, + "PromiseDebugging is available." + ); +}); + +add_task(async function test_promiseID() { + let p1 = new Promise(resolve => {}); + let p2 = new Promise(resolve => {}); + let p3 = p2.catch(null); + let promise = [p1, p2, p3]; + + let identifiers = promise.map(PromiseDebugging.getPromiseID); + info("Identifiers: " + JSON.stringify(identifiers)); + let idSet = new Set(identifiers); + Assert.equal( + idSet.size, + identifiers.length, + "PromiseDebugging.getPromiseID returns a distinct id per promise" + ); + + let identifiers2 = promise.map(PromiseDebugging.getPromiseID); + Assert.equal( + JSON.stringify(identifiers), + JSON.stringify(identifiers2), + "Successive calls to PromiseDebugging.getPromiseID return the same id for the same promise" + ); +}); + +add_task(async function test_observe_uncaught() { + // The names of Promise instances + let names = new Map(); + + // The results for UncaughtPromiseObserver callbacks. + let CallbackResults = function (name) { + this.name = name; + this.expected = new Set(); + this.observed = new Set(); + this.blocker = new Promise(resolve => (this.resolve = resolve)); + }; + CallbackResults.prototype = { + observe(promise) { + info(this.name + " observing Promise " + names.get(promise)); + Assert.equal( + PromiseDebugging.getState(promise).state, + "rejected", + this.name + " observed a rejected Promise" + ); + if (!this.expected.has(promise)) { + Assert.ok( + false, + this.name + + " observed a Promise that it expected to observe, " + + names.get(promise) + + " (" + + PromiseDebugging.getPromiseID(promise) + + ", " + + PromiseDebugging.getAllocationStack(promise) + + ")" + ); + } + Assert.ok( + this.expected.delete(promise), + this.name + + " observed a Promise that it expected to observe, " + + names.get(promise) + + " (" + + PromiseDebugging.getPromiseID(promise) + + ")" + ); + Assert.ok( + !this.observed.has(promise), + this.name + " observed a Promise that it has not observed yet" + ); + this.observed.add(promise); + if (this.expected.size == 0) { + this.resolve(); + } else { + info( + this.name + + " is still waiting for " + + this.expected.size + + " observations:" + ); + info( + JSON.stringify(Array.from(this.expected.values(), x => names.get(x))) + ); + } + }, + }; + + let onLeftUncaught = new CallbackResults("onLeftUncaught"); + let onConsumed = new CallbackResults("onConsumed"); + + let observer = { + onLeftUncaught(promise, data) { + onLeftUncaught.observe(promise); + }, + onConsumed(promise) { + onConsumed.observe(promise); + }, + }; + + let resolveLater = function (delay = 20) { + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + return new Promise((resolve, reject) => setTimeout(resolve, delay)); + }; + let rejectLater = function (delay = 20) { + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + return new Promise((resolve, reject) => setTimeout(reject, delay)); + }; + let makeSamples = function* () { + yield { + promise: Promise.resolve(0), + name: "Promise.resolve", + }; + yield { + promise: Promise.resolve(resolve => resolve(0)), + name: "Resolution callback", + }; + yield { + promise: Promise.resolve(0).catch(null), + name: "`catch(null)`", + }; + yield { + promise: Promise.reject(0).catch(() => {}), + name: "Reject and catch immediately", + }; + yield { + promise: resolveLater(), + name: "Resolve later", + }; + yield { + promise: Promise.reject("Simple rejection"), + leftUncaught: true, + consumed: false, + name: "Promise.reject", + }; + + // Reject a promise now, consume it later. + let p = Promise.reject("Reject now, consume later"); + + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + setTimeout( + () => + p.catch(() => { + info("Consumed promise"); + }), + 200 + ); + yield { + promise: p, + leftUncaught: true, + consumed: true, + name: "Reject now, consume later", + }; + + yield { + promise: Promise.all([Promise.resolve("Promise.all"), rejectLater()]), + leftUncaught: true, + name: "Rejecting through Promise.all", + }; + yield { + promise: Promise.race([resolveLater(500), Promise.reject()]), + leftUncaught: true, // The rejection wins the race. + name: "Rejecting through Promise.race", + }; + yield { + promise: Promise.race([Promise.resolve(), rejectLater(500)]), + leftUncaught: false, // The resolution wins the race. + name: "Resolving through Promise.race", + }; + + let boom = new Error("`throw` in the constructor"); + yield { + promise: new Promise(() => { + throw boom; + }), + leftUncaught: true, + name: "Throwing in the constructor", + }; + + let rejection = Promise.reject("`reject` during resolution"); + yield { + promise: rejection, + leftUncaught: false, + consumed: false, // `rejection` is consumed immediately (see below) + name: "Promise.reject, again", + }; + + yield { + promise: new Promise(resolve => resolve(rejection)), + leftUncaught: true, + consumed: false, + name: "Resolving with a rejected promise", + }; + + yield { + promise: Promise.resolve(0).then(() => rejection), + leftUncaught: true, + consumed: false, + name: "Returning a rejected promise from success handler", + }; + + yield { + promise: Promise.resolve(0).then(() => { + throw new Error(); + }), + leftUncaught: true, + consumed: false, + name: "Throwing during the call to the success callback", + }; + }; + let samples = []; + for (let s of makeSamples()) { + samples.push(s); + info( + "Promise '" + + s.name + + "' has id " + + PromiseDebugging.getPromiseID(s.promise) + ); + } + + PromiseDebugging.addUncaughtRejectionObserver(observer); + + for (let s of samples) { + names.set(s.promise, s.name); + if (s.leftUncaught || false) { + onLeftUncaught.expected.add(s.promise); + } + if (s.consumed || false) { + onConsumed.expected.add(s.promise); + } + } + + info("Test setup, waiting for callbacks."); + await onLeftUncaught.blocker; + + info("All calls to onLeftUncaught are complete."); + if (onConsumed.expected.size != 0) { + info("onConsumed is still waiting for the following Promise:"); + info( + JSON.stringify( + Array.from(onConsumed.expected.values(), x => names.get(x)) + ) + ); + await onConsumed.blocker; + } + + info("All calls to onConsumed are complete."); + let removed = PromiseDebugging.removeUncaughtRejectionObserver(observer); + Assert.ok(removed, "removeUncaughtRejectionObserver succeeded"); + removed = PromiseDebugging.removeUncaughtRejectionObserver(observer); + Assert.ok( + !removed, + "second call to removeUncaughtRejectionObserver didn't remove anything" + ); +}); + +add_task(async function test_uninstall_observer() { + let Observer = function () { + this.blocker = new Promise(resolve => (this.resolve = resolve)); + this.active = true; + }; + Observer.prototype = { + set active(x) { + this._active = x; + if (x) { + PromiseDebugging.addUncaughtRejectionObserver(this); + } else { + PromiseDebugging.removeUncaughtRejectionObserver(this); + } + }, + onLeftUncaught() { + Assert.ok(this._active, "This observer is active."); + this.resolve(); + }, + onConsumed() { + Assert.ok(false, "We should not consume any Promise."); + }, + }; + + info("Adding an observer."); + let deactivate = new Observer(); + Promise.reject("I am an uncaught rejection."); + await deactivate.blocker; + Assert.ok(true, "The observer has observed an uncaught Promise."); + deactivate.active = false; + info( + "Removing the observer, it should not observe any further uncaught Promise." + ); + + info( + "Rejecting a Promise and waiting a little to give a chance to observers." + ); + let wait = new Observer(); + Promise.reject("I am another uncaught rejection."); + await wait.blocker; + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + await new Promise(resolve => setTimeout(resolve, 100)); + // Normally, `deactivate` should not be notified of the uncaught rejection. + wait.active = false; +}); diff --git a/dom/promise/tests/unit/test_promise_job_across_sandbox.js b/dom/promise/tests/unit/test_promise_job_across_sandbox.js new file mode 100644 index 0000000000..ff1d1575e3 --- /dev/null +++ b/dom/promise/tests/unit/test_promise_job_across_sandbox.js @@ -0,0 +1,221 @@ +function createSandbox() { + const uri = Services.io.newURI("https://example.com"); + const principal = Services.scriptSecurityManager.createContentPrincipal( + uri, + {} + ); + return new Cu.Sandbox(principal, {}); +} + +add_task(async function testReactionJob() { + const sandbox = createSandbox(); + + sandbox.eval(` +var testPromise = Promise.resolve(10); +`); + + // Calling `Promise.prototype.then` from sandbox performs GetFunctionRealm + // on wrapped `resolve` in sandbox realm, and it fails to unwrap the security + // wrapper. The reaction job should be created with sandbox realm. + const p = new Promise(resolve => { + sandbox.resolve = resolve; + + sandbox.eval(` +testPromise.then(resolve); +`); + }); + + const result = await p; + + equal(result, 10); +}); + +add_task(async function testReactionJobNuked() { + const sandbox = createSandbox(); + + sandbox.eval(` +var testPromise = Promise.resolve(10); +`); + + // Calling `Promise.prototype.then` from sandbox performs GetFunctionRealm + // on wrapped `resolve` in sandbox realm, and it fails to unwrap the security + // wrapper. The reaction job should be created with sandbox realm. + const p1 = new Promise(resolve => { + sandbox.resolve = resolve; + + sandbox.eval(` +testPromise.then(resolve); +`); + + // Given the reaction job is created with the sandbox realm, nuking the + // sandbox prevents the job gets executed. + Cu.nukeSandbox(sandbox); + }); + + const p2 = Promise.resolve(11); + + // Given the p1 doesn't get resolved, p2 should win. + const result = await Promise.race([p1, p2]); + + equal(result, 11); +}); + +add_task(async function testReactionJobWithXray() { + const sandbox = createSandbox(); + + sandbox.eval(` +var testPromise = Promise.resolve(10); +`); + + // Calling `Promise.prototype.then` from privileged realm via Xray uses + // privileged `Promise.prototype.then` function, and GetFunctionRealm + // performed there successfully gets top-level realm. The reaction job + // should be created with top-level realm. + const result = await new Promise(resolve => { + sandbox.testPromise.then(resolve); + + // Given the reaction job is created with the top-level realm, nuking the + // sandbox doesn't affect the reaction job. + Cu.nukeSandbox(sandbox); + }); + + equal(result, 10); +}); + +add_task(async function testBoundReactionJob() { + const sandbox = createSandbox(); + + sandbox.eval(` +var resolve = undefined; +var callbackPromise = new Promise(r => { resolve = r; }); +var callback = function (v) { resolve(v + 1); }; +`); + + // Create a bound function where its realm is privileged realm, and + // its target is from sandbox realm. + sandbox.bound_callback = Function.prototype.bind.call( + sandbox.callback, + sandbox + ); + + // Calling `Promise.prototype.then` from sandbox performs GetFunctionRealm + // and it fails. The reaction job should be created with sandbox realm. + sandbox.eval(` +Promise.resolve(10).then(bound_callback); +`); + + const result = await sandbox.callbackPromise; + equal(result, 11); +}); + +add_task(async function testThenableJob() { + const sandbox = createSandbox(); + + const p = new Promise(resolve => { + // Create a bound function where its realm is privileged realm, and + // its target is from sandbox realm. + sandbox.then = function (onFulfilled, onRejected) { + resolve(10); + }; + }); + + // Creating a promise thenable job in the following `Promise.resolve` performs + // GetFunctionRealm on the bound thenable.then and fails. The reaction job + // should be created with sandbox realm. + sandbox.eval(` +var thenable = { + then: then, +}; + +Promise.resolve(thenable); +`); + + const result = await p; + equal(result, 10); +}); + +add_task(async function testThenableJobNuked() { + const sandbox = createSandbox(); + + let called = false; + sandbox.then = function (onFulfilled, onRejected) { + called = true; + }; + + // Creating a promise thenable job in the following `Promise.resolve` performs + // GetFunctionRealm on the bound thenable.then and fails. The reaction job + // should be created with sandbox realm. + sandbox.eval(` +var thenable = { + then: then, +}; + +Promise.resolve(thenable); +`); + + Cu.nukeSandbox(sandbox); + + // Drain the job queue, to make sure we hit dead object error inside the + // thenable job. + await Promise.resolve(10); + + equal( + Services.console.getMessageArray().find(x => { + return x.toString().includes("can't access dead object"); + }) !== undefined, + true + ); + equal(called, false); +}); + +add_task(async function testThenableJobAccessError() { + const sandbox = createSandbox(); + + let accessed = false; + sandbox.thenable = { + get then() { + accessed = true; + }, + }; + + // The following operation silently fails when accessing `then` property. + sandbox.eval(` +var x = typeof thenable.then; + +Promise.resolve(thenable); +`); + + equal(accessed, false); +}); + +add_task(async function testBoundThenableJob() { + const sandbox = createSandbox(); + + sandbox.eval(` +var resolve = undefined; +var callbackPromise = new Promise(r => { resolve = r; }); +var callback = function (v) { resolve(v + 1); }; + +var then = function(onFulfilled, onRejected) { + onFulfilled(10); +}; +`); + + // Create a bound function where its realm is privileged realm, and + // its target is from sandbox realm. + sandbox.bound_then = Function.prototype.bind.call(sandbox.then, sandbox); + + // Creating a promise thenable job in the following `Promise.resolve` performs + // GetFunctionRealm on the bound thenable.then and fails. The reaction job + // should be created with sandbox realm. + sandbox.eval(` +var thenable = { + then: bound_then, +}; + +Promise.resolve(thenable).then(callback); +`); + + const result = await sandbox.callbackPromise; + equal(result, 11); +}); diff --git a/dom/promise/tests/unit/test_promise_unhandled_rejection.js b/dom/promise/tests/unit/test_promise_unhandled_rejection.js new file mode 100644 index 0000000000..68471569ec --- /dev/null +++ b/dom/promise/tests/unit/test_promise_unhandled_rejection.js @@ -0,0 +1,139 @@ +"use strict"; + +// Tests that unhandled promise rejections generate the appropriate +// console messages. + +const { AddonTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/AddonTestUtils.sys.mjs" +); +const { PromiseTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/PromiseTestUtils.sys.mjs" +); + +PromiseTestUtils.expectUncaughtRejection(/could not be cloned/); +PromiseTestUtils.expectUncaughtRejection(/An exception was thrown/); +PromiseTestUtils.expectUncaughtRejection(/Bleah/); + +const filename = "resource://foo/Bar.jsm"; + +async function getSandboxMessages(sandbox, code) { + let { messages } = await AddonTestUtils.promiseConsoleOutput(async () => { + Cu.evalInSandbox(code, sandbox, null, filename, 1); + + // We need two trips through the event loop for this error to be reported. + await new Promise(executeSoon); + await new Promise(executeSoon); + }); + + // xpcshell tests on OS-X sometimes include an extra warning, which we + // unfortunately need to ignore: + return messages.filter( + msg => + !msg.message.includes( + "No chrome package registered for chrome://branding/locale/brand.properties" + ) + ); +} + +add_task(async function test_unhandled_dom_exception() { + let sandbox = Cu.Sandbox(Services.scriptSecurityManager.getSystemPrincipal()); + sandbox.StructuredCloneHolder = StructuredCloneHolder; + + let messages = await getSandboxMessages( + sandbox, + `new Promise(() => { + new StructuredCloneHolder("", "", () => {}); + });` + ); + + equal(messages.length, 1, "Got one console message"); + + let [msg] = messages; + ok(msg instanceof Ci.nsIScriptError, "Message is a script error"); + equal(msg.sourceName, filename, "Got expected filename"); + equal(msg.lineNumber, 2, "Got expected line number"); + equal( + msg.errorMessage, + "DataCloneError: Function object could not be cloned.", + "Got expected error message" + ); +}); + +add_task(async function test_unhandled_dom_exception_wrapped() { + let sandbox = Cu.Sandbox( + Services.scriptSecurityManager.createContentPrincipalFromOrigin( + "http://example.com/" + ) + ); + Cu.exportFunction( + function frick() { + throw new Components.Exception( + "Bleah.", + Cr.NS_ERROR_FAILURE, + Components.stack.caller + ); + }, + sandbox, + { defineAs: "frick" } + ); + + let messages = await getSandboxMessages( + sandbox, + `new Promise(() => { + frick(); + });` + ); + + equal(messages.length, 2, "Got two console messages"); + + let [msg1, msg2] = messages; + ok(msg1 instanceof Ci.nsIScriptError, "Message is a script error"); + equal(msg1.sourceName, filename, "Got expected filename"); + equal(msg1.lineNumber, 2, "Got expected line number"); + equal( + msg1.errorMessage, + "NS_ERROR_FAILURE: Bleah.", + "Got expected error message" + ); + + ok(msg2 instanceof Ci.nsIScriptError, "Message is a script error"); + equal(msg2.sourceName, filename, "Got expected filename"); + equal(msg2.lineNumber, 2, "Got expected line number"); + equal( + msg2.errorMessage, + "InvalidStateError: An exception was thrown", + "Got expected error message" + ); +}); + +add_task(async function test_unhandled_dom_exception_from_sandbox() { + let sandbox = Cu.Sandbox( + Services.scriptSecurityManager.createContentPrincipalFromOrigin( + "http://example.com/" + ), + { wantGlobalProperties: ["DOMException"] } + ); + let ctor = Cu.evalInSandbox("DOMException", sandbox); + Cu.exportFunction( + function frick() { + throw new ctor("Bleah."); + }, + sandbox, + { defineAs: "frick" } + ); + + let messages = await getSandboxMessages( + sandbox, + `new Promise(() => { + frick(); + });` + ); + + equal(messages.length, 1, "Got one console messages"); + + let [msg] = messages; + ok(msg instanceof Ci.nsIScriptError, "Message is a script error"); + equal(msg.sourceName, filename, "Got expected filename"); + equal(msg.lineNumber, 2, "Got expected line number"); + equal(msg.errorMessage, "Error: Bleah.", "Got expected error message"); +}); diff --git a/dom/promise/tests/unit/xpcshell.toml b/dom/promise/tests/unit/xpcshell.toml new file mode 100644 index 0000000000..f54bbc4c9e --- /dev/null +++ b/dom/promise/tests/unit/xpcshell.toml @@ -0,0 +1,8 @@ +[DEFAULT] +head = "" + +["test_monitor_uncaught.js"] + +["test_promise_job_across_sandbox.js"] + +["test_promise_unhandled_rejection.js"] |