summaryrefslogtreecommitdiffstats
path: root/dom/base/MutationObservers.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/base/MutationObservers.cpp250
1 files changed, 250 insertions, 0 deletions
diff --git a/dom/base/MutationObservers.cpp b/dom/base/MutationObservers.cpp
new file mode 100644
index 0000000000..e3e7c8b02e
--- /dev/null
+++ b/dom/base/MutationObservers.cpp
@@ -0,0 +1,250 @@
+/* -*- 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 "MutationObservers.h"
+
+#include "nsContentUtils.h"
+#include "nsCSSPseudoElements.h"
+#include "nsINode.h"
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/Element.h"
+#include "nsIMutationObserver.h"
+#include "mozilla/EventListenerManager.h"
+#include "PLDHashTable.h"
+#include "nsCOMArray.h"
+#include "nsPIDOMWindow.h"
+#include "nsXULElement.h"
+#include "nsGenericHTMLElement.h"
+#include "mozilla/AnimationTarget.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/Animation.h"
+#include "mozilla/dom/KeyframeEffect.h"
+#include "mozilla/PresShell.h"
+#include "nsWrapperCacheInlines.h"
+#include "nsDOMMutationObserver.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/CustomElementRegistry.h"
+#include "mozilla/dom/HTMLTemplateElement.h"
+#include "mozilla/dom/ShadowRoot.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#define NOTIFY_PRESSHELL(notify_) \
+ if (PresShell* presShell = doc->GetObservingPresShell()) { \
+ notify_(presShell); \
+ }
+
+#define NOTIFIER(func_, ...) \
+ [&](nsIMutationObserver* aObserver) { aObserver->func_(__VA_ARGS__); }
+
+template <typename NotifyObserver>
+static inline nsINode* ForEachAncestorObserver(nsINode* aNode,
+ NotifyObserver& aFunc,
+ uint32_t aCallback) {
+ nsINode* last;
+ nsINode* node = aNode;
+ do {
+ mozilla::SafeDoublyLinkedList<nsIMutationObserver>* observers =
+ node->GetMutationObservers();
+ if (observers) {
+ for (auto iter = observers->begin(); iter != observers->end(); ++iter) {
+ if (iter->IsCallbackEnabled(aCallback)) {
+ aFunc(&*iter);
+ }
+ }
+ }
+ last = node;
+ if (!(node = node->GetParentNode())) {
+ if (ShadowRoot* shadow = ShadowRoot::FromNode(last)) {
+ node = shadow->GetHost();
+ }
+ }
+ } while (node);
+ return last;
+}
+
+// Whether to notify to the PresShell about a mutation.
+// For removals, the pres shell gets notified first, since it needs to operate
+// on the "old" DOM shape.
+enum class NotifyPresShell { No, Before, After };
+
+template <NotifyPresShell aNotifyPresShell = NotifyPresShell::After,
+ typename NotifyObserver>
+static inline void Notify(nsINode* aNode, NotifyObserver&& aNotify,
+ uint32_t aCallback) {
+ Document* doc = aNode->OwnerDoc();
+ nsDOMMutationEnterLeave enterLeave(doc);
+
+#ifdef DEBUG
+ const bool wasConnected = aNode->IsInComposedDoc();
+#endif
+ if constexpr (aNotifyPresShell == NotifyPresShell::Before) {
+ if (aNode->IsInComposedDoc()) {
+ NOTIFY_PRESSHELL(aNotify);
+ }
+ }
+ nsINode* last = ForEachAncestorObserver(aNode, aNotify, aCallback);
+ // For non-removals, the pres shell gets notified last, since it needs to
+ // operate on the "final" DOM shape.
+ if constexpr (aNotifyPresShell == NotifyPresShell::After) {
+ if (last == doc) {
+ NOTIFY_PRESSHELL(aNotify);
+ }
+ }
+ MOZ_ASSERT((last == doc) == wasConnected,
+ "If we were connected we should notify all ancestors all the "
+ "way to the document");
+}
+
+#define IMPL_ANIMATION_NOTIFICATION(func_, content_, params_) \
+ PR_BEGIN_MACRO \
+ nsDOMMutationEnterLeave enterLeave(doc); \
+ auto forEach = [&](nsIMutationObserver* aObserver) { \
+ if (nsCOMPtr<nsIAnimationObserver> obs = do_QueryInterface(aObserver)) { \
+ obs->func_ params_; \
+ } \
+ }; \
+ ForEachAncestorObserver(content_, forEach, nsIMutationObserver::k##func_); \
+ PR_END_MACRO
+
+namespace mozilla {
+void MutationObservers::NotifyCharacterDataWillChange(
+ nsIContent* aContent, const CharacterDataChangeInfo& aInfo) {
+ Notify(aContent, NOTIFIER(CharacterDataWillChange, aContent, aInfo),
+ nsIMutationObserver::kCharacterDataWillChange);
+}
+
+void MutationObservers::NotifyCharacterDataChanged(
+ nsIContent* aContent, const CharacterDataChangeInfo& aInfo) {
+ aContent->OwnerDoc()->Changed();
+ Notify(aContent, NOTIFIER(CharacterDataChanged, aContent, aInfo),
+ nsIMutationObserver::kCharacterDataChanged);
+}
+
+void MutationObservers::NotifyAttributeWillChange(Element* aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute,
+ int32_t aModType) {
+ Notify(aElement,
+ NOTIFIER(AttributeWillChange, aElement, aNameSpaceID, aAttribute,
+ aModType),
+ nsIMutationObserver::kAttributeWillChange);
+}
+
+void MutationObservers::NotifyAttributeChanged(Element* aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute,
+ int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ aElement->OwnerDoc()->Changed();
+ Notify(aElement,
+ NOTIFIER(AttributeChanged, aElement, aNameSpaceID, aAttribute,
+ aModType, aOldValue),
+ nsIMutationObserver::kAttributeChanged);
+}
+
+void MutationObservers::NotifyAttributeSetToCurrentValue(Element* aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute) {
+ Notify(
+ aElement,
+ NOTIFIER(AttributeSetToCurrentValue, aElement, aNameSpaceID, aAttribute),
+ nsIMutationObserver::kAttributeSetToCurrentValue);
+}
+
+void MutationObservers::NotifyContentAppended(nsIContent* aContainer,
+ nsIContent* aFirstNewContent) {
+ aContainer->OwnerDoc()->Changed();
+ Notify(aContainer, NOTIFIER(ContentAppended, aFirstNewContent),
+ nsIMutationObserver::kContentAppended);
+}
+
+void MutationObservers::NotifyContentInserted(nsINode* aContainer,
+ nsIContent* aChild) {
+ MOZ_ASSERT(aContainer->IsContent() || aContainer->IsDocument(),
+ "container must be an nsIContent or an Document");
+ aContainer->OwnerDoc()->Changed();
+ Notify(aContainer, NOTIFIER(ContentInserted, aChild),
+ nsIMutationObserver::kContentInserted);
+}
+
+void MutationObservers::NotifyContentRemoved(nsINode* aContainer,
+ nsIContent* aChild,
+ nsIContent* aPreviousSibling) {
+ MOZ_ASSERT(aContainer->IsContent() || aContainer->IsDocument(),
+ "container must be an nsIContent or an Document");
+ aContainer->OwnerDoc()->Changed();
+ MOZ_ASSERT(aChild->GetParentNode() == aContainer,
+ "We expect the parent link to be still around at this point");
+ Notify<NotifyPresShell::Before>(
+ aContainer, NOTIFIER(ContentRemoved, aChild, aPreviousSibling),
+ nsIMutationObserver::kContentRemoved);
+}
+
+void MutationObservers::NotifyARIAAttributeDefaultWillChange(
+ mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {
+ Notify<NotifyPresShell::No>(
+ aElement,
+ NOTIFIER(ARIAAttributeDefaultWillChange, aElement, aAttribute, aModType),
+ nsIMutationObserver::kARIAAttributeDefaultWillChange);
+}
+
+void MutationObservers::NotifyARIAAttributeDefaultChanged(
+ mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {
+ Notify<NotifyPresShell::No>(
+ aElement,
+ NOTIFIER(ARIAAttributeDefaultChanged, aElement, aAttribute, aModType),
+ nsIMutationObserver::kARIAAttributeDefaultChanged);
+}
+
+} // namespace mozilla
+
+void MutationObservers::NotifyAnimationMutated(
+ dom::Animation* aAnimation, AnimationMutationType aMutatedType) {
+ MOZ_ASSERT(aAnimation);
+
+ NonOwningAnimationTarget target = aAnimation->GetTargetForAnimation();
+ if (!target) {
+ return;
+ }
+
+ // A pseudo element and its parent element use the same owner doc.
+ Document* doc = target.mElement->OwnerDoc();
+ if (doc->MayHaveAnimationObservers()) {
+ // we use the its parent element as the subject in DOM Mutation Observer.
+ Element* elem = target.mElement;
+ switch (aMutatedType) {
+ case AnimationMutationType::Added:
+ IMPL_ANIMATION_NOTIFICATION(AnimationAdded, elem, (aAnimation));
+ break;
+ case AnimationMutationType::Changed:
+ IMPL_ANIMATION_NOTIFICATION(AnimationChanged, elem, (aAnimation));
+ break;
+ case AnimationMutationType::Removed:
+ IMPL_ANIMATION_NOTIFICATION(AnimationRemoved, elem, (aAnimation));
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("unexpected mutation type");
+ }
+ }
+}
+
+void MutationObservers::NotifyAnimationAdded(dom::Animation* aAnimation) {
+ NotifyAnimationMutated(aAnimation, AnimationMutationType::Added);
+}
+
+void MutationObservers::NotifyAnimationChanged(dom::Animation* aAnimation) {
+ NotifyAnimationMutated(aAnimation, AnimationMutationType::Changed);
+}
+
+void MutationObservers::NotifyAnimationRemoved(dom::Animation* aAnimation) {
+ NotifyAnimationMutated(aAnimation, AnimationMutationType::Removed);
+}