dom/base/nsDOMMutationObserver.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef nsDOMMutationObserver_h
   8 #define nsDOMMutationObserver_h
   9
  10 #include <utility>
  11
  12 #include "mozilla/Attributes.h"
  13 #include "mozilla/dom/Animation.h"
  14 #include "mozilla/dom/Document.h"
  15 #include "mozilla/dom/MutationEventBinding.h"
  16 #include "mozilla/dom/MutationObserverBinding.h"
  17 #include "mozilla/dom/Nullable.h"
  18 #include "nsCOMArray.h"
  19 #include "nsClassHashtable.h"
  20 #include "nsContentList.h"
  21 #include "nsCycleCollectionParticipant.h"
  22 #include "nsGlobalWindowInner.h"
  23 #include "nsIAnimationObserver.h"
  24 #include "nsPIDOMWindow.h"
  25 #include "nsStubAnimationObserver.h"
  26 #include "nsTArray.h"
  27 #include "nsWrapperCache.h"
  28
  29 class nsIPrincipal;
  30
  31 class nsDOMMutationObserver;
  32 using mozilla::dom::MutationObservingInfo;
  33
  34 namespace mozilla::dom {
  35 class Element;
  36 }
  37
  38 class nsDOMMutationRecord final : public nsISupports, public nsWrapperCache {
  39   virtual ~nsDOMMutationRecord() = default;
  40
  41  public:
  42   using AnimationArray = nsTArray<RefPtr<mozilla::dom::Animation>>;
  43
  44   nsDOMMutationRecord(nsAtom* aType, nsISupports* aOwner)
  45       : mType(aType),
  46         mAttrNamespace(VoidString()),
  47         mPrevValue(VoidString()),
  48         mOwner(aOwner) {}
  49
  50   nsISupports* GetParentObject() const { return mOwner; }
  51
  52   virtual JSObject* WrapObject(JSContext* aCx,
  53                                JS::Handle<JSObject*> aGivenProto) override {
  54     return mozilla::dom::MutationRecord_Binding::Wrap(aCx, this, aGivenProto);
  55   }
  56
  57   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  58   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(nsDOMMutationRecord)
  59
  60   void GetType(mozilla::dom::DOMString& aRetVal) const {
  61     aRetVal.SetKnownLiveAtom(mType, mozilla::dom::DOMString::eNullNotExpected);
  62   }
  63
  64   nsINode* GetTarget() const { return mTarget; }
  65
  66   nsINodeList* AddedNodes();
  67
  68   nsINodeList* RemovedNodes();
  69
  70   nsINode* GetPreviousSibling() const { return mPreviousSibling; }
  71
  72   nsINode* GetNextSibling() const { return mNextSibling; }
  73
  74   void GetAttributeName(mozilla::dom::DOMString& aRetVal) const {
  75     aRetVal.SetKnownLiveAtom(mAttrName,
  76                              mozilla::dom::DOMString::eTreatNullAsNull);
  77   }
  78
  79   void GetAttributeNamespace(mozilla::dom::DOMString& aRetVal) const {
  80     aRetVal.SetKnownLiveString(mAttrNamespace);
  81   }
  82
  83   void GetOldValue(mozilla::dom::DOMString& aRetVal) const {
  84     aRetVal.SetKnownLiveString(mPrevValue);
  85   }
  86
  87   void GetAddedAnimations(AnimationArray& aRetVal) const {
  88     aRetVal = mAddedAnimations.Clone();
  89   }
  90
  91   void GetRemovedAnimations(AnimationArray& aRetVal) const {
  92     aRetVal = mRemovedAnimations.Clone();
  93   }
  94
  95   void GetChangedAnimations(AnimationArray& aRetVal) const {
  96     aRetVal = mChangedAnimations.Clone();
  97   }
  98
  99   nsCOMPtr<nsINode> mTarget;
 100   RefPtr<nsAtom> mType;
 101   RefPtr<nsAtom> mAttrName;
 102   nsString mAttrNamespace;
 103   nsString mPrevValue;
 104   RefPtr<nsSimpleContentList> mAddedNodes;
 105   RefPtr<nsSimpleContentList> mRemovedNodes;
 106   nsCOMPtr<nsINode> mPreviousSibling;
 107   nsCOMPtr<nsINode> mNextSibling;
 108   AnimationArray mAddedAnimations;
 109   AnimationArray mRemovedAnimations;
 110   AnimationArray mChangedAnimations;
 111
 112   RefPtr<nsDOMMutationRecord> mNext;
 113   nsCOMPtr<nsISupports> mOwner;
 114 };
 115
 116 // Base class just prevents direct access to
 117 // members to make sure we go through getters/setters.
 118 class nsMutationReceiverBase : public nsStubAnimationObserver {
 119  public:
 120   virtual ~nsMutationReceiverBase() = default;
 121
 122   nsDOMMutationObserver* Observer();
 123   nsINode* Target() { return mParent ? mParent->Target() : mTarget; }
 124   nsINode* RegisterTarget() { return mRegisterTarget; }
 125
 126   bool Subtree() { return mParent ? mParent->Subtree() : mSubtree; }
 127   void SetSubtree(bool aSubtree) {
 128     NS_ASSERTION(!mParent, "Shouldn't have parent");
 129     mSubtree = aSubtree;
 130   }
 131
 132   bool ChildList() { return mParent ? mParent->ChildList() : mChildList; }
 133   void SetChildList(bool aChildList) {
 134     NS_ASSERTION(!mParent, "Shouldn't have parent");
 135     mChildList = aChildList;
 136   }
 137
 138   bool CharacterData() {
 139     return mParent ? mParent->CharacterData() : mCharacterData;
 140   }
 141   void SetCharacterData(bool aCharacterData) {
 142     NS_ASSERTION(!mParent, "Shouldn't have parent");
 143     mCharacterData = aCharacterData;
 144   }
 145
 146   bool CharacterDataOldValue() const {
 147     return mParent ? mParent->CharacterDataOldValue() : mCharacterDataOldValue;
 148   }
 149   void SetCharacterDataOldValue(bool aOldValue) {
 150     NS_ASSERTION(!mParent, "Shouldn't have parent");
 151     mCharacterDataOldValue = aOldValue;
 152   }
 153
 154   bool Attributes() const {
 155     return mParent ? mParent->Attributes() : mAttributes;
 156   }
 157   void SetAttributes(bool aAttributes) {
 158     NS_ASSERTION(!mParent, "Shouldn't have parent");
 159     mAttributes = aAttributes;
 160   }
 161
 162   bool AllAttributes() const {
 163     return mParent ? mParent->AllAttributes() : mAllAttributes;
 164   }
 165   void SetAllAttributes(bool aAll) {
 166     NS_ASSERTION(!mParent, "Shouldn't have parent");
 167     mAllAttributes = aAll;
 168   }
 169
 170   bool Animations() const {
 171     return mParent ? mParent->Animations() : mAnimations;
 172   }
 173   void SetAnimations(bool aAnimations) {
 174     NS_ASSERTION(!mParent, "Shouldn't have parent");
 175     mAnimations = aAnimations;
 176   }
 177
 178   bool AttributeOldValue() const {
 179     return mParent ? mParent->AttributeOldValue() : mAttributeOldValue;
 180   }
 181   void SetAttributeOldValue(bool aOldValue) {
 182     NS_ASSERTION(!mParent, "Shouldn't have parent");
 183     mAttributeOldValue = aOldValue;
 184   }
 185
 186   bool ChromeOnlyNodes() const {
 187     return mParent ? mParent->ChromeOnlyNodes() : mChromeOnlyNodes;
 188   }
 189
 190   void SetChromeOnlyNodes(bool aChromeOnlyNodes) {
 191     NS_ASSERTION(!mParent, "Shouldn't have parent");
 192     mChromeOnlyNodes = aChromeOnlyNodes;
 193   }
 194
 195   nsTArray<RefPtr<nsAtom>>& AttributeFilter() { return mAttributeFilter; }
 196   void SetAttributeFilter(nsTArray<RefPtr<nsAtom>>&& aFilter) {
 197     NS_ASSERTION(!mParent, "Shouldn't have parent");
 198     mAttributeFilter.Clear();
 199     mAttributeFilter = std::move(aFilter);
 200   }
 201
 202   void AddClone(nsMutationReceiverBase* aClone) {
 203     mTransientReceivers.AppendObject(aClone);
 204   }
 205
 206   void RemoveClone(nsMutationReceiverBase* aClone) {
 207     mTransientReceivers.RemoveObject(aClone);
 208   }
 209
 210  protected:
 211   nsMutationReceiverBase(nsINode* aTarget, nsDOMMutationObserver* aObserver)
 212       : mTarget(aTarget),
 213         mObserver(aObserver),
 214         mRegisterTarget(aTarget),
 215         mSubtree(false),
 216         mChildList(false),
 217         mCharacterData(false),
 218         mCharacterDataOldValue(false),
 219         mAttributes(false),
 220         mAllAttributes(false),
 221         mAttributeOldValue(false),
 222         mAnimations(false) {}
 223
 224   nsMutationReceiverBase(nsINode* aRegisterTarget,
 225                          nsMutationReceiverBase* aParent)
 226       : mTarget(nullptr),
 227         mObserver(nullptr),
 228         mParent(aParent),
 229         mRegisterTarget(aRegisterTarget),
 230         mKungFuDeathGrip(aParent->Target()),
 231         mSubtree(false),
 232         mChildList(false),
 233         mCharacterData(false),
 234         mCharacterDataOldValue(false),
 235         mAttributes(false),
 236         mAllAttributes(false),
 237         mAttributeOldValue(false),
 238         mAnimations(false),
 239         mChromeOnlyNodes(false) {
 240     NS_ASSERTION(mParent->Subtree(), "Should clone a non-subtree observer!");
 241   }
 242
 243   virtual void AddMutationObserver() = 0;
 244
 245   void AddObserver() {
 246     AddMutationObserver();
 247     mRegisterTarget->SetMayHaveDOMMutationObserver();
 248     mRegisterTarget->OwnerDoc()->SetMayHaveDOMMutationObservers();
 249   }
 250
 251   bool IsObservable(nsIContent* aContent);
 252
 253   bool ObservesAttr(nsINode* aRegisterTarget, mozilla::dom::Element* aElement,
 254                     int32_t aNameSpaceID, nsAtom* aAttr);
 255
 256   // The target for the MutationObserver.observe() method.
 257   nsINode* mTarget;
 258   nsDOMMutationObserver* mObserver;
 259   RefPtr<nsMutationReceiverBase> mParent;  // Cleared after microtask.
 260   // The node to which Gecko-internal nsIMutationObserver was registered to.
 261   // This is different than mTarget when dealing with transient observers.
 262   nsINode* mRegisterTarget;
 263   nsCOMArray<nsMutationReceiverBase> mTransientReceivers;
 264   // While we have transient receivers, keep the original mutation receiver
 265   // alive so it doesn't go away and disconnect all its transient receivers.
 266   nsCOMPtr<nsINode> mKungFuDeathGrip;
 267
 268  private:
 269   nsTArray<RefPtr<nsAtom>> mAttributeFilter;
 270   bool mSubtree : 1;
 271   bool mChildList : 1;
 272   bool mCharacterData : 1;
 273   bool mCharacterDataOldValue : 1;
 274   bool mAttributes : 1;
 275   bool mAllAttributes : 1;
 276   bool mAttributeOldValue : 1;
 277   bool mAnimations : 1;
 278   bool mChromeOnlyNodes : 1;
 279 };
 280
 281 class nsMutationReceiver : public nsMutationReceiverBase {
 282  protected:
 283   virtual ~nsMutationReceiver() { Disconnect(false); }
 284
 285  public:
 286   static nsMutationReceiver* Create(nsINode* aTarget,
 287                                     nsDOMMutationObserver* aObserver) {
 288     nsMutationReceiver* r = new nsMutationReceiver(aTarget, aObserver);
 289     r->AddObserver();
 290     return r;
 291   }
 292
 293   static nsMutationReceiver* Create(nsINode* aRegisterTarget,
 294                                     nsMutationReceiverBase* aParent) {
 295     nsMutationReceiver* r = new nsMutationReceiver(aRegisterTarget, aParent);
 296     aParent->AddClone(r);
 297     r->AddObserver();
 298     return r;
 299   }
 300
 301   nsMutationReceiver* GetParent() {
 302     return static_cast<nsMutationReceiver*>(mParent.get());
 303   }
 304
 305   void RemoveClones() {
 306     for (int32_t i = 0; i < mTransientReceivers.Count(); ++i) {
 307       nsMutationReceiver* r =
 308           static_cast<nsMutationReceiver*>(mTransientReceivers[i]);
 309       r->DisconnectTransientReceiver();
 310     }
 311     mTransientReceivers.Clear();
 312   }
 313
 314   void DisconnectTransientReceiver() {
 315     if (mRegisterTarget) {
 316       mRegisterTarget->RemoveMutationObserver(this);
 317       mRegisterTarget = nullptr;
 318     }
 319
 320     mParent = nullptr;
 321     NS_ASSERTION(!mTarget, "Should not have mTarget");
 322     NS_ASSERTION(!mObserver, "Should not have mObserver");
 323   }
 324
 325   void Disconnect(bool aRemoveFromObserver);
 326
 327   NS_DECL_ISUPPORTS
 328
 329   NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTEWILLCHANGE
 330   NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATAWILLCHANGE
 331   NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
 332   NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
 333   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
 334   NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
 335
 336   virtual void AttributeSetToCurrentValue(mozilla::dom::Element* aElement,
 337                                           int32_t aNameSpaceID,
 338                                           nsAtom* aAttribute) override {
 339     // We can reuse AttributeWillChange implementation.
 340     AttributeWillChange(aElement, aNameSpaceID, aAttribute,
 341                         mozilla::dom::MutationEvent_Binding::MODIFICATION);
 342   }
 343
 344  protected:
 345   nsMutationReceiver(nsINode* aTarget, nsDOMMutationObserver* aObserver);
 346
 347   nsMutationReceiver(nsINode* aRegisterTarget, nsMutationReceiverBase* aParent)
 348       : nsMutationReceiverBase(aRegisterTarget, aParent) {
 349     NS_ASSERTION(!static_cast<nsMutationReceiver*>(aParent)->GetParent(),
 350                  "Shouldn't create deep observer hierarchies!");
 351   }
 352
 353   virtual void AddMutationObserver() override {
 354     mRegisterTarget->AddMutationObserver(this);
 355   }
 356 };
 357
 358 class nsAnimationReceiver : public nsMutationReceiver {
 359  public:
 360   static nsAnimationReceiver* Create(nsINode* aTarget,
 361                                      nsDOMMutationObserver* aObserver) {
 362     nsAnimationReceiver* r = new nsAnimationReceiver(aTarget, aObserver);
 363     r->AddObserver();
 364     return r;
 365   }
 366
 367   static nsAnimationReceiver* Create(nsINode* aRegisterTarget,
 368                                      nsMutationReceiverBase* aParent) {
 369     nsAnimationReceiver* r = new nsAnimationReceiver(aRegisterTarget, aParent);
 370     aParent->AddClone(r);
 371     r->AddObserver();
 372     return r;
 373   }
 374
 375   NS_DECL_ISUPPORTS_INHERITED
 376
 377   NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONADDED
 378   NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONCHANGED
 379   NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONREMOVED
 380
 381  protected:
 382   virtual ~nsAnimationReceiver() = default;
 383
 384   nsAnimationReceiver(nsINode* aTarget, nsDOMMutationObserver* aObserver)
 385       : nsMutationReceiver(aTarget, aObserver) {}
 386
 387   nsAnimationReceiver(nsINode* aRegisterTarget, nsMutationReceiverBase* aParent)
 388       : nsMutationReceiver(aRegisterTarget, aParent) {}
 389
 390   virtual void AddMutationObserver() override {
 391     mRegisterTarget->AddAnimationObserver(this);
 392   }
 393
 394  private:
 395   enum AnimationMutation {
 396     eAnimationMutation_Added,
 397     eAnimationMutation_Changed,
 398     eAnimationMutation_Removed
 399   };
 400
 401   void RecordAnimationMutation(mozilla::dom::Animation* aAnimation,
 402                                AnimationMutation aMutationType);
 403 };
 404
 405 #define NS_DOM_MUTATION_OBSERVER_IID                 \
 406   {                                                  \
 407     0x0c3b91f8, 0xcc3b, 0x4b08, {                    \
 408       0x9e, 0xab, 0x07, 0x47, 0xa9, 0xe4, 0x65, 0xb4 \
 409     }                                                \
 410   }
 411
 412 class nsDOMMutationObserver final : public nsISupports, public nsWrapperCache {
 413  public:
 414   nsDOMMutationObserver(nsCOMPtr<nsPIDOMWindowInner>&& aOwner,
 415                         mozilla::dom::MutationCallback& aCb)
 416       : mOwner(std::move(aOwner)),
 417         mLastPendingMutation(nullptr),
 418         mPendingMutationCount(0),
 419         mCallback(&aCb),
 420         mWaitingForRun(false),
 421         mMergeAttributeRecords(false),
 422         mId(++sCount) {}
 423   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 424   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsDOMMutationObserver)
 425   NS_DECLARE_STATIC_IID_ACCESSOR(NS_DOM_MUTATION_OBSERVER_IID)
 426
 427   static already_AddRefed<nsDOMMutationObserver> Constructor(
 428       const mozilla::dom::GlobalObject&, mozilla::dom::MutationCallback&,
 429       mozilla::ErrorResult&);
 430
 431   JSObject* WrapObject(JSContext* aCx,
 432                        JS::Handle<JSObject*> aGivenProto) override {
 433     return mozilla::dom::MutationObserver_Binding::Wrap(aCx, this, aGivenProto);
 434   }
 435
 436   nsISupports* GetParentObject() const { return mOwner; }
 437
 438   void Observe(nsINode& aTarget,
 439                const mozilla::dom::MutationObserverInit& aOptions,
 440                nsIPrincipal& aSubjectPrincipal, mozilla::ErrorResult& aRv);
 441
 442   void Disconnect();
 443
 444   void TakeRecords(nsTArray<RefPtr<nsDOMMutationRecord>>& aRetVal);
 445
 446   MOZ_CAN_RUN_SCRIPT void HandleMutation();
 447
 448   void GetObservingInfo(
 449       nsTArray<mozilla::dom::Nullable<MutationObservingInfo>>& aResult,
 450       mozilla::ErrorResult& aRv);
 451
 452   mozilla::dom::MutationCallback* MutationCallback() { return mCallback; }
 453
 454   bool MergeAttributeRecords() { return mMergeAttributeRecords; }
 455
 456   void SetMergeAttributeRecords(bool aVal) { mMergeAttributeRecords = aVal; }
 457
 458   // If both records are for 'attributes' type and for the same target and
 459   // attribute name and namespace are the same, we can skip the newer record.
 460   // aOldRecord->mPrevValue holds the original value, if observed.
 461   bool MergeableAttributeRecord(nsDOMMutationRecord* aOldRecord,
 462                                 nsDOMMutationRecord* aRecord);
 463
 464   void AppendMutationRecord(already_AddRefed<nsDOMMutationRecord> aRecord) {
 465     RefPtr<nsDOMMutationRecord> record = aRecord;
 466     MOZ_ASSERT(record);
 467     if (!mLastPendingMutation) {
 468       MOZ_ASSERT(!mFirstPendingMutation);
 469       mFirstPendingMutation = std::move(record);
 470       mLastPendingMutation = mFirstPendingMutation;
 471     } else {
 472       MOZ_ASSERT(mFirstPendingMutation);
 473       mLastPendingMutation->mNext = std::move(record);
 474       mLastPendingMutation = mLastPendingMutation->mNext;
 475     }
 476     ++mPendingMutationCount;
 477   }
 478
 479   void ClearPendingRecords() {
 480     // Break down the pending mutation record list so that cycle collector
 481     // can delete the objects sooner.
 482     RefPtr<nsDOMMutationRecord> current = std::move(mFirstPendingMutation);
 483     mLastPendingMutation = nullptr;
 484     mPendingMutationCount = 0;
 485     while (current) {
 486       current = std::move(current->mNext);
 487     }
 488   }
 489
 490   // static methods
 491   static void QueueMutationObserverMicroTask();
 492
 493   MOZ_CAN_RUN_SCRIPT
 494   static void HandleMutations(mozilla::AutoSlowOperation& aAso);
 495
 496   static bool AllScheduledMutationObserversAreSuppressed() {
 497     if (sScheduledMutationObservers) {
 498       uint32_t len = sScheduledMutationObservers->Length();
 499       if (len > 0) {
 500         for (uint32_t i = 0; i < len; ++i) {
 501           if (!(*sScheduledMutationObservers)[i]->Suppressed()) {
 502             return false;
 503           }
 504         }
 505         return true;
 506       }
 507     }
 508     return false;
 509   }
 510
 511   static void EnterMutationHandling();
 512   static void LeaveMutationHandling();
 513
 514   static void Shutdown();
 515
 516  protected:
 517   virtual ~nsDOMMutationObserver();
 518
 519   friend class nsMutationReceiver;
 520   friend class nsAnimationReceiver;
 521   friend class nsAutoMutationBatch;
 522   friend class nsAutoAnimationMutationBatch;
 523   nsMutationReceiver* GetReceiverFor(nsINode* aNode, bool aMayCreate,
 524                                      bool aWantsAnimations);
 525   void RemoveReceiver(nsMutationReceiver* aReceiver);
 526
 527   void GetAllSubtreeObserversFor(nsINode* aNode,
 528                                  nsTArray<nsMutationReceiver*>& aObservers);
 529   void ScheduleForRun();
 530   void RescheduleForRun();
 531
 532   nsDOMMutationRecord* CurrentRecord(nsAtom* aType);
 533   bool HasCurrentRecord(const nsAString& aType);
 534
 535   bool Suppressed() {
 536     return mOwner && nsGlobalWindowInner::Cast(mOwner)->IsInSyncOperation();
 537   }
 538
 539   MOZ_CAN_RUN_SCRIPT
 540   static void HandleMutationsInternal(mozilla::AutoSlowOperation& aAso);
 541
 542   static void AddCurrentlyHandlingObserver(nsDOMMutationObserver* aObserver,
 543                                            uint32_t aMutationLevel);
 544
 545   nsCOMPtr<nsPIDOMWindowInner> mOwner;
 546
 547   nsCOMArray<nsMutationReceiver> mReceivers;
 548   nsClassHashtable<nsISupportsHashKey, nsCOMArray<nsMutationReceiver>>
 549       mTransientReceivers;
 550   // MutationRecords which are being constructed.
 551   AutoTArray<nsDOMMutationRecord*, 4> mCurrentMutations;
 552   // MutationRecords which will be handed to the callback at the end of
 553   // the microtask.
 554   RefPtr<nsDOMMutationRecord> mFirstPendingMutation;
 555   nsDOMMutationRecord* mLastPendingMutation;
 556   uint32_t mPendingMutationCount;
 557
 558   RefPtr<mozilla::dom::MutationCallback> mCallback;
 559
 560   bool mWaitingForRun;
 561   bool mMergeAttributeRecords;
 562
 563   uint64_t mId;
 564
 565   static uint64_t sCount;
 566   static AutoTArray<RefPtr<nsDOMMutationObserver>, 4>*
 567       sScheduledMutationObservers;
 568
 569   static uint32_t sMutationLevel;
 570   static AutoTArray<AutoTArray<RefPtr<nsDOMMutationObserver>, 4>, 4>*
 571       sCurrentlyHandlingObservers;
 572 };
 573
 574 NS_DEFINE_STATIC_IID_ACCESSOR(nsDOMMutationObserver,
 575                               NS_DOM_MUTATION_OBSERVER_IID)
 576
 577 class nsAutoMutationBatch {
 578  public:
 579   nsAutoMutationBatch()
 580       : mPreviousBatch(nullptr),
 581         mBatchTarget(nullptr),
 582         mRemovalDone(false),
 583         mFromFirstToLast(false),
 584         mAllowNestedBatches(false) {}
 585
 586   nsAutoMutationBatch(nsINode* aTarget, bool aFromFirstToLast,
 587                       bool aAllowNestedBatches)
 588       : mPreviousBatch(nullptr),
 589         mBatchTarget(nullptr),
 590         mRemovalDone(false),
 591         mFromFirstToLast(false),
 592         mAllowNestedBatches(false) {
 593     Init(aTarget, aFromFirstToLast, aAllowNestedBatches);
 594   }
 595
 596   void Init(nsINode* aTarget, bool aFromFirstToLast, bool aAllowNestedBatches) {
 597     if (aTarget && aTarget->OwnerDoc()->MayHaveDOMMutationObservers()) {
 598       if (sCurrentBatch && !sCurrentBatch->mAllowNestedBatches) {
 599         return;
 600       }
 601       mBatchTarget = aTarget;
 602       mFromFirstToLast = aFromFirstToLast;
 603       mAllowNestedBatches = aAllowNestedBatches;
 604       mPreviousBatch = sCurrentBatch;
 605       sCurrentBatch = this;
 606       nsDOMMutationObserver::EnterMutationHandling();
 607     }
 608   }
 609
 610   void RemovalDone() { mRemovalDone = true; }
 611   static bool IsRemovalDone() { return sCurrentBatch->mRemovalDone; }
 612
 613   void SetPrevSibling(nsINode* aNode) { mPrevSibling = aNode; }
 614   void SetNextSibling(nsINode* aNode) { mNextSibling = aNode; }
 615
 616   void Done();
 617
 618   ~nsAutoMutationBatch() { NodesAdded(); }
 619
 620   static bool IsBatching() { return !!sCurrentBatch; }
 621
 622   static nsAutoMutationBatch* GetCurrentBatch() { return sCurrentBatch; }
 623
 624   static void UpdateObserver(nsDOMMutationObserver* aObserver,
 625                              bool aWantsChildList) {
 626     uint32_t l = sCurrentBatch->mObservers.Length();
 627     for (uint32_t i = 0; i < l; ++i) {
 628       if (sCurrentBatch->mObservers[i].mObserver == aObserver) {
 629         if (aWantsChildList) {
 630           sCurrentBatch->mObservers[i].mWantsChildList = aWantsChildList;
 631         }
 632         return;
 633       }
 634     }
 635     BatchObserver* bo = sCurrentBatch->mObservers.AppendElement();
 636     bo->mObserver = aObserver;
 637     bo->mWantsChildList = aWantsChildList;
 638   }
 639
 640   static nsINode* GetBatchTarget() { return sCurrentBatch->mBatchTarget; }
 641
 642   // Mutation receivers notify the batch about removed child nodes.
 643   static void NodeRemoved(nsIContent* aChild) {
 644     if (IsBatching() && !sCurrentBatch->mRemovalDone) {
 645       uint32_t len = sCurrentBatch->mRemovedNodes.Length();
 646       if (!len || sCurrentBatch->mRemovedNodes[len - 1] != aChild) {
 647         sCurrentBatch->mRemovedNodes.AppendElement(aChild);
 648       }
 649     }
 650   }
 651
 652   // Called after new child nodes have been added to the batch target.
 653   void NodesAdded() {
 654     if (sCurrentBatch != this) {
 655       return;
 656     }
 657
 658     nsIContent* c = mPrevSibling ? mPrevSibling->GetNextSibling()
 659                                  : mBatchTarget->GetFirstChild();
 660     for (; c != mNextSibling; c = c->GetNextSibling()) {
 661       mAddedNodes.AppendElement(c);
 662     }
 663     Done();
 664   }
 665
 666  private:
 667   struct BatchObserver {
 668     nsDOMMutationObserver* mObserver;
 669     bool mWantsChildList;
 670   };
 671
 672   static nsAutoMutationBatch* sCurrentBatch;
 673   nsAutoMutationBatch* mPreviousBatch;
 674   AutoTArray<BatchObserver, 2> mObservers;
 675   nsTArray<nsCOMPtr<nsIContent>> mRemovedNodes;
 676   nsTArray<nsCOMPtr<nsIContent>> mAddedNodes;
 677   nsINode* mBatchTarget;
 678   bool mRemovalDone;
 679   bool mFromFirstToLast;
 680   bool mAllowNestedBatches;
 681   nsCOMPtr<nsINode> mPrevSibling;
 682   nsCOMPtr<nsINode> mNextSibling;
 683 };
 684
 685 class nsAutoAnimationMutationBatch {
 686   struct Entry;
 687
 688  public:
 689   explicit nsAutoAnimationMutationBatch(mozilla::dom::Document* aDocument) {
 690     Init(aDocument);
 691   }
 692
 693   void Init(mozilla::dom::Document* aDocument) {
 694     if (!aDocument || !aDocument->MayHaveDOMMutationObservers() ||
 695         sCurrentBatch) {
 696       return;
 697     }
 698
 699     sCurrentBatch = this;
 700     nsDOMMutationObserver::EnterMutationHandling();
 701   }
 702
 703   ~nsAutoAnimationMutationBatch() { Done(); }
 704
 705   void Done();
 706
 707   static bool IsBatching() { return !!sCurrentBatch; }
 708
 709   static nsAutoAnimationMutationBatch* GetCurrentBatch() {
 710     return sCurrentBatch;
 711   }
 712
 713   static void AddObserver(nsDOMMutationObserver* aObserver) {
 714     if (sCurrentBatch->mObservers.Contains(aObserver)) {
 715       return;
 716     }
 717     sCurrentBatch->mObservers.AppendElement(aObserver);
 718   }
 719
 720   static void AnimationAdded(mozilla::dom::Animation* aAnimation,
 721                              nsINode* aTarget) {
 722     if (!IsBatching()) {
 723       return;
 724     }
 725
 726     Entry* entry = sCurrentBatch->FindEntry(aAnimation, aTarget);
 727     if (entry) {
 728       switch (entry->mState) {
 729         case eState_RemainedAbsent:
 730           entry->mState = eState_Added;
 731           break;
 732         case eState_Removed:
 733           entry->mState = eState_RemainedPresent;
 734           break;
 735         case eState_Added:
 736           // FIXME bug 1189015
 737           NS_ERROR("shouldn't have observed an animation being added twice");
 738           break;
 739         case eState_RemainedPresent:
 740           MOZ_ASSERT_UNREACHABLE(
 741               "shouldn't have observed an animation "
 742               "remaining present");
 743           break;
 744       }
 745     } else {
 746       entry = sCurrentBatch->AddEntry(aAnimation, aTarget);
 747       entry->mState = eState_Added;
 748       entry->mChanged = false;
 749     }
 750   }
 751
 752   static void AnimationChanged(mozilla::dom::Animation* aAnimation,
 753                                nsINode* aTarget) {
 754     Entry* entry = sCurrentBatch->FindEntry(aAnimation, aTarget);
 755     if (entry) {
 756       NS_ASSERTION(entry->mState == eState_RemainedPresent ||
 757                        entry->mState == eState_Added,
 758                    "shouldn't have observed an animation being changed after "
 759                    "being removed");
 760       entry->mChanged = true;
 761     } else {
 762       entry = sCurrentBatch->AddEntry(aAnimation, aTarget);
 763       entry->mState = eState_RemainedPresent;
 764       entry->mChanged = true;
 765     }
 766   }
 767
 768   static void AnimationRemoved(mozilla::dom::Animation* aAnimation,
 769                                nsINode* aTarget) {
 770     Entry* entry = sCurrentBatch->FindEntry(aAnimation, aTarget);
 771     if (entry) {
 772       switch (entry->mState) {
 773         case eState_RemainedPresent:
 774           entry->mState = eState_Removed;
 775           break;
 776         case eState_Added:
 777           entry->mState = eState_RemainedAbsent;
 778           break;
 779         case eState_RemainedAbsent:
 780           MOZ_ASSERT_UNREACHABLE(
 781               "shouldn't have observed an animation "
 782               "remaining absent");
 783           break;
 784         case eState_Removed:
 785           // FIXME bug 1189015
 786           NS_ERROR("shouldn't have observed an animation being removed twice");
 787           break;
 788       }
 789     } else {
 790       entry = sCurrentBatch->AddEntry(aAnimation, aTarget);
 791       entry->mState = eState_Removed;
 792       entry->mChanged = false;
 793     }
 794   }
 795
 796  private:
 797   Entry* FindEntry(mozilla::dom::Animation* aAnimation, nsINode* aTarget) {
 798     EntryArray* entries = mEntryTable.Get(aTarget);
 799     if (!entries) {
 800       return nullptr;
 801     }
 802
 803     for (Entry& e : *entries) {
 804       if (e.mAnimation == aAnimation) {
 805         return &e;
 806       }
 807     }
 808     return nullptr;
 809   }
 810
 811   Entry* AddEntry(mozilla::dom::Animation* aAnimation, nsINode* aTarget) {
 812     EntryArray* entries = sCurrentBatch->mEntryTable.GetOrInsertNew(aTarget);
 813     if (entries->IsEmpty()) {
 814       sCurrentBatch->mBatchTargets.AppendElement(aTarget);
 815     }
 816     Entry* entry = entries->AppendElement();
 817     entry->mAnimation = aAnimation;
 818     return entry;
 819   }
 820
 821   enum State {
 822     eState_RemainedPresent,
 823     eState_RemainedAbsent,
 824     eState_Added,
 825     eState_Removed
 826   };
 827
 828   struct Entry {
 829     RefPtr<mozilla::dom::Animation> mAnimation;
 830     State mState;
 831     bool mChanged;
 832   };
 833
 834   static nsAutoAnimationMutationBatch* sCurrentBatch;
 835   AutoTArray<nsDOMMutationObserver*, 2> mObservers;
 836   using EntryArray = nsTArray<Entry>;
 837   nsClassHashtable<nsPtrHashKey<nsINode>, EntryArray> mEntryTable;
 838   // List of nodes referred to by mEntryTable so we can sort them
 839   // For a specific pseudo element, we use its parent element as the
 840   // batch target, so they will be put in the same EntryArray.
 841   nsTArray<nsINode*> mBatchTargets;
 842 };
 843
 844 inline nsDOMMutationObserver* nsMutationReceiverBase::Observer() {
 845   return mParent ? mParent->Observer()
 846                  : static_cast<nsDOMMutationObserver*>(mObserver);
 847 }
 848
 849 class MOZ_RAII nsDOMMutationEnterLeave {
 850  public:
 851   explicit nsDOMMutationEnterLeave(mozilla::dom::Document* aDoc)
 852       : mNeeded(aDoc->MayHaveDOMMutationObservers()) {
 853     if (mNeeded) {
 854       nsDOMMutationObserver::EnterMutationHandling();
 855     }
 856   }
 857   ~nsDOMMutationEnterLeave() {
 858     if (mNeeded) {
 859       nsDOMMutationObserver::LeaveMutationHandling();
 860     }
 861   }
 862
 863  private:
 864   const bool mNeeded;
 865 };
 866
 867 #endif