From 2d31ebf6b6bba8c1b90982f687346e5c6a0ff6ef Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Thu, 2 Jan 2020 21:24:22 -0500 Subject: Bug 1274159 - Part 1: Support looking up definitions by using constructor as a key; Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index ff803a054..9034dd7ea 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -7,13 +7,14 @@ #ifndef mozilla_dom_CustomElementRegistry_h #define mozilla_dom_CustomElementRegistry_h +#include "js/GCHashTable.h" #include "js/TypeDecls.h" #include "mozilla/Attributes.h" #include "mozilla/ErrorResult.h" #include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/FunctionBinding.h" #include "nsCycleCollectionParticipant.h" #include "nsWrapperCache.h" -#include "mozilla/dom/FunctionBinding.h" class nsDocument; @@ -173,6 +174,8 @@ private: explicit CustomElementRegistry(nsPIDOMWindowInner* aWindow); ~CustomElementRegistry(); + bool Init(); + /** * Registers an unresolved custom element that is a candidate for * upgrade when the definition is registered via registerElement. @@ -192,15 +195,25 @@ private: DefinitionMap; typedef nsClassHashtable> CandidateMap; + typedef JS::GCHashMap, + nsCOMPtr, + js::MovableCellHasher>, + js::SystemAllocPolicy> ConstructorMap; // Hashtable for custom element definitions in web components. // Custom prototypes are stored in the compartment where // registerElement was called. DefinitionMap mCustomDefinitions; + // 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; + typedef nsRefPtrHashtable WhenDefinedPromiseMap; 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. -- cgit v1.2.3 From 5222f6e9daa4cb74b404f769b23510b3d600efd9 Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Thu, 2 Jan 2020 21:25:47 -0500 Subject: Bug 1274159 - Part 2-2: Support HTMLConstructor WebIDL extended attribute for custom elements; Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 9034dd7ea..8ef0785af 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -128,6 +128,10 @@ struct CustomElementDefinition // The document custom element order. uint32_t mDocOrder; + + bool IsCustomBuiltIn() { + return mType != mLocalName; + } }; class CustomElementRegistry final : public nsISupports, @@ -155,6 +159,9 @@ public: CustomElementDefinition* LookupCustomElementDefinition( const nsAString& aLocalName, const nsAString* aIs = nullptr) const; + CustomElementDefinition* LookupCustomElementDefinition( + JSContext* aCx, JSObject *aConstructor) const; + /** * Enqueue created callback or register upgrade candidate for * newly created custom elements, possibly extending an existing type. -- cgit v1.2.3 From 3a97503b361b0b5ff1b5d8948a74497710f2a095 Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Thu, 2 Jan 2020 22:04:11 -0500 Subject: Bug 1309184 - Implement upgrade reaction for custom element reactions. Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 110 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 8ef0785af..b3b4d7c0f 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -134,6 +134,37 @@ struct CustomElementDefinition } }; +class CustomElementReaction +{ +public: + explicit CustomElementReaction(CustomElementRegistry* aRegistry, + CustomElementDefinition* aDefinition) + : mRegistry(aRegistry) + , mDefinition(aDefinition) + { + }; + + virtual ~CustomElementReaction() = default; + virtual void Invoke(Element* aElement) = 0; + +protected: + CustomElementRegistry* mRegistry; + CustomElementDefinition* mDefinition; +}; + +class CustomElementUpgradeReaction final : public CustomElementReaction +{ +public: + explicit CustomElementUpgradeReaction(CustomElementRegistry* aRegistry, + CustomElementDefinition* aDefinition) + : CustomElementReaction(aRegistry, aDefinition) + { + } + +private: + virtual void Invoke(Element* aElement) override; +}; + class CustomElementRegistry final : public nsISupports, public nsWrapperCache { @@ -177,6 +208,24 @@ public: void GetCustomPrototype(nsIAtom* aAtom, JS::MutableHandle aPrototype); + /** + * 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); + + void Upgrade(Element* aElement, CustomElementDefinition* aDefinition); + + // [CEReactions] Before executing the algorithm's steps + // Push a new element queue onto the custom element reactions stack. + void CreateAndPushElementQueue(); + + // [CEReactions] After executing the algorithm's steps + // Pop the element queue from the custom element reactions stack, + // and invoke custom element reactions in that queue. + void PopAndInvokeElementQueue(); + private: explicit CustomElementRegistry(nsPIDOMWindowInner* aWindow); ~CustomElementRegistry(); @@ -198,6 +247,21 @@ private: nsIAtom* aKey, CustomElementDefinition* aDefinition); + void InvokeBackupQueue(); + + void Enqueue(Element* aElement, CustomElementReaction* aReaction); + + // nsWeakPtr is a weak pointer of Element + // The element reaction queues are stored in ElementReactionQueueMap. + // We need to lookup ElementReactionQueueMap again to get relevant reaction queue. + typedef nsTArray ElementQueue; + + /** + * Invoke custom element reactions + * https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions + */ + void InvokeReactions(ElementQueue& aElementQueue); + typedef nsClassHashtable DefinitionMap; typedef nsClassHashtable> @@ -238,6 +302,17 @@ private: // It is used to prevent reentrant invocations of element definition. bool mIsCustomDefinitionRunning; + // https://html.spec.whatwg.org/#enqueue-an-element-on-the-appropriate-element-queue + bool mIsBackupQueueProcessing; + + typedef nsTArray> ReactionQueue; + typedef nsClassHashtable + ElementReactionQueueMap; + + ElementReactionQueueMap mElementReactionQueueMap; + + nsTArray mReactionsStack; + ElementQueue mBackupQueue; private: class MOZ_RAII AutoSetRunningFlag final { @@ -258,6 +333,28 @@ private: CustomElementRegistry* mRegistry; }; +private: + class ProcessBackupQueueRunnable : public mozilla::Runnable { + public: + explicit ProcessBackupQueueRunnable(CustomElementRegistry* aRegistry) + : mRegistry(aRegistry) + { + MOZ_ASSERT(!mRegistry->mIsBackupQueueProcessing, + "mIsBackupQueueProcessing should be initially false"); + mRegistry->mIsBackupQueueProcessing = true; + } + + NS_IMETHOD Run() override + { + mRegistry->InvokeBackupQueue(); + mRegistry->mIsBackupQueueProcessing = false; + return NS_OK; + } + + private: + RefPtr mRegistry; + }; + public: nsISupports* GetParentObject() const; @@ -272,6 +369,19 @@ public: already_AddRefed WhenDefined(const nsAString& aName, ErrorResult& aRv); }; +class MOZ_RAII AutoCEReaction final { + public: + explicit AutoCEReaction(CustomElementRegistry* aRegistry) + : mRegistry(aRegistry) { + mRegistry->CreateAndPushElementQueue(); + } + ~AutoCEReaction() { + mRegistry->PopAndInvokeElementQueue(); + } + private: + RefPtr mRegistry; +}; + } // namespace dom } // namespace mozilla -- cgit v1.2.3 From 5cf46e2f87f4f6294d02d96c7905b069c9975eee Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Fri, 3 Jan 2020 18:50:56 -0500 Subject: Bug 1341693 - Don't need to check GetDocShell() when creating CustomElementRegistry; Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index b3b4d7c0f..8fdf28289 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -178,11 +178,13 @@ public: public: static bool IsCustomElementEnabled(JSContext* aCx = nullptr, JSObject* aObject = nullptr); - static already_AddRefed Create(nsPIDOMWindowInner* aWindow); + static void ProcessTopElementQueue(); static void XPCOMShutdown(); + explicit CustomElementRegistry(nsPIDOMWindowInner* aWindow); + /** * Looking up a custom element definition. * https://html.spec.whatwg.org/#look-up-a-custom-element-definition @@ -227,11 +229,8 @@ public: void PopAndInvokeElementQueue(); private: - explicit CustomElementRegistry(nsPIDOMWindowInner* aWindow); ~CustomElementRegistry(); - bool Init(); - /** * Registers an unresolved custom element that is a candidate for * upgrade when the definition is registered via registerElement. -- cgit v1.2.3 From 25a33c7123d457a59ecb4b15a2466cfc8507406b Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Fri, 3 Jan 2020 22:18:55 -0500 Subject: Bug 1347446 - Move custom element reactions stack to DocGroup. Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 157 ++++++++++++++++++++++----------------- 1 file changed, 87 insertions(+), 70 deletions(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 8fdf28289..5fc2eb2fd 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -165,6 +165,86 @@ private: virtual void Invoke(Element* aElement) override; }; +// https://html.spec.whatwg.org/multipage/scripting.html#custom-element-reactions-stack +class CustomElementReactionsStack +{ +public: + NS_INLINE_DECL_REFCOUNTING(CustomElementReactionsStack) + + CustomElementReactionsStack() + : mIsBackupQueueProcessing(false) + { + } + + // nsWeakPtr is a weak pointer of Element + // The element reaction queues are stored in ElementReactionQueueMap. + // We need to lookup ElementReactionQueueMap again to get relevant reaction queue. + typedef nsTArray ElementQueue; + + /** + * Enqueue a custom element upgrade reaction + * https://html.spec.whatwg.org/multipage/scripting.html#enqueue-a-custom-element-upgrade-reaction + */ + void EnqueueUpgradeReaction(CustomElementRegistry* aRegistry, + Element* aElement, + CustomElementDefinition* aDefinition); + + // [CEReactions] Before executing the algorithm's steps + // Push a new element queue onto the custom element reactions stack. + void CreateAndPushElementQueue(); + + // [CEReactions] After executing the algorithm's steps + // Pop the element queue from the custom element reactions stack, + // and invoke custom element reactions in that queue. + void PopAndInvokeElementQueue(); + +private: + ~CustomElementReactionsStack() {}; + + typedef nsTArray> ReactionQueue; + typedef nsClassHashtable + ElementReactionQueueMap; + + ElementReactionQueueMap mElementReactionQueueMap; + + nsTArray mReactionsStack; + ElementQueue mBackupQueue; + // https://html.spec.whatwg.org/#enqueue-an-element-on-the-appropriate-element-queue + bool mIsBackupQueueProcessing; + + void InvokeBackupQueue(); + + /** + * Invoke custom element reactions + * https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions + */ + void InvokeReactions(ElementQueue& aElementQueue); + + void Enqueue(Element* aElement, CustomElementReaction* aReaction); + +private: + class ProcessBackupQueueRunnable : public mozilla::Runnable { + public: + explicit ProcessBackupQueueRunnable(CustomElementReactionsStack* aReactionStack) + : mReactionStack(aReactionStack) + { + MOZ_ASSERT(!mReactionStack->mIsBackupQueueProcessing, + "mIsBackupQueueProcessing should be initially false"); + mReactionStack->mIsBackupQueueProcessing = true; + } + + NS_IMETHOD Run() override + { + mReactionStack->InvokeBackupQueue(); + mReactionStack->mIsBackupQueueProcessing = false; + return NS_OK; + } + + private: + RefPtr mReactionStack; + }; +}; + class CustomElementRegistry final : public nsISupports, public nsWrapperCache { @@ -210,24 +290,8 @@ public: void GetCustomPrototype(nsIAtom* aAtom, JS::MutableHandle aPrototype); - /** - * 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); - void Upgrade(Element* aElement, CustomElementDefinition* aDefinition); - // [CEReactions] Before executing the algorithm's steps - // Push a new element queue onto the custom element reactions stack. - void CreateAndPushElementQueue(); - - // [CEReactions] After executing the algorithm's steps - // Pop the element queue from the custom element reactions stack, - // and invoke custom element reactions in that queue. - void PopAndInvokeElementQueue(); - private: ~CustomElementRegistry(); @@ -244,22 +308,8 @@ private: void UpgradeCandidates(JSContext* aCx, nsIAtom* aKey, - CustomElementDefinition* aDefinition); - - void InvokeBackupQueue(); - - void Enqueue(Element* aElement, CustomElementReaction* aReaction); - - // nsWeakPtr is a weak pointer of Element - // The element reaction queues are stored in ElementReactionQueueMap. - // We need to lookup ElementReactionQueueMap again to get relevant reaction queue. - typedef nsTArray ElementQueue; - - /** - * Invoke custom element reactions - * https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions - */ - void InvokeReactions(ElementQueue& aElementQueue); + CustomElementDefinition* aDefinition, + ErrorResult& aRv); typedef nsClassHashtable DefinitionMap; @@ -301,17 +351,6 @@ private: // It is used to prevent reentrant invocations of element definition. bool mIsCustomDefinitionRunning; - // https://html.spec.whatwg.org/#enqueue-an-element-on-the-appropriate-element-queue - bool mIsBackupQueueProcessing; - - typedef nsTArray> ReactionQueue; - typedef nsClassHashtable - ElementReactionQueueMap; - - ElementReactionQueueMap mElementReactionQueueMap; - - nsTArray mReactionsStack; - ElementQueue mBackupQueue; private: class MOZ_RAII AutoSetRunningFlag final { @@ -332,28 +371,6 @@ private: CustomElementRegistry* mRegistry; }; -private: - class ProcessBackupQueueRunnable : public mozilla::Runnable { - public: - explicit ProcessBackupQueueRunnable(CustomElementRegistry* aRegistry) - : mRegistry(aRegistry) - { - MOZ_ASSERT(!mRegistry->mIsBackupQueueProcessing, - "mIsBackupQueueProcessing should be initially false"); - mRegistry->mIsBackupQueueProcessing = true; - } - - NS_IMETHOD Run() override - { - mRegistry->InvokeBackupQueue(); - mRegistry->mIsBackupQueueProcessing = false; - return NS_OK; - } - - private: - RefPtr mRegistry; - }; - public: nsISupports* GetParentObject() const; @@ -370,15 +387,15 @@ public: class MOZ_RAII AutoCEReaction final { public: - explicit AutoCEReaction(CustomElementRegistry* aRegistry) - : mRegistry(aRegistry) { - mRegistry->CreateAndPushElementQueue(); + explicit AutoCEReaction(CustomElementReactionsStack* aReactionsStack) + : mReactionsStack(aReactionsStack) { + mReactionsStack->CreateAndPushElementQueue(); } ~AutoCEReaction() { - mRegistry->PopAndInvokeElementQueue(); + mReactionsStack->PopAndInvokeElementQueue(); } private: - RefPtr mRegistry; + RefPtr mReactionsStack; }; } // namespace dom -- cgit v1.2.3 From d8109fa9a0aae6ee09eca1d6b5cfab285af318f9 Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Sat, 4 Jan 2020 10:34:36 -0500 Subject: Bug 1309147 - Part 5: Eliminate performance cliff when accessing CEReactions code. Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 5fc2eb2fd..24d501d73 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -179,7 +179,8 @@ public: // nsWeakPtr is a weak pointer of Element // The element reaction queues are stored in ElementReactionQueueMap. // We need to lookup ElementReactionQueueMap again to get relevant reaction queue. - typedef nsTArray ElementQueue; + // The choice of 1 for the auto size here is based on gut feeling. + typedef AutoTArray ElementQueue; /** * Enqueue a custom element upgrade reaction @@ -201,13 +202,19 @@ public: private: ~CustomElementReactionsStack() {}; - typedef nsTArray> ReactionQueue; + // 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. + typedef AutoTArray, 3> ReactionQueue; typedef nsClassHashtable ElementReactionQueueMap; ElementReactionQueueMap mElementReactionQueueMap; - nsTArray mReactionsStack; + // The choice of 8 for the auto size here is based on gut feeling. + AutoTArray mReactionsStack; ElementQueue mBackupQueue; // https://html.spec.whatwg.org/#enqueue-an-element-on-the-appropriate-element-queue bool mIsBackupQueueProcessing; -- cgit v1.2.3 From e86aac28b8f450cc99836b07a5c0ffddb59f222f Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Sat, 4 Jan 2020 13:24:58 -0500 Subject: Bug 1359346 - Implement custom element state; https://dom.spec.whatwg.org/#concept-element-custom-element-state Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 24d501d73..6184c0ac3 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -71,7 +71,18 @@ struct CustomElementData { NS_INLINE_DECL_REFCOUNTING(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 + }; + explicit CustomElementData(nsIAtom* aType); + CustomElementData(nsIAtom* aType, State aState); // Objects in this array are transient and empty after each microtask // checkpoint. nsTArray> mCallbackQueue; @@ -89,6 +100,8 @@ struct CustomElementData // it is used to determine if a new queue needs to be pushed onto the // processing stack. int32_t mAssociatedMicroTask; + // Custom element state as described in the custom element spec. + State mState; // Empties the callback queue. void RunCallbackQueue(); -- cgit v1.2.3 From a2c7b5f1d971cd529e65179ad97d39750e956644 Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Sat, 4 Jan 2020 19:47:42 -0500 Subject: Bug 1325279 - Put the reaction queue in CustomElementData structure instead of using a map; Bug 1347446 makes accessing ElementReactionQueue becomes a bit non-trival (have to get it via DocGroup). Since bug 1359346 already refactors the creation time of CustomElementData, ReactionQueue can also be put into CustomElementData, then we can just get ReactionQueue from Element. Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index 6184c0ac3..cb7bd67a5 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -25,6 +25,7 @@ struct CustomElementData; struct ElementDefinitionOptions; struct LifecycleCallbacks; class CallbackFunction; +class CustomElementReaction; class Function; class Promise; @@ -102,6 +103,13 @@ struct CustomElementData int32_t mAssociatedMicroTask; // 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, 3> mReactionQueue; // Empties the callback queue. void RunCallbackQueue(); @@ -190,7 +198,7 @@ public: } // nsWeakPtr is a weak pointer of Element - // The element reaction queues are stored in ElementReactionQueueMap. + // The element reaction queues are stored in CustomElementData. // We need to lookup ElementReactionQueueMap again to get relevant reaction queue. // The choice of 1 for the auto size here is based on gut feeling. typedef AutoTArray ElementQueue; @@ -215,17 +223,6 @@ public: private: ~CustomElementReactionsStack() {}; - // 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. - typedef AutoTArray, 3> ReactionQueue; - typedef nsClassHashtable - ElementReactionQueueMap; - - ElementReactionQueueMap mElementReactionQueueMap; - // The choice of 8 for the auto size here is based on gut feeling. AutoTArray mReactionsStack; ElementQueue mBackupQueue; -- cgit v1.2.3 From 53c9b77ed41aebb157012eff5e57cad3a962d18e Mon Sep 17 00:00:00 2001 From: Gaming4JC Date: Sat, 4 Jan 2020 23:29:10 -0500 Subject: Bug 1315885 - Part 4: Implement callback reaction for custom element reactions. Note: Skipped SyncInvokeReactions since it is removed in CE v1, waste of time. Tag UXP Issue #1344 --- dom/base/CustomElementRegistry.h | 67 ++++++++++++++++++++++++---------------- 1 file changed, 40 insertions(+), 27 deletions(-) (limited to 'dom/base/CustomElementRegistry.h') diff --git a/dom/base/CustomElementRegistry.h b/dom/base/CustomElementRegistry.h index cb7bd67a5..33f2a95ff 100644 --- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -84,23 +84,14 @@ struct CustomElementData explicit CustomElementData(nsIAtom* aType); CustomElementData(nsIAtom* aType, State aState); - // Objects in this array are transient and empty after each microtask - // checkpoint. - nsTArray> mCallbackQueue; // Custom element type, for