Add m-esr52 at 52.6.0

1 files changed, 696 insertions, 0 deletions

diff --git a/dom/base/nsNodeUtils.cpp b/dom/base/nsNodeUtils.cpp
new file mode 100644
index 000000000..69a9414fe
--- /dev/null
+++ b/dom/base/nsNodeUtils.cpp
@@ -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();
+}
+