From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/promise/PromiseCallback.h | 203 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) create mode 100644 dom/promise/PromiseCallback.h (limited to 'dom/promise/PromiseCallback.h') diff --git a/dom/promise/PromiseCallback.h b/dom/promise/PromiseCallback.h new file mode 100644 index 000000000..9f55e03d0 --- /dev/null +++ b/dom/promise/PromiseCallback.h @@ -0,0 +1,203 @@ +/* -*- 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_PromiseCallback_h +#define mozilla_dom_PromiseCallback_h + +#include "mozilla/dom/Promise.h" +#include "nsCycleCollectionParticipant.h" + +namespace mozilla { +namespace dom { + +#ifndef SPIDERMONKEY_PROMISE +// This is the base class for any PromiseCallback. +// It's a logical step in the promise chain of callbacks. +class PromiseCallback : public nsISupports +{ +protected: + virtual ~PromiseCallback(); + +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(PromiseCallback) + + PromiseCallback(); + + virtual nsresult Call(JSContext* aCx, + JS::Handle aValue) = 0; + + // Return the Promise that this callback will end up resolving or + // rejecting, if any. + virtual Promise* GetDependentPromise() = 0; + + enum Task { + Resolve, + Reject + }; + + // This factory returns a PromiseCallback object with refcount of 0. + static PromiseCallback* + Factory(Promise* aNextPromise, JS::Handle aObject, + AnyCallback* aCallback, Task aTask); +}; + +// WrapperPromiseCallback execs a JS Callback with a value, and then the return +// value is sent to either: +// a) If aNextPromise is non-null, the aNextPromise->ResolveFunction() or to +// aNextPromise->RejectFunction() if the JS Callback throws. +// or +// b) If aNextPromise is null, in which case aResolveFunc and aRejectFunc must +// be non-null, then to aResolveFunc, unless aCallback threw, in which case +// aRejectFunc. +class WrapperPromiseCallback final : public PromiseCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WrapperPromiseCallback, + PromiseCallback) + + nsresult Call(JSContext* aCx, + JS::Handle aValue) override; + + Promise* GetDependentPromise() override; + + // Constructor for when we know we have a vanilla Promise. + WrapperPromiseCallback(Promise* aNextPromise, JS::Handle aGlobal, + AnyCallback* aCallback); + + // Constructor for when all we have to work with are resolve/reject functions. + WrapperPromiseCallback(JS::Handle aGlobal, + AnyCallback* aCallback, + JS::Handle mNextPromiseObj, + AnyCallback* aResolveFunc, + AnyCallback* aRejectFunc); + +private: + ~WrapperPromiseCallback(); + + // Either mNextPromise is non-null or all three of mNextPromiseObj, + // mResolveFund and mRejectFunc must are non-null. + RefPtr mNextPromise; + // mNextPromiseObj is the reflector itself; it may not be in the + // same compartment as anything else we have. + JS::Heap mNextPromiseObj; + RefPtr mResolveFunc; + RefPtr mRejectFunc; + JS::Heap mGlobal; + RefPtr mCallback; +}; + +// ResolvePromiseCallback calls aPromise->ResolveFunction() with the value +// received by Call(). +class ResolvePromiseCallback final : public PromiseCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(ResolvePromiseCallback, + PromiseCallback) + + nsresult Call(JSContext* aCx, + JS::Handle aValue) override; + + Promise* GetDependentPromise() override + { + return mPromise; + } + + ResolvePromiseCallback(Promise* aPromise, JS::Handle aGlobal); + +private: + ~ResolvePromiseCallback(); + + RefPtr mPromise; + JS::Heap mGlobal; +}; + +// RejectPromiseCallback calls aPromise->RejectFunction() with the value +// received by Call(). +class RejectPromiseCallback final : public PromiseCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(RejectPromiseCallback, + PromiseCallback) + + nsresult Call(JSContext* aCx, + JS::Handle aValue) override; + + Promise* GetDependentPromise() override + { + return mPromise; + } + + RejectPromiseCallback(Promise* aPromise, JS::Handle aGlobal); + +private: + ~RejectPromiseCallback(); + + RefPtr mPromise; + JS::Heap mGlobal; +}; + +// InvokePromiseFuncCallback calls the given function with the value +// received by Call(). +class InvokePromiseFuncCallback final : public PromiseCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(InvokePromiseFuncCallback, + PromiseCallback) + + nsresult Call(JSContext* aCx, + JS::Handle aValue) override; + + Promise* GetDependentPromise() override; + + InvokePromiseFuncCallback(JS::Handle aGlobal, + JS::Handle aNextPromiseObj, + AnyCallback* aPromiseFunc); + +private: + ~InvokePromiseFuncCallback(); + + JS::Heap mGlobal; + JS::Heap mNextPromiseObj; + RefPtr mPromiseFunc; +}; + +// NativePromiseCallback wraps a PromiseNativeHandler. +class NativePromiseCallback final : public PromiseCallback +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(NativePromiseCallback, + PromiseCallback) + + nsresult Call(JSContext* aCx, + JS::Handle aValue) override; + + Promise* GetDependentPromise() override + { + return nullptr; + } + + NativePromiseCallback(PromiseNativeHandler* aHandler, + Promise::PromiseState aState); + +private: + ~NativePromiseCallback(); + + RefPtr mHandler; + Promise::PromiseState mState; +}; + +#endif // SPIDERMONKEY_PROMISE + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_PromiseCallback_h -- cgit v1.2.3