summaryrefslogtreecommitdiffstats
path: root/dom/base/CustomElementRegistry.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/base/CustomElementRegistry.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/base/CustomElementRegistry.h')
-rw-r--r--dom/base/CustomElementRegistry.h599
1 files changed, 599 insertions, 0 deletions
diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h
new file mode 100644
index 0000000000..099be3ebef
--- /dev/null
+++ b/dom/base/CustomElementRegistry.h
@@ -0,0 +1,599 @@
+/* -*- 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_CustomElementRegistry_h
+#define mozilla_dom_CustomElementRegistry_h
+
+#include "js/GCHashTable.h"
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/CycleCollectedJSContext.h" // for MicroTaskRunnable
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/CustomElementRegistryBinding.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ElementInternals.h"
+#include "mozilla/dom/ElementInternalsBinding.h"
+#include "mozilla/dom/HTMLFormElement.h"
+#include "mozilla/RefPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+#include "nsTHashSet.h"
+#include "nsAtomHashKeys.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+struct CustomElementData;
+struct ElementDefinitionOptions;
+class CallbackFunction;
+class CustomElementCallback;
+class CustomElementReaction;
+class DocGroup;
+class Promise;
+
+enum class ElementCallbackType {
+ eConnected,
+ eDisconnected,
+ eAdopted,
+ eAttributeChanged,
+ eFormAssociated,
+ eFormReset,
+ eFormDisabled,
+ eFormStateRestore,
+ eGetCustomInterface
+};
+
+struct LifecycleCallbackArgs {
+ // Used by the attribute changed callback.
+ RefPtr<nsAtom> mName;
+ nsString mOldValue;
+ nsString mNewValue;
+ nsString mNamespaceURI;
+
+ // Used by the adopted callback.
+ RefPtr<Document> mOldDocument;
+ RefPtr<Document> mNewDocument;
+
+ // Used by the form associated callback.
+ RefPtr<HTMLFormElement> mForm;
+
+ // Used by the form disabled callback.
+ bool mDisabled;
+
+ // Used by the form state restore callback.
+ Nullable<OwningFileOrUSVStringOrFormData> mState;
+ RestoreReason mReason;
+
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
+};
+
+// Each custom element has an associated callback queue and an element is
+// being created flag.
+struct CustomElementData {
+ // https://dom.spec.whatwg.org/#concept-element-custom-element-state
+ // CustomElementData is only created on the element which is a custom element
+ // or an upgrade candidate, so the state of an element without
+ // CustomElementData is "uncustomized".
+ enum class State { eUndefined, eFailed, eCustom, ePrecustomized };
+
+ explicit CustomElementData(nsAtom* aType);
+ CustomElementData(nsAtom* aType, State aState);
+ ~CustomElementData() = default;
+
+ // Custom element state as described in the custom element spec.
+ State mState;
+ // custom element reaction queue as described in the custom element spec.
+ // There is 1 reaction in reaction queue, when 1) it becomes disconnected,
+ // 2) it’s adopted into a new document, 3) its attributes are changed,
+ // appended, removed, or replaced.
+ // There are 3 reactions in reaction queue when doing upgrade operation,
+ // e.g., create an element, insert a node.
+ AutoTArray<UniquePtr<CustomElementReaction>, 3> mReactionQueue;
+
+ void SetCustomElementDefinition(CustomElementDefinition* aDefinition);
+ CustomElementDefinition* GetCustomElementDefinition() const;
+ nsAtom* GetCustomElementType() const { return mType; }
+ void AttachedInternals();
+ bool HasAttachedInternals() const { return mIsAttachedInternals; }
+
+ bool IsFormAssociated() const;
+
+ void Traverse(nsCycleCollectionTraversalCallback& aCb) const;
+ void Unlink();
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+
+ nsAtom* GetIs(const Element* aElement) const {
+ // If mType isn't the same as name atom, this is a customized built-in
+ // element, which has 'is' value set.
+ return aElement->NodeInfo()->NameAtom() == mType ? nullptr : mType.get();
+ }
+
+ ElementInternals* GetElementInternals() const { return mElementInternals; }
+
+ ElementInternals* GetOrCreateElementInternals(HTMLElement* aTarget) {
+ if (!mElementInternals) {
+ mElementInternals = MakeAndAddRef<ElementInternals>(aTarget);
+ }
+ return mElementInternals;
+ }
+
+ private:
+ // Custom element type, for <button is="x-button"> or <x-button>
+ // this would be x-button.
+ RefPtr<nsAtom> mType;
+ RefPtr<CustomElementDefinition> mCustomElementDefinition;
+ RefPtr<ElementInternals> mElementInternals;
+ bool mIsAttachedInternals = false;
+};
+
+#define ALREADY_CONSTRUCTED_MARKER nullptr
+
+// The required information for a custom element as defined in:
+// https://html.spec.whatwg.org/multipage/scripting.html#custom-element-definition
+struct CustomElementDefinition {
+ NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(CustomElementDefinition)
+ NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(CustomElementDefinition)
+
+ CustomElementDefinition(
+ nsAtom* aType, nsAtom* aLocalName, int32_t aNamespaceID,
+ CustomElementConstructor* aConstructor,
+ nsTArray<RefPtr<nsAtom>>&& aObservedAttributes,
+ UniquePtr<LifecycleCallbacks>&& aCallbacks,
+ UniquePtr<FormAssociatedLifecycleCallbacks>&& aFormAssociatedCallbacks,
+ bool aFormAssociated, bool aDisableInternals, bool aDisableShadow);
+
+ // The type (name) for this custom element, for <button is="x-foo"> or <x-foo>
+ // this would be x-foo.
+ RefPtr<nsAtom> mType;
+
+ // The localname to (e.g. <button is=type> -- this would be button).
+ RefPtr<nsAtom> mLocalName;
+
+ // The namespace for this custom element
+ int32_t mNamespaceID;
+
+ // The custom element constructor.
+ RefPtr<CustomElementConstructor> mConstructor;
+
+ // The list of attributes that this custom element observes.
+ nsTArray<RefPtr<nsAtom>> mObservedAttributes;
+
+ // The lifecycle callbacks to call for this custom element.
+ UniquePtr<LifecycleCallbacks> mCallbacks;
+ UniquePtr<FormAssociatedLifecycleCallbacks> mFormAssociatedCallbacks;
+
+ // If this is true, user agent treats elements associated to this custom
+ // element definition as form-associated custom elements.
+ bool mFormAssociated = false;
+
+ // Determine whether to allow to attachInternals() for this custom element.
+ bool mDisableInternals = false;
+
+ // Determine whether to allow to attachShadow() for this custom element.
+ bool mDisableShadow = false;
+
+ // A construction stack. Use nullptr to represent an "already constructed
+ // marker".
+ nsTArray<RefPtr<Element>> mConstructionStack;
+
+ // See step 6.1.10 of https://dom.spec.whatwg.org/#concept-create-element
+ // which set up the prefix after a custom element is created. However, In
+ // Gecko, the prefix isn't allowed to be changed in NodeInfo, so we store the
+ // prefix information here and propagate to where NodeInfo is assigned to a
+ // custom element instead.
+ nsTArray<RefPtr<nsAtom>> mPrefixStack;
+
+ // This basically is used for distinguishing the custom element constructor
+ // is invoked from document.createElement or directly from JS, i.e.
+ // `new CustomElementConstructor()`.
+ uint32_t mConstructionDepth = 0;
+
+ bool IsCustomBuiltIn() { return mType != mLocalName; }
+
+ bool IsInObservedAttributeList(nsAtom* aName) {
+ if (mObservedAttributes.IsEmpty()) {
+ return false;
+ }
+
+ return mObservedAttributes.Contains(aName);
+ }
+
+ private:
+ ~CustomElementDefinition() = default;
+};
+
+class CustomElementReaction {
+ public:
+ virtual ~CustomElementReaction() = default;
+ MOZ_CAN_RUN_SCRIPT
+ virtual void Invoke(Element* aElement, ErrorResult& aRv) = 0;
+ virtual void Traverse(nsCycleCollectionTraversalCallback& aCb) const = 0;
+ virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const = 0;
+
+ bool IsUpgradeReaction() { return mIsUpgradeReaction; }
+
+ protected:
+ bool mIsUpgradeReaction = false;
+};
+
+// https://html.spec.whatwg.org/multipage/scripting.html#custom-element-reactions-stack
+class CustomElementReactionsStack {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(CustomElementReactionsStack)
+
+ CustomElementReactionsStack()
+ : mIsBackupQueueProcessing(false),
+ mRecursionDepth(0),
+ mIsElementQueuePushedForCurrentRecursionDepth(false) {}
+
+ // Hold a strong reference of Element so that it does not get cycle collected
+ // before the reactions in its reaction queue are invoked.
+ // The element reaction queues are stored in CustomElementData.
+ // We need to lookup ElementReactionQueueMap again to get relevant reaction
+ // queue. The choice of 3 for the auto size here is based on running Custom
+ // Elements wpt tests.
+ typedef AutoTArray<RefPtr<Element>, 3> ElementQueue;
+
+ /**
+ * Enqueue a custom element upgrade reaction
+ * https://html.spec.whatwg.org/multipage/scripting.html#enqueue-a-custom-element-upgrade-reaction
+ */
+ void EnqueueUpgradeReaction(Element* aElement,
+ CustomElementDefinition* aDefinition);
+
+ /**
+ * Enqueue a custom element callback reaction
+ * https://html.spec.whatwg.org/multipage/scripting.html#enqueue-a-custom-element-callback-reaction
+ */
+ void EnqueueCallbackReaction(
+ Element* aElement,
+ UniquePtr<CustomElementCallback> aCustomElementCallback);
+
+ /**
+ * [CEReactions] Before executing the algorithm's steps.
+ * Increase the current recursion depth, and the element queue is pushed
+ * lazily when we really enqueue reactions.
+ *
+ * @return true if the element queue is pushed for "previous" recursion depth.
+ */
+ bool EnterCEReactions() {
+ bool temp = mIsElementQueuePushedForCurrentRecursionDepth;
+ mRecursionDepth++;
+ // The is-element-queue-pushed flag is initially false when entering a new
+ // recursion level. The original value will be cached in AutoCEReaction
+ // and restored after leaving this recursion level.
+ mIsElementQueuePushedForCurrentRecursionDepth = false;
+ return temp;
+ }
+
+ /**
+ * [CEReactions] After executing the algorithm's steps.
+ * Pop and invoke the element queue if it is created and pushed for current
+ * recursion depth, then decrease the current recursion depth.
+ *
+ * @param aCx JSContext used for handling exception thrown by algorithm's
+ * steps, this could be a nullptr.
+ * aWasElementQueuePushed used for restoring status after leaving
+ * current recursion.
+ */
+ MOZ_CAN_RUN_SCRIPT
+ void LeaveCEReactions(JSContext* aCx, bool aWasElementQueuePushed) {
+ MOZ_ASSERT(mRecursionDepth);
+
+ if (mIsElementQueuePushedForCurrentRecursionDepth) {
+ Maybe<JS::AutoSaveExceptionState> ases;
+ if (aCx) {
+ ases.emplace(aCx);
+ }
+ PopAndInvokeElementQueue();
+ }
+ mRecursionDepth--;
+ // Restore the is-element-queue-pushed flag cached in AutoCEReaction when
+ // leaving the recursion level.
+ mIsElementQueuePushedForCurrentRecursionDepth = aWasElementQueuePushed;
+
+ MOZ_ASSERT_IF(!mRecursionDepth, mReactionsStack.IsEmpty());
+ }
+
+ bool IsElementQueuePushedForCurrentRecursionDepth() {
+ MOZ_ASSERT_IF(mIsElementQueuePushedForCurrentRecursionDepth,
+ !mReactionsStack.IsEmpty() &&
+ !mReactionsStack.LastElement()->IsEmpty());
+ return mIsElementQueuePushedForCurrentRecursionDepth;
+ }
+
+ private:
+ ~CustomElementReactionsStack() = default;
+ ;
+
+ /**
+ * Push a new element queue onto the custom element reactions stack.
+ */
+ void CreateAndPushElementQueue();
+
+ /**
+ * Pop the element queue from the custom element reactions stack, and invoke
+ * custom element reactions in that queue.
+ */
+ MOZ_CAN_RUN_SCRIPT void PopAndInvokeElementQueue();
+
+ // The choice of 8 for the auto size here is based on gut feeling.
+ AutoTArray<UniquePtr<ElementQueue>, 8> mReactionsStack;
+ ElementQueue mBackupQueue;
+ // https://html.spec.whatwg.org/#enqueue-an-element-on-the-appropriate-element-queue
+ bool mIsBackupQueueProcessing;
+
+ MOZ_CAN_RUN_SCRIPT void InvokeBackupQueue();
+
+ /**
+ * Invoke custom element reactions
+ * https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions
+ */
+ MOZ_CAN_RUN_SCRIPT
+ void InvokeReactions(ElementQueue* aElementQueue, nsIGlobalObject* aGlobal);
+
+ void Enqueue(Element* aElement, CustomElementReaction* aReaction);
+
+ // Current [CEReactions] recursion depth.
+ uint32_t mRecursionDepth;
+ // True if the element queue is pushed into reaction stack for current
+ // recursion depth. This will be cached in AutoCEReaction when entering a new
+ // CEReaction recursion and restored after leaving the recursion.
+ bool mIsElementQueuePushedForCurrentRecursionDepth;
+
+ private:
+ class BackupQueueMicroTask final : public mozilla::MicroTaskRunnable {
+ public:
+ explicit BackupQueueMicroTask(CustomElementReactionsStack* aReactionStack)
+ : MicroTaskRunnable(), mReactionStack(aReactionStack) {
+ MOZ_ASSERT(!mReactionStack->mIsBackupQueueProcessing,
+ "mIsBackupQueueProcessing should be initially false");
+ mReactionStack->mIsBackupQueueProcessing = true;
+ }
+
+ MOZ_CAN_RUN_SCRIPT virtual void Run(AutoSlowOperation& aAso) override {
+ mReactionStack->InvokeBackupQueue();
+ mReactionStack->mIsBackupQueueProcessing = false;
+ }
+
+ private:
+ const RefPtr<CustomElementReactionsStack> mReactionStack;
+ };
+};
+
+class CustomElementRegistry final : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(CustomElementRegistry)
+
+ public:
+ explicit CustomElementRegistry(nsPIDOMWindowInner* aWindow);
+
+ private:
+ class RunCustomElementCreationCallback : public mozilla::Runnable {
+ public:
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT.
+ // See bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY
+ NS_DECL_NSIRUNNABLE
+
+ explicit RunCustomElementCreationCallback(
+ CustomElementRegistry* aRegistry, nsAtom* aAtom,
+ CustomElementCreationCallback* aCallback)
+ : mozilla::Runnable(
+ "CustomElementRegistry::RunCustomElementCreationCallback"),
+ mRegistry(aRegistry),
+ mAtom(aAtom),
+ mCallback(aCallback) {}
+
+ private:
+ RefPtr<CustomElementRegistry> mRegistry;
+ RefPtr<nsAtom> mAtom;
+ RefPtr<CustomElementCreationCallback> mCallback;
+ };
+
+ public:
+ /**
+ * Looking up a custom element definition.
+ * https://html.spec.whatwg.org/#look-up-a-custom-element-definition
+ */
+ CustomElementDefinition* LookupCustomElementDefinition(nsAtom* aNameAtom,
+ int32_t aNameSpaceID,
+ nsAtom* aTypeAtom);
+
+ CustomElementDefinition* LookupCustomElementDefinition(
+ JSContext* aCx, JSObject* aConstructor) const;
+
+ static void EnqueueLifecycleCallback(ElementCallbackType aType,
+ Element* aCustomElement,
+ const LifecycleCallbackArgs& aArgs,
+ CustomElementDefinition* aDefinition);
+
+ /**
+ * Upgrade an element.
+ * https://html.spec.whatwg.org/multipage/scripting.html#upgrades
+ */
+ MOZ_CAN_RUN_SCRIPT
+ static void Upgrade(Element* aElement, CustomElementDefinition* aDefinition,
+ ErrorResult& aRv);
+
+ /**
+ * To allow native code to call methods of chrome-implemented custom elements,
+ * a helper method may be defined in the custom element called
+ * 'getCustomInterfaceCallback'. This method takes an IID and returns an
+ * object which implements an XPCOM interface.
+ *
+ * This returns null if aElement is not from a chrome document.
+ */
+ static already_AddRefed<nsISupports> CallGetCustomInterface(
+ Element* aElement, const nsIID& aIID);
+
+ /**
+ * Registers an unresolved custom element that is a candidate for
+ * upgrade. |aTypeName| is the name of the custom element type, if it is not
+ * provided, then element name is used. |aTypeName| should be provided
+ * when registering a custom element that extends an existing
+ * element. e.g. <button is="x-button">.
+ */
+ void RegisterUnresolvedElement(Element* aElement,
+ nsAtom* aTypeName = nullptr);
+
+ /**
+ * Unregister an unresolved custom element that is a candidate for
+ * upgrade when a custom element is removed from tree.
+ */
+ void UnregisterUnresolvedElement(Element* aElement,
+ nsAtom* aTypeName = nullptr);
+
+ /**
+ * Register an element to be upgraded when the custom element creation
+ * callback is executed.
+ *
+ * To be used when LookupCustomElementDefinition() didn't return a definition,
+ * but with the callback scheduled to be run.
+ */
+ inline void RegisterCallbackUpgradeElement(Element* aElement,
+ nsAtom* aTypeName = nullptr) {
+ if (mElementCreationCallbacksUpgradeCandidatesMap.IsEmpty()) {
+ return;
+ }
+
+ RefPtr<nsAtom> typeName = aTypeName;
+ if (!typeName) {
+ typeName = aElement->NodeInfo()->NameAtom();
+ }
+
+ nsTHashSet<RefPtr<nsIWeakReference>>* elements =
+ mElementCreationCallbacksUpgradeCandidatesMap.Get(typeName);
+
+ // If there isn't a table, there won't be a definition added by the
+ // callback.
+ if (!elements) {
+ return;
+ }
+
+ nsWeakPtr elem = do_GetWeakReference(aElement);
+ elements->Insert(elem);
+ }
+
+ void TraceDefinitions(JSTracer* aTrc);
+
+ private:
+ ~CustomElementRegistry();
+
+ bool JSObjectToAtomArray(JSContext* aCx, JS::Handle<JSObject*> aConstructor,
+ const nsString& aName,
+ nsTArray<RefPtr<nsAtom>>& aArray, ErrorResult& aRv);
+
+ void UpgradeCandidates(nsAtom* aKey, CustomElementDefinition* aDefinition,
+ ErrorResult& aRv);
+
+ using DefinitionMap =
+ nsRefPtrHashtable<nsAtomHashKey, CustomElementDefinition>;
+ using ElementCreationCallbackMap =
+ nsRefPtrHashtable<nsAtomHashKey, CustomElementCreationCallback>;
+ using CandidateMap =
+ nsClassHashtable<nsAtomHashKey, nsTHashSet<RefPtr<nsIWeakReference>>>;
+ using ConstructorMap =
+ JS::GCHashMap<JS::Heap<JSObject*>, RefPtr<nsAtom>,
+ js::StableCellHasher<JS::Heap<JSObject*>>,
+ js::SystemAllocPolicy>;
+
+ // Hashtable for custom element definitions in web components.
+ // Custom prototypes are stored in the compartment where definition was
+ // defined.
+ DefinitionMap mCustomDefinitions;
+
+ // Hashtable for chrome-only callbacks that is called *before* we return
+ // a CustomElementDefinition, when the typeAtom matches.
+ // The callbacks are registered with the setElementCreationCallback method.
+ ElementCreationCallbackMap mElementCreationCallbacks;
+
+ // Hashtable for looking up definitions by using constructor as key.
+ // Custom elements' name are stored here and we need to lookup
+ // mCustomDefinitions again to get definitions.
+ ConstructorMap mConstructors;
+
+ using WhenDefinedPromiseMap = nsRefPtrHashtable<nsAtomHashKey, Promise>;
+ WhenDefinedPromiseMap mWhenDefinedPromiseMap;
+
+ // The "upgrade candidates map" from the web components spec. Maps from a
+ // namespace id and local name to a list of elements to upgrade if that
+ // element is registered as a custom element.
+ CandidateMap mCandidatesMap;
+
+ // If an element creation callback is found, the nsTHashtable for the
+ // type is created here, and elements will later be upgraded.
+ CandidateMap mElementCreationCallbacksUpgradeCandidatesMap;
+
+ nsCOMPtr<nsPIDOMWindowInner> mWindow;
+
+ // It is used to prevent reentrant invocations of element definition.
+ bool mIsCustomDefinitionRunning;
+
+ private:
+ int32_t InferNamespace(JSContext* aCx, JS::Handle<JSObject*> constructor);
+
+ public:
+ nsISupports* GetParentObject() const;
+
+ DocGroup* GetDocGroup() const;
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ void Define(JSContext* aCx, const nsAString& aName,
+ CustomElementConstructor& aFunctionConstructor,
+ const ElementDefinitionOptions& aOptions, ErrorResult& aRv);
+
+ void Get(const nsAString& name,
+ OwningCustomElementConstructorOrUndefined& aRetVal);
+
+ void GetName(JSContext* aCx, CustomElementConstructor& aConstructor,
+ nsAString& aResult);
+
+ already_AddRefed<Promise> WhenDefined(const nsAString& aName,
+ ErrorResult& aRv);
+
+ // Chrome-only method that give JS an opportunity to only load the custom
+ // element definition script when needed.
+ void SetElementCreationCallback(const nsAString& aName,
+ CustomElementCreationCallback& aCallback,
+ ErrorResult& aRv);
+
+ void Upgrade(nsINode& aRoot);
+};
+
+class MOZ_RAII AutoCEReaction final {
+ public:
+ // JSContext is allowed to be a nullptr if we are guaranteeing that we're
+ // not doing something that might throw but not finish reporting a JS
+ // exception during the lifetime of the AutoCEReaction.
+ AutoCEReaction(CustomElementReactionsStack* aReactionsStack, JSContext* aCx)
+ : mReactionsStack(aReactionsStack), mCx(aCx) {
+ mIsElementQueuePushedForPreviousRecursionDepth =
+ mReactionsStack->EnterCEReactions();
+ }
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY because this is called from Maybe<>.reset().
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY ~AutoCEReaction() {
+ mReactionsStack->LeaveCEReactions(
+ mCx, mIsElementQueuePushedForPreviousRecursionDepth);
+ }
+
+ private:
+ const RefPtr<CustomElementReactionsStack> mReactionsStack;
+ JSContext* mCx;
+ bool mIsElementQueuePushedForPreviousRecursionDepth;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_CustomElementRegistry_h