[ tor-browser ].git.dasho

nsDOMMutationObserver.cpp (36167B)
      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 #include "nsDOMMutationObserver.h"
      8 
      9 #include "mozilla/AnimationTarget.h"
     10 #include "mozilla/BasePrincipal.h"
     11 #include "mozilla/CycleCollectedJSContext.h"
     12 #include "mozilla/Maybe.h"
     13 #include "mozilla/OwningNonNull.h"
     14 #include "mozilla/dom/Animation.h"
     15 #include "mozilla/dom/CharacterDataBuffer.h"
     16 #include "mozilla/dom/DocGroup.h"
     17 #include "mozilla/dom/KeyframeEffect.h"
     18 #include "nsCSSPseudoElements.h"
     19 #include "nsContentUtils.h"
     20 #include "nsError.h"
     21 #include "nsIScriptGlobalObject.h"
     22 #include "nsNameSpaceManager.h"
     23 #include "nsServiceManagerUtils.h"
     24 #include "nsThreadUtils.h"
     25 
     26 using namespace mozilla;
     27 using namespace mozilla::dom;
     28 
     29 AutoTArray<RefPtr<nsDOMMutationObserver>, 4>*
     30    nsDOMMutationObserver::sScheduledMutationObservers = nullptr;
     31 
     32 uint32_t nsDOMMutationObserver::sMutationLevel = 0;
     33 uint64_t nsDOMMutationObserver::sCount = 0;
     34 
     35 AutoTArray<AutoTArray<RefPtr<nsDOMMutationObserver>, 4>, 4>*
     36    nsDOMMutationObserver::sCurrentlyHandlingObservers = nullptr;
     37 
     38 nsINodeList* nsDOMMutationRecord::AddedNodes() {
     39  if (!mAddedNodes) {
     40    mAddedNodes = new nsSimpleContentList(mTarget);
     41  }
     42  return mAddedNodes;
     43 }
     44 
     45 nsINodeList* nsDOMMutationRecord::RemovedNodes() {
     46  if (!mRemovedNodes) {
     47    mRemovedNodes = new nsSimpleContentList(mTarget);
     48  }
     49  return mRemovedNodes;
     50 }
     51 
     52 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMMutationRecord)
     53  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
     54  NS_INTERFACE_MAP_ENTRY(nsISupports)
     55 NS_INTERFACE_MAP_END
     56 
     57 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMMutationRecord)
     58 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMMutationRecord)
     59 
     60 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsDOMMutationRecord, mTarget,
     61                                      mPreviousSibling, mNextSibling,
     62                                      mAddedNodes, mRemovedNodes,
     63                                      mAddedAnimations, mRemovedAnimations,
     64                                      mChangedAnimations, mNext, mOwner)
     65 
     66 // Observer
     67 
     68 bool nsMutationReceiverBase::IsObservable(nsIContent* aContent) {
     69  return !aContent->ChromeOnlyAccess() || ChromeOnlyNodes();
     70 }
     71 
     72 bool nsMutationReceiverBase::ObservesAttr(nsINode* aRegisterTarget,
     73                                          Element* aElement,
     74                                          int32_t aNameSpaceID, nsAtom* aAttr) {
     75  if (mParent) {
     76    return mParent->ObservesAttr(aRegisterTarget, aElement, aNameSpaceID,
     77                                 aAttr);
     78  }
     79  if (!Attributes() || (!Subtree() && aElement != Target()) ||
     80      (Subtree() &&
     81       aRegisterTarget->SubtreeRoot() != aElement->SubtreeRoot()) ||
     82      !IsObservable(aElement)) {
     83    return false;
     84  }
     85  if (AllAttributes()) {
     86    return true;
     87  }
     88 
     89  if (aNameSpaceID != kNameSpaceID_None) {
     90    return false;
     91  }
     92 
     93  nsTArray<RefPtr<nsAtom>>& filters = AttributeFilter();
     94  for (size_t i = 0; i < filters.Length(); ++i) {
     95    if (filters[i] == aAttr) {
     96      return true;
     97    }
     98  }
     99  return false;
    100 }
    101 
    102 NS_IMPL_ADDREF(nsMutationReceiver)
    103 NS_IMPL_RELEASE(nsMutationReceiver)
    104 
    105 NS_INTERFACE_MAP_BEGIN(nsMutationReceiver)
    106  NS_INTERFACE_MAP_ENTRY(nsISupports)
    107  NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
    108 NS_INTERFACE_MAP_END
    109 
    110 nsMutationReceiver::nsMutationReceiver(nsINode* aTarget,
    111                                       nsDOMMutationObserver* aObserver)
    112    : nsMutationReceiverBase(aTarget, aObserver) {
    113  mTarget->BindObject(aObserver);
    114 }
    115 
    116 void nsMutationReceiver::Disconnect(bool aRemoveFromObserver) {
    117  if (mRegisterTarget) {
    118    mRegisterTarget->RemoveMutationObserver(this);
    119    mRegisterTarget = nullptr;
    120  }
    121 
    122  mParent = nullptr;
    123  nsINode* target = mTarget;
    124  mTarget = nullptr;
    125  nsDOMMutationObserver* observer = mObserver;
    126  mObserver = nullptr;
    127  RemoveClones();
    128 
    129  if (target && observer) {
    130    if (aRemoveFromObserver) {
    131      static_cast<nsDOMMutationObserver*>(observer)->RemoveReceiver(this);
    132    }
    133    // UnbindObject may delete 'this'!
    134    target->UnbindObject(observer);
    135  }
    136 }
    137 
    138 void nsMutationReceiver::AttributeWillChange(Element* aElement,
    139                                             int32_t aNameSpaceID,
    140                                             nsAtom* aAttribute, AttrModType) {
    141  if (nsAutoMutationBatch::IsBatching() ||
    142      !ObservesAttr(RegisterTarget(), aElement, aNameSpaceID, aAttribute)) {
    143    return;
    144  }
    145 
    146  nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::attributes);
    147 
    148  NS_ASSERTION(!m->mTarget || m->mTarget == aElement, "Wrong target!");
    149  NS_ASSERTION(!m->mAttrName || m->mAttrName == aAttribute, "Wrong attribute!");
    150  if (!m->mTarget) {
    151    m->mTarget = aElement;
    152    m->mAttrName = aAttribute;
    153    if (aNameSpaceID == kNameSpaceID_None) {
    154      m->mAttrNamespace.SetIsVoid(true);
    155    } else {
    156      nsNameSpaceManager::GetInstance()->GetNameSpaceURI(aNameSpaceID,
    157                                                         m->mAttrNamespace);
    158    }
    159  }
    160 
    161  if (AttributeOldValue() && m->mPrevValue.IsVoid()) {
    162    if (!aElement->GetAttr(aNameSpaceID, aAttribute, m->mPrevValue)) {
    163      m->mPrevValue.SetIsVoid(true);
    164    }
    165  }
    166 }
    167 
    168 void nsMutationReceiver::CharacterDataWillChange(
    169    nsIContent* aContent, const CharacterDataChangeInfo&) {
    170  if (nsAutoMutationBatch::IsBatching() || !CharacterData() ||
    171      (!Subtree() && aContent != Target()) ||
    172      (Subtree() &&
    173       RegisterTarget()->SubtreeRoot() != aContent->SubtreeRoot()) ||
    174      !IsObservable(aContent)) {
    175    return;
    176  }
    177 
    178  nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::characterData);
    179 
    180  NS_ASSERTION(!m->mTarget || m->mTarget == aContent, "Wrong target!");
    181 
    182  if (!m->mTarget) {
    183    m->mTarget = aContent;
    184  }
    185  if (CharacterDataOldValue() && m->mPrevValue.IsVoid()) {
    186    aContent->GetCharacterDataBuffer()->AppendTo(m->mPrevValue);
    187  }
    188 }
    189 
    190 void nsMutationReceiver::ContentAppended(nsIContent* aFirstNewContent,
    191                                         const ContentAppendInfo&) {
    192  nsINode* parent = aFirstNewContent->GetParentNode();
    193  bool wantsChildList =
    194      ChildList() && ((Subtree() && RegisterTarget()->SubtreeRoot() ==
    195                                        parent->SubtreeRoot()) ||
    196                      parent == Target());
    197  if (!wantsChildList || !IsObservable(aFirstNewContent)) {
    198    return;
    199  }
    200 
    201  if (nsAutoMutationBatch::IsBatching()) {
    202    if (parent == nsAutoMutationBatch::GetBatchTarget()) {
    203      nsAutoMutationBatch::UpdateObserver(Observer(), wantsChildList);
    204    }
    205    return;
    206  }
    207 
    208  nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::childList);
    209  NS_ASSERTION(!m->mTarget || m->mTarget == parent, "Wrong target!");
    210  if (m->mTarget) {
    211    // Already handled case.
    212    return;
    213  }
    214  m->mTarget = parent;
    215  m->mAddedNodes = new nsSimpleContentList(parent);
    216 
    217  nsINode* n = aFirstNewContent;
    218  while (n) {
    219    m->mAddedNodes->AppendElement(static_cast<nsIContent*>(n));
    220    n = n->GetNextSibling();
    221  }
    222  m->mPreviousSibling = aFirstNewContent->GetPreviousSibling();
    223 }
    224 
    225 void nsMutationReceiver::ContentInserted(nsIContent* aChild,
    226                                         const ContentInsertInfo&) {
    227  nsINode* parent = aChild->GetParentNode();
    228  bool wantsChildList =
    229      ChildList() && ((Subtree() && RegisterTarget()->SubtreeRoot() ==
    230                                        parent->SubtreeRoot()) ||
    231                      parent == Target());
    232  if (!wantsChildList || !IsObservable(aChild)) {
    233    return;
    234  }
    235 
    236  if (nsAutoMutationBatch::IsBatching()) {
    237    if (parent == nsAutoMutationBatch::GetBatchTarget()) {
    238      nsAutoMutationBatch::UpdateObserver(Observer(), wantsChildList);
    239    }
    240    return;
    241  }
    242 
    243  nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::childList);
    244  if (m->mTarget) {
    245    // Already handled case.
    246    return;
    247  }
    248  m->mTarget = parent;
    249  m->mAddedNodes = new nsSimpleContentList(parent);
    250  m->mAddedNodes->AppendElement(aChild);
    251  m->mPreviousSibling = aChild->GetPreviousSibling();
    252  m->mNextSibling = aChild->GetNextSibling();
    253 }
    254 
    255 void nsMutationReceiver::ContentWillBeRemoved(nsIContent* aChild,
    256                                              const ContentRemoveInfo&) {
    257  if (!IsObservable(aChild)) {
    258    return;
    259  }
    260 
    261  nsINode* parent = aChild->GetParentNode();
    262  if (Subtree() && parent->SubtreeRoot() != RegisterTarget()->SubtreeRoot()) {
    263    return;
    264  }
    265  if (nsAutoMutationBatch::IsBatching()) {
    266    if (nsAutoMutationBatch::IsRemovalDone()) {
    267      // This can happen for example if HTML parser parses to
    268      // context node, but needs to move elements around.
    269      return;
    270    }
    271    if (nsAutoMutationBatch::GetBatchTarget() != parent) {
    272      return;
    273    }
    274 
    275    bool wantsChildList = ChildList() && (Subtree() || parent == Target());
    276    if (wantsChildList || Subtree()) {
    277      nsAutoMutationBatch::NodeRemoved(aChild);
    278      nsAutoMutationBatch::UpdateObserver(Observer(), wantsChildList);
    279    }
    280 
    281    return;
    282  }
    283 
    284  if (Subtree()) {
    285    // Try to avoid creating transient observer if the node
    286    // already has an observer observing the same set of nodes.
    287    nsMutationReceiver* orig = GetParent() ? GetParent() : this;
    288    if (Observer()->GetReceiverFor(aChild, false, false) != orig) {
    289      bool transientExists = false;
    290      bool isNewEntry = false;
    291      auto* const transientReceivers =
    292          Observer()
    293              ->mTransientReceivers
    294              .LookupOrInsertWith(
    295                  aChild,
    296                  [&isNewEntry] {
    297                    isNewEntry = true;
    298                    return MakeUnique<nsCOMArray<nsMutationReceiver>>();
    299                  })
    300              .get();
    301      if (!isNewEntry) {
    302        for (int32_t i = 0; i < transientReceivers->Count(); ++i) {
    303          nsMutationReceiver* r = transientReceivers->ObjectAt(i);
    304          if (r->GetParent() == orig) {
    305            transientExists = true;
    306          }
    307        }
    308      }
    309      if (!transientExists) {
    310        // Make sure the elements which are removed from the
    311        // subtree are kept in the same observation set.
    312        nsMutationReceiver* tr;
    313        if (orig->Animations()) {
    314          tr = nsAnimationReceiver::Create(aChild, orig);
    315        } else {
    316          tr = nsMutationReceiver::Create(aChild, orig);
    317        }
    318        transientReceivers->AppendObject(tr);
    319      }
    320    }
    321  }
    322 
    323  if (ChildList() && (Subtree() || parent == Target())) {
    324    nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::childList);
    325    if (m->mTarget) {
    326      // Already handled case.
    327      return;
    328    }
    329    MOZ_ASSERT(parent);
    330 
    331    m->mTarget = parent;
    332    m->mRemovedNodes = new nsSimpleContentList(parent);
    333    m->mRemovedNodes->AppendElement(aChild);
    334    m->mPreviousSibling = aChild->GetPreviousSibling();
    335    m->mNextSibling = aChild->GetNextSibling();
    336  }
    337  // We need to schedule always, so that after microtask mTransientReceivers
    338  // can be cleared correctly.
    339  Observer()->ScheduleForRun();
    340 }
    341 
    342 void nsMutationReceiver::NodeWillBeDestroyed(nsINode* aNode) {
    343  NS_ASSERTION(!mParent, "Shouldn't have mParent here!");
    344  Disconnect(true);
    345 }
    346 
    347 void nsAnimationReceiver::RecordAnimationMutation(
    348    Animation* aAnimation, AnimationMutation aMutationType) {
    349  AnimationEffect* effect = aAnimation->GetEffect();
    350  if (!effect) {
    351    return;
    352  }
    353 
    354  KeyframeEffect* keyframeEffect = effect->AsKeyframeEffect();
    355  if (!keyframeEffect) {
    356    return;
    357  }
    358 
    359  NonOwningAnimationTarget animationTarget =
    360      keyframeEffect->GetAnimationTarget();
    361  if (!animationTarget) {
    362    return;
    363  }
    364 
    365  Element* elem = animationTarget.mElement;
    366  if (!Animations() || !(Subtree() || elem == Target()) ||
    367      elem->ChromeOnlyAccess()) {
    368    return;
    369  }
    370 
    371  // Record animations targeting to a pseudo element only when subtree is true.
    372  if (!animationTarget.mPseudoRequest.IsNotPseudo() && !Subtree()) {
    373    return;
    374  }
    375 
    376  if (nsAutoAnimationMutationBatch::IsBatching()) {
    377    switch (aMutationType) {
    378      case eAnimationMutation_Added:
    379        nsAutoAnimationMutationBatch::AnimationAdded(aAnimation, elem);
    380        break;
    381      case eAnimationMutation_Changed:
    382        nsAutoAnimationMutationBatch::AnimationChanged(aAnimation, elem);
    383        break;
    384      case eAnimationMutation_Removed:
    385        nsAutoAnimationMutationBatch::AnimationRemoved(aAnimation, elem);
    386        break;
    387    }
    388 
    389    nsAutoAnimationMutationBatch::AddObserver(Observer());
    390    return;
    391  }
    392 
    393  nsDOMMutationRecord* m = Observer()->CurrentRecord(nsGkAtoms::animations);
    394 
    395  NS_ASSERTION(!m->mTarget, "Wrong target!");
    396 
    397  m->mTarget = elem;
    398 
    399  switch (aMutationType) {
    400    case eAnimationMutation_Added:
    401      m->mAddedAnimations.AppendElement(aAnimation);
    402      break;
    403    case eAnimationMutation_Changed:
    404      m->mChangedAnimations.AppendElement(aAnimation);
    405      break;
    406    case eAnimationMutation_Removed:
    407      m->mRemovedAnimations.AppendElement(aAnimation);
    408      break;
    409  }
    410 }
    411 
    412 void nsAnimationReceiver::AnimationAdded(Animation* aAnimation) {
    413  RecordAnimationMutation(aAnimation, eAnimationMutation_Added);
    414 }
    415 
    416 void nsAnimationReceiver::AnimationChanged(Animation* aAnimation) {
    417  RecordAnimationMutation(aAnimation, eAnimationMutation_Changed);
    418 }
    419 
    420 void nsAnimationReceiver::AnimationRemoved(Animation* aAnimation) {
    421  RecordAnimationMutation(aAnimation, eAnimationMutation_Removed);
    422 }
    423 
    424 NS_IMPL_ISUPPORTS_INHERITED(nsAnimationReceiver, nsMutationReceiver,
    425                            nsIAnimationObserver)
    426 
    427 // Observer
    428 
    429 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMMutationObserver)
    430  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
    431  NS_INTERFACE_MAP_ENTRY(nsISupports)
    432  NS_INTERFACE_MAP_ENTRY(nsDOMMutationObserver)
    433 NS_INTERFACE_MAP_END
    434 
    435 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMMutationObserver)
    436 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMMutationObserver)
    437 
    438 NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMMutationObserver)
    439 
    440 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsDOMMutationObserver)
    441  NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
    442 NS_IMPL_CYCLE_COLLECTION_TRACE_END
    443 
    444 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDOMMutationObserver)
    445  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
    446  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
    447  for (int32_t i = 0; i < tmp->mReceivers.Count(); ++i) {
    448    tmp->mReceivers[i]->Disconnect(false);
    449  }
    450  tmp->mReceivers.Clear();
    451  tmp->ClearPendingRecords();
    452  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback)
    453 // No need to handle mTransientReceivers
    454 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
    455 
    456 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDOMMutationObserver)
    457  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
    458  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReceivers)
    459  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFirstPendingMutation)
    460  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback)
    461  // No need to handle mTransientReceivers
    462 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
    463 
    464 nsMutationReceiver* nsDOMMutationObserver::GetReceiverFor(
    465    nsINode* aNode, bool aMayCreate, bool aWantsAnimations) {
    466  MOZ_ASSERT(aMayCreate || !aWantsAnimations,
    467             "the value of aWantsAnimations doesn't matter when aMayCreate is "
    468             "false, so just pass in false for it");
    469 
    470  if (!aMayCreate && !aNode->MayHaveDOMMutationObserver()) {
    471    return nullptr;
    472  }
    473 
    474  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    475    if (mReceivers[i]->Target() == aNode) {
    476      return mReceivers[i];
    477    }
    478  }
    479  if (!aMayCreate) {
    480    return nullptr;
    481  }
    482 
    483  nsMutationReceiver* r;
    484  if (aWantsAnimations) {
    485    r = nsAnimationReceiver::Create(aNode, this);
    486  } else {
    487    r = nsMutationReceiver::Create(aNode, this);
    488  }
    489  mReceivers.AppendObject(r);
    490  return r;
    491 }
    492 
    493 void nsDOMMutationObserver::RemoveReceiver(nsMutationReceiver* aReceiver) {
    494  mReceivers.RemoveObject(aReceiver);
    495 }
    496 
    497 void nsDOMMutationObserver::GetAllSubtreeObserversFor(
    498    nsINode* aNode, nsTArray<nsMutationReceiver*>& aReceivers) {
    499  nsINode* n = aNode;
    500  while (n) {
    501    if (n->MayHaveDOMMutationObserver()) {
    502      nsMutationReceiver* r = GetReceiverFor(n, false, false);
    503      if (r && r->Subtree() && !aReceivers.Contains(r)) {
    504        aReceivers.AppendElement(r);
    505        // If we've found all the receivers the observer has,
    506        // no need to search for more.
    507        if (mReceivers.Count() == int32_t(aReceivers.Length())) {
    508          return;
    509        }
    510      }
    511      nsCOMArray<nsMutationReceiver>* transientReceivers = nullptr;
    512      if (mTransientReceivers.Get(n, &transientReceivers) &&
    513          transientReceivers) {
    514        for (int32_t i = 0; i < transientReceivers->Count(); ++i) {
    515          nsMutationReceiver* r = transientReceivers->ObjectAt(i);
    516          nsMutationReceiver* parent = r->GetParent();
    517          if (r->Subtree() && parent && !aReceivers.Contains(parent)) {
    518            aReceivers.AppendElement(parent);
    519          }
    520        }
    521        if (mReceivers.Count() == int32_t(aReceivers.Length())) {
    522          return;
    523        }
    524      }
    525    }
    526    n = n->GetParentNode();
    527  }
    528 }
    529 
    530 void nsDOMMutationObserver::ScheduleForRun() {
    531  nsDOMMutationObserver::AddCurrentlyHandlingObserver(this, sMutationLevel);
    532 
    533  if (mWaitingForRun) {
    534    return;
    535  }
    536  mWaitingForRun = true;
    537  RescheduleForRun();
    538 }
    539 
    540 class MutationObserverMicroTask final : public MicroTaskRunnable {
    541 public:
    542  MOZ_CAN_RUN_SCRIPT
    543  virtual void Run(AutoSlowOperation& aAso) override {
    544    nsDOMMutationObserver::HandleMutations(aAso);
    545  }
    546 
    547  virtual bool Suppressed() override {
    548    return nsDOMMutationObserver::AllScheduledMutationObserversAreSuppressed();
    549  }
    550 };
    551 
    552 /* static */
    553 void nsDOMMutationObserver::QueueMutationObserverMicroTask() {
    554  CycleCollectedJSContext* ccjs = CycleCollectedJSContext::Get();
    555  if (!ccjs) {
    556    return;
    557  }
    558 
    559  RefPtr<MutationObserverMicroTask> momt = new MutationObserverMicroTask();
    560  ccjs->DispatchToMicroTask(momt.forget());
    561 }
    562 
    563 void nsDOMMutationObserver::HandleMutations(mozilla::AutoSlowOperation& aAso) {
    564  if (sScheduledMutationObservers || DocGroup::sPendingDocGroups) {
    565    HandleMutationsInternal(aAso);
    566  }
    567 }
    568 
    569 void nsDOMMutationObserver::RescheduleForRun() {
    570  if (!sScheduledMutationObservers) {
    571    CycleCollectedJSContext* ccjs = CycleCollectedJSContext::Get();
    572    if (!ccjs) {
    573      return;
    574    }
    575 
    576    RefPtr<MutationObserverMicroTask> momt = new MutationObserverMicroTask();
    577    ccjs->DispatchToMicroTask(momt.forget());
    578    sScheduledMutationObservers =
    579        new AutoTArray<RefPtr<nsDOMMutationObserver>, 4>;
    580  }
    581 
    582  bool didInsert = false;
    583  for (uint32_t i = 0; i < sScheduledMutationObservers->Length(); ++i) {
    584    if (static_cast<nsDOMMutationObserver*>((*sScheduledMutationObservers)[i])
    585            ->mId > mId) {
    586      sScheduledMutationObservers->InsertElementAt(i, this);
    587      didInsert = true;
    588      break;
    589    }
    590  }
    591  if (!didInsert) {
    592    sScheduledMutationObservers->AppendElement(this);
    593  }
    594 }
    595 
    596 void nsDOMMutationObserver::Observe(nsINode& aTarget,
    597                                    const MutationObserverInit& aOptions,
    598                                    nsIPrincipal& aSubjectPrincipal,
    599                                    ErrorResult& aRv) {
    600  bool childList = aOptions.mChildList;
    601  bool attributes =
    602      aOptions.mAttributes.WasPassed() && aOptions.mAttributes.Value();
    603  bool characterData =
    604      aOptions.mCharacterData.WasPassed() && aOptions.mCharacterData.Value();
    605  bool subtree = aOptions.mSubtree;
    606  bool attributeOldValue = aOptions.mAttributeOldValue.WasPassed() &&
    607                           aOptions.mAttributeOldValue.Value();
    608  bool characterDataOldValue = aOptions.mCharacterDataOldValue.WasPassed() &&
    609                               aOptions.mCharacterDataOldValue.Value();
    610  bool animations = aOptions.mAnimations;
    611  bool chromeOnlyNodes = aOptions.mChromeOnlyNodes;
    612 
    613  if (!aOptions.mAttributes.WasPassed() &&
    614      (aOptions.mAttributeOldValue.WasPassed() ||
    615       aOptions.mAttributeFilter.WasPassed())) {
    616    attributes = true;
    617  }
    618 
    619  if (!aOptions.mCharacterData.WasPassed() &&
    620      aOptions.mCharacterDataOldValue.WasPassed()) {
    621    characterData = true;
    622  }
    623 
    624  if (!(childList || attributes || characterData || animations)) {
    625    aRv.ThrowTypeError(
    626        "One of 'childList', 'attributes', 'characterData' must not be false.");
    627    return;
    628  }
    629 
    630  if (aOptions.mAttributeOldValue.WasPassed() &&
    631      aOptions.mAttributeOldValue.Value() && !attributes) {
    632    aRv.ThrowTypeError(
    633        "If 'attributeOldValue' is true, 'attributes' must not be false.");
    634    return;
    635  }
    636 
    637  if (aOptions.mAttributeFilter.WasPassed() && !attributes) {
    638    aRv.ThrowTypeError(
    639        "If 'attributesFilter' is present, 'attributes' must not be false.");
    640    return;
    641  }
    642 
    643  if (aOptions.mCharacterDataOldValue.WasPassed() &&
    644      aOptions.mCharacterDataOldValue.Value() && !characterData) {
    645    aRv.ThrowTypeError(
    646        "If 'characterDataOldValue' is true, 'characterData' must not be "
    647        "false.");
    648    return;
    649  }
    650 
    651  nsTArray<RefPtr<nsAtom>> filters;
    652  bool allAttrs = true;
    653  if (aOptions.mAttributeFilter.WasPassed()) {
    654    allAttrs = false;
    655    const Sequence<nsString>& filtersAsString =
    656        aOptions.mAttributeFilter.Value();
    657    uint32_t len = filtersAsString.Length();
    658    filters.SetCapacity(len);
    659 
    660    for (uint32_t i = 0; i < len; ++i) {
    661      filters.AppendElement(NS_Atomize(filtersAsString[i]));
    662    }
    663  }
    664 
    665  nsMutationReceiver* r = GetReceiverFor(&aTarget, true, animations);
    666  r->SetChildList(childList);
    667  r->SetAttributes(attributes);
    668  r->SetCharacterData(characterData);
    669  r->SetSubtree(subtree);
    670  r->SetAttributeOldValue(attributeOldValue);
    671  r->SetCharacterDataOldValue(characterDataOldValue);
    672  r->SetAttributeFilter(std::move(filters));
    673  r->SetAllAttributes(allAttrs);
    674  r->SetAnimations(animations);
    675  r->SetChromeOnlyNodes(chromeOnlyNodes);
    676  r->RemoveClones();
    677 
    678  if (!aSubjectPrincipal.IsSystemPrincipal() &&
    679      !aSubjectPrincipal.GetIsAddonOrExpandedAddonPrincipal()) {
    680    if (nsPIDOMWindowInner* window = aTarget.OwnerDoc()->GetInnerWindow()) {
    681      window->SetMutationObserverHasObservedNodeForTelemetry();
    682    }
    683  }
    684 
    685 #ifdef DEBUG
    686  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    687    NS_WARNING_ASSERTION(mReceivers[i]->Target(),
    688                         "All the receivers should have a target!");
    689  }
    690 #endif
    691 }
    692 
    693 void nsDOMMutationObserver::Disconnect() {
    694  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    695    mReceivers[i]->Disconnect(false);
    696  }
    697  mReceivers.Clear();
    698  mCurrentMutations.Clear();
    699  ClearPendingRecords();
    700 }
    701 
    702 void nsDOMMutationObserver::TakeRecords(
    703    nsTArray<RefPtr<nsDOMMutationRecord>>& aRetVal) {
    704  aRetVal.Clear();
    705  aRetVal.SetCapacity(mPendingMutationCount);
    706  RefPtr<nsDOMMutationRecord> current;
    707  current.swap(mFirstPendingMutation);
    708  for (uint32_t i = 0; i < mPendingMutationCount; ++i) {
    709    RefPtr<nsDOMMutationRecord> next;
    710    current->mNext.swap(next);
    711    if (!mMergeAttributeRecords ||
    712        !MergeableAttributeRecord(aRetVal.SafeLastElement(nullptr), current)) {
    713      *aRetVal.AppendElement() = std::move(current);
    714    }
    715    current.swap(next);
    716  }
    717  ClearPendingRecords();
    718 }
    719 
    720 void nsDOMMutationObserver::GetObservingInfo(
    721    nsTArray<Nullable<MutationObservingInfo>>& aResult,
    722    mozilla::ErrorResult& aRv) {
    723  aResult.SetCapacity(mReceivers.Count());
    724  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    725    MutationObservingInfo& info = aResult.AppendElement()->SetValue();
    726    nsMutationReceiver* mr = mReceivers[i];
    727    info.mChildList = mr->ChildList();
    728    info.mAttributes.Construct(mr->Attributes());
    729    info.mCharacterData.Construct(mr->CharacterData());
    730    info.mSubtree = mr->Subtree();
    731    info.mAttributeOldValue.Construct(mr->AttributeOldValue());
    732    info.mCharacterDataOldValue.Construct(mr->CharacterDataOldValue());
    733    info.mAnimations = mr->Animations();
    734    nsTArray<RefPtr<nsAtom>>& filters = mr->AttributeFilter();
    735    if (filters.Length()) {
    736      info.mAttributeFilter.Construct();
    737      Sequence<nsString>& filtersAsStrings = info.mAttributeFilter.Value();
    738      nsString* strings =
    739          filtersAsStrings.AppendElements(filters.Length(), mozilla::fallible);
    740      if (!strings) {
    741        aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
    742        return;
    743      }
    744      for (size_t j = 0; j < filters.Length(); ++j) {
    745        filters[j]->ToString(strings[j]);
    746      }
    747    }
    748    info.mObservedNode = mr->Target();
    749  }
    750 }
    751 
    752 // static
    753 already_AddRefed<nsDOMMutationObserver> nsDOMMutationObserver::Constructor(
    754    const GlobalObject& aGlobal, dom::MutationCallback& aCb, ErrorResult& aRv) {
    755  nsCOMPtr<nsPIDOMWindowInner> window =
    756      do_QueryInterface(aGlobal.GetAsSupports());
    757  if (!window) {
    758    aRv.Throw(NS_ERROR_FAILURE);
    759    return nullptr;
    760  }
    761  return MakeAndAddRef<nsDOMMutationObserver>(std::move(window), aCb);
    762 }
    763 
    764 bool nsDOMMutationObserver::MergeableAttributeRecord(
    765    nsDOMMutationRecord* aOldRecord, nsDOMMutationRecord* aRecord) {
    766  MOZ_ASSERT(mMergeAttributeRecords);
    767  return aOldRecord && aOldRecord->mType == nsGkAtoms::attributes &&
    768         aOldRecord->mType == aRecord->mType &&
    769         aOldRecord->mTarget == aRecord->mTarget &&
    770         aOldRecord->mAttrName == aRecord->mAttrName &&
    771         aOldRecord->mAttrNamespace.Equals(aRecord->mAttrNamespace);
    772 }
    773 
    774 void nsDOMMutationObserver::HandleMutation() {
    775  NS_ASSERTION(nsContentUtils::IsSafeToRunScript(), "Whaat!");
    776  NS_ASSERTION(mCurrentMutations.IsEmpty(),
    777               "Still generating MutationRecords?");
    778 
    779  mWaitingForRun = false;
    780 
    781  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    782    mReceivers[i]->RemoveClones();
    783  }
    784  mTransientReceivers.Clear();
    785 
    786  nsPIDOMWindowOuter* outer = mOwner->GetOuterWindow();
    787  if (!mPendingMutationCount || !outer ||
    788      outer->GetCurrentInnerWindow() != mOwner) {
    789    ClearPendingRecords();
    790    return;
    791  }
    792 
    793  mozilla::dom::Sequence<mozilla::OwningNonNull<nsDOMMutationRecord>> mutations;
    794  if (mutations.SetCapacity(mPendingMutationCount, mozilla::fallible)) {
    795    // We can't use TakeRecords easily here, because it deals with a
    796    // different type of array, and we want to optimize out any extra copying.
    797    RefPtr<nsDOMMutationRecord> current;
    798    current.swap(mFirstPendingMutation);
    799    for (uint32_t i = 0; i < mPendingMutationCount; ++i) {
    800      RefPtr<nsDOMMutationRecord> next;
    801      current->mNext.swap(next);
    802      if (!mMergeAttributeRecords ||
    803          !MergeableAttributeRecord(
    804              mutations.Length() ? mutations.LastElement().get() : nullptr,
    805              current)) {
    806        *mutations.AppendElement(mozilla::fallible) = current;
    807      }
    808      current.swap(next);
    809    }
    810  }
    811  ClearPendingRecords();
    812 
    813  RefPtr<dom::MutationCallback> callback(mCallback);
    814  callback->Call(this, mutations, *this);
    815 }
    816 
    817 void nsDOMMutationObserver::HandleMutationsInternal(AutoSlowOperation& aAso) {
    818  nsTArray<RefPtr<nsDOMMutationObserver>>* suppressedObservers = nullptr;
    819 
    820  // This loop implements:
    821  //  * Let signalList be a copy of unit of related similar-origin browsing
    822  //    contexts' signal slot list.
    823  //  * Empty unit of related similar-origin browsing contexts' signal slot
    824  //    list.
    825  nsTArray<nsTArray<RefPtr<HTMLSlotElement>>> signalLists;
    826  if (DocGroup::sPendingDocGroups) {
    827    signalLists.SetCapacity(DocGroup::sPendingDocGroups->Length());
    828    for (DocGroup* docGroup : *DocGroup::sPendingDocGroups) {
    829      signalLists.AppendElement(docGroup->MoveSignalSlotList());
    830    }
    831    delete DocGroup::sPendingDocGroups;
    832    DocGroup::sPendingDocGroups = nullptr;
    833  }
    834 
    835  if (sScheduledMutationObservers) {
    836    AutoTArray<RefPtr<nsDOMMutationObserver>, 4>* observers =
    837        sScheduledMutationObservers;
    838    sScheduledMutationObservers = nullptr;
    839    for (uint32_t i = 0; i < observers->Length(); ++i) {
    840      RefPtr<nsDOMMutationObserver> currentObserver =
    841          static_cast<nsDOMMutationObserver*>((*observers)[i]);
    842      if (!currentObserver->Suppressed()) {
    843        currentObserver->HandleMutation();
    844      } else {
    845        if (!suppressedObservers) {
    846          suppressedObservers = new nsTArray<RefPtr<nsDOMMutationObserver>>;
    847        }
    848        if (!suppressedObservers->Contains(currentObserver)) {
    849          suppressedObservers->AppendElement(currentObserver);
    850        }
    851      }
    852    }
    853    delete observers;
    854    aAso.CheckForInterrupt();
    855  }
    856 
    857  if (suppressedObservers) {
    858    for (uint32_t i = 0; i < suppressedObservers->Length(); ++i) {
    859      static_cast<nsDOMMutationObserver*>(suppressedObservers->ElementAt(i))
    860          ->RescheduleForRun();
    861    }
    862    delete suppressedObservers;
    863    suppressedObservers = nullptr;
    864  }
    865 
    866  // Fire slotchange event for each slot in signalLists.
    867  for (const nsTArray<RefPtr<HTMLSlotElement>>& signalList : signalLists) {
    868    for (const RefPtr<HTMLSlotElement>& signal : signalList) {
    869      signal->FireSlotChangeEvent();
    870    }
    871  }
    872 }
    873 
    874 nsDOMMutationRecord* nsDOMMutationObserver::CurrentRecord(nsAtom* aType) {
    875  NS_ASSERTION(sMutationLevel > 0, "Unexpected mutation level!");
    876 
    877  while (mCurrentMutations.Length() < sMutationLevel) {
    878    mCurrentMutations.AppendElement(static_cast<nsDOMMutationRecord*>(nullptr));
    879  }
    880 
    881  uint32_t last = sMutationLevel - 1;
    882  if (!mCurrentMutations[last]) {
    883    RefPtr<nsDOMMutationRecord> r =
    884        new nsDOMMutationRecord(aType, GetParentObject());
    885    mCurrentMutations[last] = r;
    886    AppendMutationRecord(r.forget());
    887    ScheduleForRun();
    888  }
    889 
    890 #ifdef DEBUG
    891  MOZ_ASSERT(sCurrentlyHandlingObservers->Length() == sMutationLevel);
    892  for (size_t i = 0; i < sCurrentlyHandlingObservers->Length(); ++i) {
    893    MOZ_ASSERT(sCurrentlyHandlingObservers->ElementAt(i).Contains(this),
    894               "MutationObserver should be added as an observer of all the "
    895               "nested mutations!");
    896  }
    897 #endif
    898 
    899  NS_ASSERTION(mCurrentMutations[last]->mType == aType,
    900               "Unexpected MutationRecord type!");
    901 
    902  return mCurrentMutations[last];
    903 }
    904 
    905 nsDOMMutationObserver::~nsDOMMutationObserver() {
    906  for (int32_t i = 0; i < mReceivers.Count(); ++i) {
    907    mReceivers[i]->RemoveClones();
    908  }
    909 }
    910 
    911 void nsDOMMutationObserver::EnterMutationHandling() { ++sMutationLevel; }
    912 
    913 // Leave the current mutation level (there can be several levels if in case
    914 // of nested calls to the nsIMutationObserver methods).
    915 // The most recent mutation record is removed from mCurrentMutations, so
    916 // that is doesn't get modified anymore by receivers.
    917 void nsDOMMutationObserver::LeaveMutationHandling() {
    918  if (sCurrentlyHandlingObservers &&
    919      sCurrentlyHandlingObservers->Length() == sMutationLevel) {
    920    nsTArray<RefPtr<nsDOMMutationObserver>> obs =
    921        sCurrentlyHandlingObservers->PopLastElement();
    922    for (uint32_t i = 0; i < obs.Length(); ++i) {
    923      nsDOMMutationObserver* o = static_cast<nsDOMMutationObserver*>(obs[i]);
    924      if (o->mCurrentMutations.Length() == sMutationLevel) {
    925        // It is already in pending mutations.
    926        o->mCurrentMutations.RemoveLastElement();
    927      }
    928    }
    929  }
    930  --sMutationLevel;
    931 }
    932 
    933 void nsDOMMutationObserver::AddCurrentlyHandlingObserver(
    934    nsDOMMutationObserver* aObserver, uint32_t aMutationLevel) {
    935  NS_ASSERTION(aMutationLevel > 0, "Unexpected mutation level!");
    936 
    937  if (aMutationLevel > 1) {
    938    // MutationObserver must be in the currently handling observer list
    939    // in all the nested levels.
    940    AddCurrentlyHandlingObserver(aObserver, aMutationLevel - 1);
    941  }
    942 
    943  if (!sCurrentlyHandlingObservers) {
    944    sCurrentlyHandlingObservers =
    945        new AutoTArray<AutoTArray<RefPtr<nsDOMMutationObserver>, 4>, 4>;
    946  }
    947 
    948  while (sCurrentlyHandlingObservers->Length() < aMutationLevel) {
    949    sCurrentlyHandlingObservers->InsertElementAt(
    950        sCurrentlyHandlingObservers->Length());
    951  }
    952 
    953  uint32_t index = aMutationLevel - 1;
    954  if (!sCurrentlyHandlingObservers->ElementAt(index).Contains(aObserver)) {
    955    sCurrentlyHandlingObservers->ElementAt(index).AppendElement(aObserver);
    956  }
    957 }
    958 
    959 void nsDOMMutationObserver::Shutdown() {
    960  delete sCurrentlyHandlingObservers;
    961  sCurrentlyHandlingObservers = nullptr;
    962  delete sScheduledMutationObservers;
    963  sScheduledMutationObservers = nullptr;
    964 }
    965 
    966 nsAutoMutationBatch* nsAutoMutationBatch::sCurrentBatch = nullptr;
    967 
    968 void nsAutoMutationBatch::Done() {
    969  if (sCurrentBatch != this) {
    970    return;
    971  }
    972 
    973  sCurrentBatch = mPreviousBatch;
    974  if (mObservers.IsEmpty()) {
    975    nsDOMMutationObserver::LeaveMutationHandling();
    976    // Nothing to do.
    977    return;
    978  }
    979 
    980  uint32_t len = mObservers.Length();
    981  for (uint32_t i = 0; i < len; ++i) {
    982    nsDOMMutationObserver* ob = mObservers[i].mObserver;
    983    bool wantsChildList = mObservers[i].mWantsChildList;
    984 
    985    RefPtr<nsSimpleContentList> removedList;
    986    if (wantsChildList) {
    987      removedList = new nsSimpleContentList(mBatchTarget);
    988    }
    989 
    990    nsTArray<nsMutationReceiver*> allObservers;
    991    ob->GetAllSubtreeObserversFor(mBatchTarget, allObservers);
    992 
    993    int32_t j = mFromFirstToLast ? 0 : mRemovedNodes.Length() - 1;
    994    int32_t end = mFromFirstToLast ? mRemovedNodes.Length() : -1;
    995    for (; j != end; mFromFirstToLast ? ++j : --j) {
    996      nsCOMPtr<nsIContent> removed = mRemovedNodes[j];
    997      if (removedList) {
    998        removedList->AppendElement(removed);
    999      }
   1000 
   1001      if (allObservers.Length()) {
   1002        auto* const transientReceivers =
   1003            ob->mTransientReceivers.GetOrInsertNew(removed);
   1004        for (uint32_t k = 0; k < allObservers.Length(); ++k) {
   1005          nsMutationReceiver* r = allObservers[k];
   1006          nsMutationReceiver* orig = r->GetParent() ? r->GetParent() : r;
   1007          if (ob->GetReceiverFor(removed, false, false) != orig) {
   1008            // Make sure the elements which are removed from the
   1009            // subtree are kept in the same observation set.
   1010            nsMutationReceiver* tr;
   1011            if (orig->Animations()) {
   1012              tr = nsAnimationReceiver::Create(removed, orig);
   1013            } else {
   1014              tr = nsMutationReceiver::Create(removed, orig);
   1015            }
   1016            transientReceivers->AppendObject(tr);
   1017          }
   1018        }
   1019      }
   1020    }
   1021    if (wantsChildList && (mRemovedNodes.Length() || mAddedNodes.Length())) {
   1022      RefPtr<nsSimpleContentList> addedList =
   1023          new nsSimpleContentList(mBatchTarget);
   1024      for (uint32_t i = 0; i < mAddedNodes.Length(); ++i) {
   1025        addedList->AppendElement(mAddedNodes[i]);
   1026      }
   1027      RefPtr<nsDOMMutationRecord> m =
   1028          new nsDOMMutationRecord(nsGkAtoms::childList, ob->GetParentObject());
   1029      m->mTarget = mBatchTarget;
   1030      m->mRemovedNodes = removedList;
   1031      m->mAddedNodes = addedList;
   1032      m->mPreviousSibling = mPrevSibling;
   1033      m->mNextSibling = mNextSibling;
   1034      ob->AppendMutationRecord(m.forget());
   1035    }
   1036    // Always schedule the observer so that transient receivers are
   1037    // removed correctly.
   1038    ob->ScheduleForRun();
   1039  }
   1040  nsDOMMutationObserver::LeaveMutationHandling();
   1041 }
   1042 
   1043 nsAutoAnimationMutationBatch* nsAutoAnimationMutationBatch::sCurrentBatch =
   1044    nullptr;
   1045 
   1046 void nsAutoAnimationMutationBatch::Done() {
   1047  if (sCurrentBatch != this) {
   1048    return;
   1049  }
   1050 
   1051  sCurrentBatch = nullptr;
   1052  if (mObservers.IsEmpty()) {
   1053    nsDOMMutationObserver::LeaveMutationHandling();
   1054    // Nothing to do.
   1055    return;
   1056  }
   1057 
   1058  mBatchTargets.Sort(TreeOrderComparator());
   1059 
   1060  for (nsDOMMutationObserver* ob : mObservers) {
   1061    bool didAddRecords = false;
   1062 
   1063    for (nsINode* target : mBatchTargets) {
   1064      EntryArray* entries = mEntryTable.Get(target);
   1065      MOZ_ASSERT(entries,
   1066                 "Targets in entry table and targets list should match");
   1067 
   1068      RefPtr<nsDOMMutationRecord> m =
   1069          new nsDOMMutationRecord(nsGkAtoms::animations, ob->GetParentObject());
   1070      m->mTarget = target;
   1071 
   1072      for (const Entry& e : *entries) {
   1073        if (e.mState == eState_Added) {
   1074          m->mAddedAnimations.AppendElement(e.mAnimation);
   1075        } else if (e.mState == eState_Removed) {
   1076          m->mRemovedAnimations.AppendElement(e.mAnimation);
   1077        } else if (e.mState == eState_RemainedPresent && e.mChanged) {
   1078          m->mChangedAnimations.AppendElement(e.mAnimation);
   1079        }
   1080      }
   1081 
   1082      if (!m->mAddedAnimations.IsEmpty() || !m->mChangedAnimations.IsEmpty() ||
   1083          !m->mRemovedAnimations.IsEmpty()) {
   1084        ob->AppendMutationRecord(m.forget());
   1085        didAddRecords = true;
   1086      }
   1087    }
   1088 
   1089    if (didAddRecords) {
   1090      ob->ScheduleForRun();
   1091    }
   1092  }
   1093  nsDOMMutationObserver::LeaveMutationHandling();
   1094 }
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE