mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-06 07:48:38 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
696
dom/base/nsNodeUtils.cpp
Normal file
696
dom/base/nsNodeUtils.cpp
Normal file
|
|
@ -0,0 +1,696 @@
|
|||
/* -*- 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 "nsNodeUtils.h"
|
||||
#include "nsContentUtils.h"
|
||||
#include "nsCSSPseudoElements.h"
|
||||
#include "nsINode.h"
|
||||
#include "nsIContent.h"
|
||||
#include "mozilla/dom/Element.h"
|
||||
#include "nsIMutationObserver.h"
|
||||
#include "nsIDocument.h"
|
||||
#include "mozilla/EventListenerManager.h"
|
||||
#include "nsIXPConnect.h"
|
||||
#include "PLDHashTable.h"
|
||||
#include "nsIDOMAttr.h"
|
||||
#include "nsCOMArray.h"
|
||||
#include "nsPIDOMWindow.h"
|
||||
#include "nsDocument.h"
|
||||
#ifdef MOZ_XUL
|
||||
#include "nsXULElement.h"
|
||||
#endif
|
||||
#include "nsBindingManager.h"
|
||||
#include "nsGenericHTMLElement.h"
|
||||
#include "mozilla/AnimationTarget.h"
|
||||
#include "mozilla/Assertions.h"
|
||||
#include "mozilla/dom/Animation.h"
|
||||
#include "mozilla/dom/HTMLImageElement.h"
|
||||
#include "mozilla/dom/HTMLMediaElement.h"
|
||||
#include "mozilla/dom/KeyframeEffectReadOnly.h"
|
||||
#include "nsWrapperCacheInlines.h"
|
||||
#include "nsObjectLoadingContent.h"
|
||||
#include "nsDOMMutationObserver.h"
|
||||
#include "mozilla/dom/BindingUtils.h"
|
||||
#include "mozilla/dom/HTMLTemplateElement.h"
|
||||
#include "mozilla/dom/ShadowRoot.h"
|
||||
|
||||
using namespace mozilla;
|
||||
using namespace mozilla::dom;
|
||||
using mozilla::AutoJSContext;
|
||||
|
||||
// This macro expects the ownerDocument of content_ to be in scope as
|
||||
// |nsIDocument* doc|
|
||||
#define IMPL_MUTATION_NOTIFICATION(func_, content_, params_) \
|
||||
PR_BEGIN_MACRO \
|
||||
bool needsEnterLeave = doc->MayHaveDOMMutationObservers(); \
|
||||
if (needsEnterLeave) { \
|
||||
nsDOMMutationObserver::EnterMutationHandling(); \
|
||||
} \
|
||||
nsINode* node = content_; \
|
||||
NS_ASSERTION(node->OwnerDoc() == doc, "Bogus document"); \
|
||||
if (doc) { \
|
||||
doc->BindingManager()->func_ params_; \
|
||||
} \
|
||||
do { \
|
||||
nsINode::nsSlots* slots = node->GetExistingSlots(); \
|
||||
if (slots && !slots->mMutationObservers.IsEmpty()) { \
|
||||
/* No need to explicitly notify the first observer first \
|
||||
since that'll happen anyway. */ \
|
||||
NS_OBSERVER_ARRAY_NOTIFY_OBSERVERS( \
|
||||
slots->mMutationObservers, nsIMutationObserver, \
|
||||
func_, params_); \
|
||||
} \
|
||||
ShadowRoot* shadow = ShadowRoot::FromNode(node); \
|
||||
if (shadow) { \
|
||||
node = shadow->GetPoolHost(); \
|
||||
} else { \
|
||||
node = node->GetParentNode(); \
|
||||
} \
|
||||
} while (node); \
|
||||
if (needsEnterLeave) { \
|
||||
nsDOMMutationObserver::LeaveMutationHandling(); \
|
||||
} \
|
||||
PR_END_MACRO
|
||||
|
||||
#define IMPL_ANIMATION_NOTIFICATION(func_, content_, params_) \
|
||||
PR_BEGIN_MACRO \
|
||||
bool needsEnterLeave = doc->MayHaveDOMMutationObservers(); \
|
||||
if (needsEnterLeave) { \
|
||||
nsDOMMutationObserver::EnterMutationHandling(); \
|
||||
} \
|
||||
nsINode* node = content_; \
|
||||
do { \
|
||||
nsINode::nsSlots* slots = node->GetExistingSlots(); \
|
||||
if (slots && !slots->mMutationObservers.IsEmpty()) { \
|
||||
/* No need to explicitly notify the first observer first \
|
||||
since that'll happen anyway. */ \
|
||||
NS_OBSERVER_ARRAY_NOTIFY_OBSERVERS_WITH_QI( \
|
||||
slots->mMutationObservers, nsIMutationObserver, \
|
||||
nsIAnimationObserver, func_, params_); \
|
||||
} \
|
||||
ShadowRoot* shadow = ShadowRoot::FromNode(node); \
|
||||
if (shadow) { \
|
||||
node = shadow->GetPoolHost(); \
|
||||
} else { \
|
||||
node = node->GetParentNode(); \
|
||||
} \
|
||||
} while (node); \
|
||||
if (needsEnterLeave) { \
|
||||
nsDOMMutationObserver::LeaveMutationHandling(); \
|
||||
} \
|
||||
PR_END_MACRO
|
||||
|
||||
void
|
||||
nsNodeUtils::CharacterDataWillChange(nsIContent* aContent,
|
||||
CharacterDataChangeInfo* aInfo)
|
||||
{
|
||||
nsIDocument* doc = aContent->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(CharacterDataWillChange, aContent,
|
||||
(doc, aContent, aInfo));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::CharacterDataChanged(nsIContent* aContent,
|
||||
CharacterDataChangeInfo* aInfo)
|
||||
{
|
||||
nsIDocument* doc = aContent->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(CharacterDataChanged, aContent,
|
||||
(doc, aContent, aInfo));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AttributeWillChange(Element* aElement,
|
||||
int32_t aNameSpaceID,
|
||||
nsIAtom* aAttribute,
|
||||
int32_t aModType,
|
||||
const nsAttrValue* aNewValue)
|
||||
{
|
||||
nsIDocument* doc = aElement->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(AttributeWillChange, aElement,
|
||||
(doc, aElement, aNameSpaceID, aAttribute,
|
||||
aModType, aNewValue));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AttributeChanged(Element* aElement,
|
||||
int32_t aNameSpaceID,
|
||||
nsIAtom* aAttribute,
|
||||
int32_t aModType,
|
||||
const nsAttrValue* aOldValue)
|
||||
{
|
||||
nsIDocument* doc = aElement->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(AttributeChanged, aElement,
|
||||
(doc, aElement, aNameSpaceID, aAttribute,
|
||||
aModType, aOldValue));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AttributeSetToCurrentValue(Element* aElement,
|
||||
int32_t aNameSpaceID,
|
||||
nsIAtom* aAttribute)
|
||||
{
|
||||
nsIDocument* doc = aElement->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(AttributeSetToCurrentValue, aElement,
|
||||
(doc, aElement, aNameSpaceID, aAttribute));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::ContentAppended(nsIContent* aContainer,
|
||||
nsIContent* aFirstNewContent,
|
||||
int32_t aNewIndexInContainer)
|
||||
{
|
||||
nsIDocument* doc = aContainer->OwnerDoc();
|
||||
|
||||
IMPL_MUTATION_NOTIFICATION(ContentAppended, aContainer,
|
||||
(doc, aContainer, aFirstNewContent,
|
||||
aNewIndexInContainer));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::NativeAnonymousChildListChange(nsIContent* aContent,
|
||||
bool aIsRemove)
|
||||
{
|
||||
nsIDocument* doc = aContent->OwnerDoc();
|
||||
IMPL_MUTATION_NOTIFICATION(NativeAnonymousChildListChange, aContent,
|
||||
(doc, aContent, aIsRemove));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::ContentInserted(nsINode* aContainer,
|
||||
nsIContent* aChild,
|
||||
int32_t aIndexInContainer)
|
||||
{
|
||||
NS_PRECONDITION(aContainer->IsNodeOfType(nsINode::eCONTENT) ||
|
||||
aContainer->IsNodeOfType(nsINode::eDOCUMENT),
|
||||
"container must be an nsIContent or an nsIDocument");
|
||||
nsIContent* container;
|
||||
nsIDocument* doc = aContainer->OwnerDoc();
|
||||
nsIDocument* document;
|
||||
if (aContainer->IsNodeOfType(nsINode::eCONTENT)) {
|
||||
container = static_cast<nsIContent*>(aContainer);
|
||||
document = doc;
|
||||
}
|
||||
else {
|
||||
container = nullptr;
|
||||
document = static_cast<nsIDocument*>(aContainer);
|
||||
}
|
||||
|
||||
IMPL_MUTATION_NOTIFICATION(ContentInserted, aContainer,
|
||||
(document, container, aChild, aIndexInContainer));
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::ContentRemoved(nsINode* aContainer,
|
||||
nsIContent* aChild,
|
||||
int32_t aIndexInContainer,
|
||||
nsIContent* aPreviousSibling)
|
||||
{
|
||||
NS_PRECONDITION(aContainer->IsNodeOfType(nsINode::eCONTENT) ||
|
||||
aContainer->IsNodeOfType(nsINode::eDOCUMENT),
|
||||
"container must be an nsIContent or an nsIDocument");
|
||||
nsIContent* container;
|
||||
nsIDocument* doc = aContainer->OwnerDoc();
|
||||
nsIDocument* document;
|
||||
if (aContainer->IsNodeOfType(nsINode::eCONTENT)) {
|
||||
container = static_cast<nsIContent*>(aContainer);
|
||||
document = doc;
|
||||
}
|
||||
else {
|
||||
container = nullptr;
|
||||
document = static_cast<nsIDocument*>(aContainer);
|
||||
}
|
||||
|
||||
IMPL_MUTATION_NOTIFICATION(ContentRemoved, aContainer,
|
||||
(document, container, aChild, aIndexInContainer,
|
||||
aPreviousSibling));
|
||||
}
|
||||
|
||||
Maybe<NonOwningAnimationTarget>
|
||||
nsNodeUtils::GetTargetForAnimation(const Animation* aAnimation)
|
||||
{
|
||||
AnimationEffectReadOnly* effect = aAnimation->GetEffect();
|
||||
if (!effect || !effect->AsKeyframeEffect()) {
|
||||
return Nothing();
|
||||
}
|
||||
return effect->AsKeyframeEffect()->GetTarget();
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AnimationMutated(Animation* aAnimation,
|
||||
AnimationMutationType aMutatedType)
|
||||
{
|
||||
Maybe<NonOwningAnimationTarget> target = GetTargetForAnimation(aAnimation);
|
||||
if (!target) {
|
||||
return;
|
||||
}
|
||||
|
||||
// A pseudo element and its parent element use the same owner doc.
|
||||
nsIDocument* 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
|
||||
nsNodeUtils::AnimationAdded(Animation* aAnimation)
|
||||
{
|
||||
AnimationMutated(aAnimation, AnimationMutationType::Added);
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AnimationChanged(Animation* aAnimation)
|
||||
{
|
||||
AnimationMutated(aAnimation, AnimationMutationType::Changed);
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::AnimationRemoved(Animation* aAnimation)
|
||||
{
|
||||
AnimationMutated(aAnimation, AnimationMutationType::Removed);
|
||||
}
|
||||
|
||||
void
|
||||
nsNodeUtils::LastRelease(nsINode* aNode)
|
||||
{
|
||||
nsINode::nsSlots* slots = aNode->GetExistingSlots();
|
||||
if (slots) {
|
||||
if (!slots->mMutationObservers.IsEmpty()) {
|
||||
NS_OBSERVER_ARRAY_NOTIFY_OBSERVERS(slots->mMutationObservers,
|
||||
nsIMutationObserver,
|
||||
NodeWillBeDestroyed, (aNode));
|
||||
}
|
||||
|
||||
if (aNode->IsElement()) {
|
||||
Element* elem = aNode->AsElement();
|
||||
FragmentOrElement::nsDOMSlots* domSlots =
|
||||
static_cast<FragmentOrElement::nsDOMSlots*>(slots);
|
||||
for (auto& reg : domSlots->mRegisteredIntersectionObservers) {
|
||||
reg.observer->UnlinkTarget(*elem);
|
||||
}
|
||||
}
|
||||
|
||||
delete slots;
|
||||
aNode->mSlots = nullptr;
|
||||
}
|
||||
|
||||
// Kill properties first since that may run external code, so we want to
|
||||
// be in as complete state as possible at that time.
|
||||
if (aNode->IsNodeOfType(nsINode::eDOCUMENT)) {
|
||||
// Delete all properties before tearing down the document. Some of the
|
||||
// properties are bound to nsINode objects and the destructor functions of
|
||||
// the properties may want to use the owner document of the nsINode.
|
||||
static_cast<nsIDocument*>(aNode)->DeleteAllProperties();
|
||||
}
|
||||
else {
|
||||
if (aNode->HasProperties()) {
|
||||
// Strong reference to the document so that deleting properties can't
|
||||
// delete the document.
|
||||
nsCOMPtr<nsIDocument> document = aNode->OwnerDoc();
|
||||
document->DeleteAllPropertiesFor(aNode);
|
||||
}
|
||||
|
||||
// I wonder whether it's faster to do the HasFlag check first....
|
||||
if (aNode->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) &&
|
||||
aNode->HasFlag(ADDED_TO_FORM)) {
|
||||
// Tell the form (if any) this node is going away. Don't
|
||||
// notify, since we're being destroyed in any case.
|
||||
static_cast<nsGenericHTMLFormElement*>(aNode)->ClearForm(true);
|
||||
}
|
||||
|
||||
if (aNode->IsHTMLElement(nsGkAtoms::img) &&
|
||||
aNode->HasFlag(ADDED_TO_FORM)) {
|
||||
HTMLImageElement* imageElem = static_cast<HTMLImageElement*>(aNode);
|
||||
imageElem->ClearForm(true);
|
||||
}
|
||||
}
|
||||
aNode->UnsetFlags(NODE_HAS_PROPERTIES);
|
||||
|
||||
if (aNode->NodeType() != nsIDOMNode::DOCUMENT_NODE &&
|
||||
aNode->HasFlag(NODE_HAS_LISTENERMANAGER)) {
|
||||
#ifdef DEBUG
|
||||
if (nsContentUtils::IsInitialized()) {
|
||||
EventListenerManager* manager =
|
||||
nsContentUtils::GetExistingListenerManagerForNode(aNode);
|
||||
if (!manager) {
|
||||
NS_ERROR("Huh, our bit says we have a listener manager list, "
|
||||
"but there's nothing in the hash!?!!");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
nsContentUtils::RemoveListenerManager(aNode);
|
||||
aNode->UnsetFlags(NODE_HAS_LISTENERMANAGER);
|
||||
}
|
||||
|
||||
if (aNode->IsElement()) {
|
||||
nsIDocument* ownerDoc = aNode->OwnerDoc();
|
||||
Element* elem = aNode->AsElement();
|
||||
ownerDoc->ClearBoxObjectFor(elem);
|
||||
|
||||
NS_ASSERTION(aNode->HasFlag(NODE_FORCE_XBL_BINDINGS) ||
|
||||
!elem->GetXBLBinding(),
|
||||
"Non-forced node has binding on destruction");
|
||||
|
||||
// if NODE_FORCE_XBL_BINDINGS is set, the node might still have a binding
|
||||
// attached
|
||||
if (aNode->HasFlag(NODE_FORCE_XBL_BINDINGS) &&
|
||||
ownerDoc->BindingManager()) {
|
||||
ownerDoc->BindingManager()->RemovedFromDocument(elem, ownerDoc,
|
||||
nsBindingManager::eRunDtor);
|
||||
}
|
||||
}
|
||||
|
||||
aNode->ReleaseWrapper(aNode);
|
||||
|
||||
FragmentOrElement::RemoveBlackMarkedNode(aNode);
|
||||
}
|
||||
|
||||
static void
|
||||
NoteUserData(void *aObject, nsIAtom *aKey, void *aXPCOMChild, void *aData)
|
||||
{
|
||||
nsCycleCollectionTraversalCallback* cb =
|
||||
static_cast<nsCycleCollectionTraversalCallback*>(aData);
|
||||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "[user data]");
|
||||
cb->NoteXPCOMChild(static_cast<nsISupports*>(aXPCOMChild));
|
||||
}
|
||||
|
||||
/* static */
|
||||
void
|
||||
nsNodeUtils::TraverseUserData(nsINode* aNode,
|
||||
nsCycleCollectionTraversalCallback &aCb)
|
||||
{
|
||||
nsIDocument* ownerDoc = aNode->OwnerDoc();
|
||||
ownerDoc->PropertyTable(DOM_USER_DATA)->Enumerate(aNode, NoteUserData, &aCb);
|
||||
}
|
||||
|
||||
/* static */
|
||||
nsresult
|
||||
nsNodeUtils::CloneNodeImpl(nsINode *aNode, bool aDeep, nsINode **aResult)
|
||||
{
|
||||
*aResult = nullptr;
|
||||
|
||||
nsCOMPtr<nsINode> newNode;
|
||||
nsCOMArray<nsINode> nodesWithProperties;
|
||||
nsresult rv = Clone(aNode, aDeep, nullptr, nodesWithProperties,
|
||||
getter_AddRefs(newNode));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
newNode.forget(aResult);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
/* static */
|
||||
nsresult
|
||||
nsNodeUtils::CloneAndAdopt(nsINode *aNode, bool aClone, bool aDeep,
|
||||
nsNodeInfoManager *aNewNodeInfoManager,
|
||||
JS::Handle<JSObject*> aReparentScope,
|
||||
nsCOMArray<nsINode> &aNodesWithProperties,
|
||||
nsINode *aParent, nsINode **aResult)
|
||||
{
|
||||
NS_PRECONDITION((!aClone && aNewNodeInfoManager) || !aReparentScope,
|
||||
"If cloning or not getting a new nodeinfo we shouldn't "
|
||||
"rewrap");
|
||||
NS_PRECONDITION(!aParent || aNode->IsNodeOfType(nsINode::eCONTENT),
|
||||
"Can't insert document or attribute nodes into a parent");
|
||||
|
||||
*aResult = nullptr;
|
||||
|
||||
// First deal with aNode and walk its attributes (and their children). Then,
|
||||
// if aDeep is true, deal with aNode's children (and recurse into their
|
||||
// attributes and children).
|
||||
|
||||
nsAutoScriptBlocker scriptBlocker;
|
||||
nsresult rv;
|
||||
|
||||
nsNodeInfoManager *nodeInfoManager = aNewNodeInfoManager;
|
||||
|
||||
// aNode.
|
||||
NodeInfo *nodeInfo = aNode->mNodeInfo;
|
||||
RefPtr<NodeInfo> newNodeInfo;
|
||||
if (nodeInfoManager) {
|
||||
|
||||
// Don't allow importing/adopting nodes from non-privileged "scriptable"
|
||||
// documents to "non-scriptable" documents.
|
||||
nsIDocument* newDoc = nodeInfoManager->GetDocument();
|
||||
NS_ENSURE_STATE(newDoc);
|
||||
bool hasHadScriptHandlingObject = false;
|
||||
if (!newDoc->GetScriptHandlingObject(hasHadScriptHandlingObject) &&
|
||||
!hasHadScriptHandlingObject) {
|
||||
nsIDocument* currentDoc = aNode->OwnerDoc();
|
||||
NS_ENSURE_STATE((nsContentUtils::IsChromeDoc(currentDoc) ||
|
||||
(!currentDoc->GetScriptHandlingObject(hasHadScriptHandlingObject) &&
|
||||
!hasHadScriptHandlingObject)));
|
||||
}
|
||||
|
||||
newNodeInfo = nodeInfoManager->GetNodeInfo(nodeInfo->NameAtom(),
|
||||
nodeInfo->GetPrefixAtom(),
|
||||
nodeInfo->NamespaceID(),
|
||||
nodeInfo->NodeType(),
|
||||
nodeInfo->GetExtraName());
|
||||
|
||||
nodeInfo = newNodeInfo;
|
||||
}
|
||||
|
||||
Element *elem = aNode->IsElement() ? aNode->AsElement() : nullptr;
|
||||
|
||||
nsCOMPtr<nsINode> clone;
|
||||
if (aClone) {
|
||||
rv = aNode->Clone(nodeInfo, getter_AddRefs(clone));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
if (clone->IsElement()) {
|
||||
// The cloned node may be a custom element that may require
|
||||
// enqueing created callback and prototype swizzling.
|
||||
Element* elem = clone->AsElement();
|
||||
if (nsContentUtils::IsCustomElementName(nodeInfo->NameAtom())) {
|
||||
nsContentUtils::SetupCustomElement(elem);
|
||||
} else {
|
||||
// Check if node may be custom element by type extension.
|
||||
// ex. <button is="x-button">
|
||||
nsAutoString extension;
|
||||
if (elem->GetAttr(kNameSpaceID_None, nsGkAtoms::is, extension) &&
|
||||
!extension.IsEmpty()) {
|
||||
nsContentUtils::SetupCustomElement(elem, &extension);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (aParent) {
|
||||
// If we're cloning we need to insert the cloned children into the cloned
|
||||
// parent.
|
||||
rv = aParent->AppendChildTo(static_cast<nsIContent*>(clone.get()),
|
||||
false);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
else if (aDeep && clone->IsNodeOfType(nsINode::eDOCUMENT)) {
|
||||
// After cloning the document itself, we want to clone the children into
|
||||
// the cloned document (somewhat like cloning and importing them into the
|
||||
// cloned document).
|
||||
nodeInfoManager = clone->mNodeInfo->NodeInfoManager();
|
||||
}
|
||||
}
|
||||
else if (nodeInfoManager) {
|
||||
nsIDocument* oldDoc = aNode->OwnerDoc();
|
||||
bool wasRegistered = false;
|
||||
if (aNode->IsElement()) {
|
||||
Element* element = aNode->AsElement();
|
||||
oldDoc->ClearBoxObjectFor(element);
|
||||
wasRegistered = oldDoc->UnregisterActivityObserver(element);
|
||||
}
|
||||
|
||||
aNode->mNodeInfo.swap(newNodeInfo);
|
||||
if (elem) {
|
||||
elem->NodeInfoChanged();
|
||||
}
|
||||
|
||||
nsIDocument* newDoc = aNode->OwnerDoc();
|
||||
if (newDoc) {
|
||||
// XXX what if oldDoc is null, we don't know if this should be
|
||||
// registered or not! Can that really happen?
|
||||
if (wasRegistered) {
|
||||
newDoc->RegisterActivityObserver(aNode->AsElement());
|
||||
}
|
||||
|
||||
if (nsPIDOMWindowInner* window = newDoc->GetInnerWindow()) {
|
||||
EventListenerManager* elm = aNode->GetExistingListenerManager();
|
||||
if (elm) {
|
||||
window->SetMutationListeners(elm->MutationListenerBits());
|
||||
if (elm->MayHavePaintEventListener()) {
|
||||
window->SetHasPaintEventListeners();
|
||||
}
|
||||
if (elm->MayHaveTouchEventListener()) {
|
||||
window->SetHasTouchEventListeners();
|
||||
}
|
||||
if (elm->MayHaveMouseEnterLeaveEventListener()) {
|
||||
window->SetHasMouseEnterLeaveEventListeners();
|
||||
}
|
||||
if (elm->MayHavePointerEnterLeaveEventListener()) {
|
||||
window->SetHasPointerEnterLeaveEventListeners();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (wasRegistered && oldDoc != newDoc) {
|
||||
nsCOMPtr<nsIDOMHTMLMediaElement> domMediaElem(do_QueryInterface(aNode));
|
||||
if (domMediaElem) {
|
||||
HTMLMediaElement* mediaElem = static_cast<HTMLMediaElement*>(aNode);
|
||||
mediaElem->NotifyOwnerDocumentActivityChanged();
|
||||
}
|
||||
nsCOMPtr<nsIObjectLoadingContent> objectLoadingContent(do_QueryInterface(aNode));
|
||||
if (objectLoadingContent) {
|
||||
nsObjectLoadingContent* olc = static_cast<nsObjectLoadingContent*>(objectLoadingContent.get());
|
||||
olc->NotifyOwnerDocumentActivityChanged();
|
||||
}
|
||||
}
|
||||
|
||||
if (oldDoc != newDoc && oldDoc->MayHaveDOMMutationObservers()) {
|
||||
newDoc->SetMayHaveDOMMutationObservers();
|
||||
}
|
||||
|
||||
if (oldDoc != newDoc && oldDoc->MayHaveAnimationObservers()) {
|
||||
newDoc->SetMayHaveAnimationObservers();
|
||||
}
|
||||
|
||||
if (elem) {
|
||||
elem->RecompileScriptEventListeners();
|
||||
}
|
||||
|
||||
if (aReparentScope) {
|
||||
AutoJSContext cx;
|
||||
JS::Rooted<JSObject*> wrapper(cx);
|
||||
if ((wrapper = aNode->GetWrapper())) {
|
||||
MOZ_ASSERT(IsDOMObject(wrapper));
|
||||
JSAutoCompartment ac(cx, wrapper);
|
||||
rv = ReparentWrapper(cx, wrapper);
|
||||
if (NS_FAILED(rv)) {
|
||||
if (wasRegistered) {
|
||||
aNode->OwnerDoc()->UnregisterActivityObserver(aNode->AsElement());
|
||||
}
|
||||
aNode->mNodeInfo.swap(newNodeInfo);
|
||||
if (wasRegistered) {
|
||||
aNode->OwnerDoc()->RegisterActivityObserver(aNode->AsElement());
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (aNode->HasProperties()) {
|
||||
bool ok = aNodesWithProperties.AppendObject(aNode);
|
||||
MOZ_RELEASE_ASSERT(ok, "Out of memory");
|
||||
if (aClone) {
|
||||
ok = aNodesWithProperties.AppendObject(clone);
|
||||
MOZ_RELEASE_ASSERT(ok, "Out of memory");
|
||||
}
|
||||
}
|
||||
|
||||
if (aDeep && (!aClone || !aNode->IsNodeOfType(nsINode::eATTRIBUTE))) {
|
||||
// aNode's children.
|
||||
for (nsIContent* cloneChild = aNode->GetFirstChild();
|
||||
cloneChild;
|
||||
cloneChild = cloneChild->GetNextSibling()) {
|
||||
nsCOMPtr<nsINode> child;
|
||||
rv = CloneAndAdopt(cloneChild, aClone, true, nodeInfoManager,
|
||||
aReparentScope, aNodesWithProperties, clone,
|
||||
getter_AddRefs(child));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
}
|
||||
|
||||
// Cloning template element.
|
||||
if (aDeep && aClone && IsTemplateElement(aNode)) {
|
||||
DocumentFragment* origContent =
|
||||
static_cast<HTMLTemplateElement*>(aNode)->Content();
|
||||
DocumentFragment* cloneContent =
|
||||
static_cast<HTMLTemplateElement*>(clone.get())->Content();
|
||||
|
||||
// Clone the children into the clone's template content owner
|
||||
// document's nodeinfo manager.
|
||||
nsNodeInfoManager* ownerNodeInfoManager =
|
||||
cloneContent->mNodeInfo->NodeInfoManager();
|
||||
|
||||
for (nsIContent* cloneChild = origContent->GetFirstChild();
|
||||
cloneChild;
|
||||
cloneChild = cloneChild->GetNextSibling()) {
|
||||
nsCOMPtr<nsINode> child;
|
||||
rv = CloneAndAdopt(cloneChild, aClone, aDeep, ownerNodeInfoManager,
|
||||
aReparentScope, aNodesWithProperties, cloneContent,
|
||||
getter_AddRefs(child));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
}
|
||||
|
||||
// XXX setting document on some nodes not in a document so XBL will bind
|
||||
// and chrome won't break. Make XBL bind to document-less nodes!
|
||||
// XXXbz Once this is fixed, fix up the asserts in all implementations of
|
||||
// BindToTree to assert what they would like to assert, and fix the
|
||||
// ChangeDocumentFor() call in nsXULElement::BindToTree as well. Also,
|
||||
// remove the UnbindFromTree call in ~nsXULElement, and add back in the
|
||||
// precondition in nsXULElement::UnbindFromTree and remove the line in
|
||||
// nsXULElement.h that makes nsNodeUtils a friend of nsXULElement.
|
||||
// Note: Make sure to do this witchery _after_ we've done any deep
|
||||
// cloning, so kids of the new node aren't confused about whether they're
|
||||
// in a document.
|
||||
#ifdef MOZ_XUL
|
||||
if (aClone && !aParent && aNode->IsXULElement()) {
|
||||
if (!aNode->OwnerDoc()->IsLoadedAsInteractiveData()) {
|
||||
clone->SetFlags(NODE_FORCE_XBL_BINDINGS);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
clone.forget(aResult);
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
void
|
||||
nsNodeUtils::UnlinkUserData(nsINode *aNode)
|
||||
{
|
||||
NS_ASSERTION(aNode->HasProperties(), "Call to UnlinkUserData not needed.");
|
||||
|
||||
// Strong reference to the document so that deleting properties can't
|
||||
// delete the document.
|
||||
nsCOMPtr<nsIDocument> document = aNode->OwnerDoc();
|
||||
document->PropertyTable(DOM_USER_DATA)->DeleteAllPropertiesFor(aNode);
|
||||
}
|
||||
|
||||
bool
|
||||
nsNodeUtils::IsTemplateElement(const nsINode *aNode)
|
||||
{
|
||||
return aNode->IsHTMLElement(nsGkAtoms::_template);
|
||||
}
|
||||
|
||||
nsIContent*
|
||||
nsNodeUtils::GetFirstChildOfTemplateOrNode(nsINode* aNode)
|
||||
{
|
||||
if (nsNodeUtils::IsTemplateElement(aNode)) {
|
||||
DocumentFragment* frag =
|
||||
static_cast<HTMLTemplateElement*>(aNode)->Content();
|
||||
return frag->GetFirstChild();
|
||||
}
|
||||
|
||||
return aNode->GetFirstChild();
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue