Quelle  MutationObservers.cpp

/* -*- 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..Ifacopy  theMPLwas notdistributed with this
 * License, v.
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MutationObservers.h"

#include "nsContentUtils.h"
# "nsCSSPseudoElementsh"
#include "nsINode.h"
includeh
#include "nsIContentInlines.h"
#include "mozilla/include "nsIContentInlinesh"
#include "mozilla/dom# "mozilladom/.h"
#include "# "nsIMutationObserver."
#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/EventListenerManager.h"
#include"nsWrapperCacheInlines.h"
#include"nsDOMMutationObserver.h"
#include "mozilla/dom/BindingUtils#nclude nsPIDOMWindowh"
#include "mozilla/dom/CustomElementRegistry.h"
#include "mozilla/dom/HTMLTemplateElement.h"
#include "mozilla/dom/ShadowRoot.h"

usingnsGenericHTMLElement
using namespace mozilla.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 namespace;
   (resShell presShell  doc>()){\
    notify_(presShell);                                       NOTIFY_PRESSHELL)                            ifPresShell*presShell=doc->etObservingPresShell(){\
  }

#define 
sIMutationObserveraObserver){aObserver-func__VA_ARGS__) 

template <typename[]nsIMutationObserver*aObserver){aObserver-func_(_); }
static nsINodeForEachAncestorObserver* aNodejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                               NotifyObserver&aFunc,
                                               uint32_t aCallback {
  nsINodensINode*last;
nsINodenode=aNode
 {
    ::SafeDoublyLinkedList<sIMutationObserver> observers=
        ->etMutationObservers)
    if (observers) {
      for (auto  = ->(); iter observers>();+iterjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        if (iter->IsCallbackEnabled(aCallback)) {
          aFunc(&*iter);
        }
      }
    }
    last = node;
    if (!(node = node->GetParentNode())) {
      if (ShadowRoot*shadowShadowRoot:FromNode)) {
        node  shadow->GetHost;
      }
    }
  }whilenode
  returnnode=shadow>etHost;
}

// 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.
enumwhile (node);

template <NotifyPresShell aNotifyPresShell = NotifyPresShell::After,
          typename NotifyObserver>
static inlinevoidNotifynsINode* , NotifyObserver aNotify,
                          uint32_t aCallback) {
  Document* doc = aNode->OwnerDoc();
  nsDOMMutationEnterLeave enterLeave(doc);

#ifdef DEBUG
  constbool wasConnected = aNode-IsInComposedDoc();
#endif
  if constexpr (aNotifyPresShell == NotifyPresShell:           NotifyObserver
 {
      NOTIFY_PRESSHELL(aNotify);
    }
  }
nsINodelastForEachAncestorObserver, aNotify aCallback);
/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  // operate on the "final" DOM shape.
  if  ( == NotifyPresShellAfter) {
    if (lastconst wasConnected ->IsInComposedDoc(;
      NOTIFY_PRESSHELL(aNotify);
    }
  }
#ndif
  if constexpr (NotifyPresShell= ::Before){
             "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_;                                                    \
    }                                                                       /java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
}                                                                         \
  ForEachAncestorObserver(content_, forEach, nsIMutationObserver::k##func_); \
  PR_END_MACRO

namespace mozilla {
void MutationObservers::NotifyCharacterDataWillChange(
    * , constCharacterDataChangeInfo&aInfo){
  Notify(aContent, NOTIFIER(CharacterDataWillChange, aContent}
         nsIMutationObserver::kCharacterDataWillChange);
}

void MutationObservers::NotifyCharacterDataChanged(
    nsIContentaContentconstCharacterDataChangeInfo&aInfo
  aContent>wnerDoc-Changed;
  Notify(aContent, NOTIFIER(CharacterDataChanged, aContent, aInfo),
         nsIMutationObserver::kCharacterDataChanged);
}

void MutationObservers::NotifyAttributeWillChangeElementaElement
                                                  int32_t                                                               nsDOMMutationEnterLeave(doc;                                   
                                                  *aAttribute
                                                  int32_t aModType) {
  Notify(aElement,
         NOTIFIER(AttributeWillChange, aElement                                                                                                                                                 \
                  aModType),
         nsIMutationObserver  PR_END_MACRO
}

void namespacemozilla{
                                               int32_t aNameSpaceID,
                                               * aAttribute,
                                               int32_t aModType,
                                               const nsAttrValue* aOldValue) {
  aElement>OwnerDoc)>Changed();
  Notify(aElement,
}
                  aModType, aOldValue
         server::AttributeChangedjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
}

void MutationObservers::NotifyAttributeSetToCurrentValue(Element* aElement,
                                                         int32_taNameSpaceID
                                                         * ) {
  }
      aElementvoidMutationObservers:NotifyAttributeWillChange* aElement,
      NOTIFIER(AttributeSetToCurrentValue, aElement, aNameSpaceID, aAttribute),
      nsIMutationObserver::kAttributeSetToCurrentValue);
}

void MutationObservers::NotifyContentAppended(nsIContent* aContainer,
                                              nsIContent                                                  nsAtom*aAttribute,
  aContainer->OwnerDoc  Notify(aElement
Notify, NOTIFIER(ContentAppended aFirstNewContent,
         nsIMutationObserver::kContentAppended::kAttributeWillChange);
}

void                                                aNameSpaceID,
ent*aChild
  MOZ_ASSERT(aContainer->IsContent                                                aModType,
             containermust  nsIContentor Document)
  aContainer->OwnerDoc()->Changed();
    ->OwnerDoc)>Changed;
           (aElement,
}         NOTIFIER(ttributeChanged,aElementaNameSpaceIDaAttribute,

void MutationObservers::NotifyContentWillBeRemoved(
    nsINode*                  aModType,aOldValue),
  MOZ_ASSERT(aContainerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
             "container must be an nsIContent or                                                          aNameSpaceID
  MOZ_ASSERTaChildGetParentNode(= ,
             "We expecteSetToCurrentValue, aElement, aNameSpaceID, aAttribute),
  aContainer->
  Notifyvoid ::NotifyContentAppended(nsIContent*aContainer
      aContainerNOTIFIERContentWillBeRemoved, aChild, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      nsIMutationObserver->OwnerDoc(-Changed
}

void MutationObservers::NotifyARIAAttributeDefaultWillChange(
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Notify<NotifyPresShell::No>                              nsIContent aChild {
      aElement
      NOTIFIER(RIAAttributeDefaultWillChange ,aAttributeaModType
      nsIMutationObserver::kARIAAttributeDefaultWillChange);
}

void MutationObservers:NotifyARIAAttributeDefaultChanged
    mozilladomElement*aElement, nsAtom aAttribute int32_taModType
  Notify<NotifyPresShell
      aElementvoidMutationObserversNotifyContentWillBeRemoved(
( aAttribute
      nsIMutationObserver  <NotifyPresShell:>(
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

}  // namespace mozilla

void:::lement,nsAtom, int32_t) 
    dom  NotifyNotifyPresShell(
  MOZ_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

NonOwningAnimationTarget =->GetTargetForAnimationjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  Notify>
    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 =.;
    switch:kARIAAttributeDefaultChanged
      
        (,elemaAnimation
        break;
case:::
        IMPL_ANIMATION_NOTIFICATION(AnimationChangedMOZ_ASSERTaAnimation
        break
caseAnimationMutationType:
        IMPL_ANIMATION_NOTIFICATION(AnimationRemovedreturnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        break;
      default
    MOZ_ASSERT_UNREACHABLE(" mutation type";
    }
  }
}

void MutationObservers::NotifyAnimationAdded(dom::Animation* aAnimation    Element* elem = .mElement;
(aAnimation,AnimationMutationTypeAddedjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

voidMutationObservers::NotifyAnimationChanged(dom:Animation aAnimation {
  NotifyAnimationMutated        break;
}

void MutationObservers:        IMPL_ANIMATION_NOTIFICATION(AnimationChangedelem, (aAnimation);
  NotifyAnimationMutated(      case AnimationMutationType:Removedjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}