Add m-esr52 at 52.6.0

1 files changed, 433 insertions, 0 deletions

diff --git a/dom/base/nsNodeInfoManager.cpp b/dom/base/nsNodeInfoManager.cpp
new file mode 100644
index 000000000..66c8c84cf
--- /dev/null
+++ b/dom/base/nsNodeInfoManager.cpp
@@ -0,0 +1,433 @@
+/* -*- 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/. */
+
+/*
+ * A class for handing out nodeinfos and ensuring sharing of them as needed.
+ */
+
+#include "nsNodeInfoManager.h"
+
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/dom/NodeInfo.h"
+#include "mozilla/dom/NodeInfoInlines.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsIAtom.h"
+#include "nsIDocument.h"
+#include "nsIPrincipal.h"
+#include "nsIURI.h"
+#include "nsContentUtils.h"
+#include "nsReadableUtils.h"
+#include "nsGkAtoms.h"
+#include "nsComponentManagerUtils.h"
+#include "nsLayoutStatics.h"
+#include "nsBindingManager.h"
+#include "nsHashKeys.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsNameSpaceManager.h"
+#include "nsDocument.h"
+#include "nsNullPrincipal.h"
+
+using namespace mozilla;
+using mozilla::dom::NodeInfo;
+
+#include "mozilla/Logging.h"
+
+static LazyLogModule gNodeInfoManagerLeakPRLog("NodeInfoManagerLeak");
+
+PLHashNumber
+nsNodeInfoManager::GetNodeInfoInnerHashValue(const void *key)
+{
+  MOZ_ASSERT(key, "Null key passed to NodeInfo::GetHashValue!");
+
+  auto *node = reinterpret_cast<const NodeInfo::NodeInfoInner*>(key);
+
+  return node->mName ? node->mName->hash() : HashString(*(node->mNameString));
+}
+
+
+int
+nsNodeInfoManager::NodeInfoInnerKeyCompare(const void *key1, const void *key2)
+{
+  MOZ_ASSERT(key1 && key2, "Null key passed to NodeInfoInnerKeyCompare!");
+
+  auto *node1 = reinterpret_cast<const NodeInfo::NodeInfoInner*>(key1);
+  auto *node2 = reinterpret_cast<const NodeInfo::NodeInfoInner*>(key2);
+
+  if (node1->mPrefix != node2->mPrefix ||
+      node1->mNamespaceID != node2->mNamespaceID ||
+      node1->mNodeType != node2->mNodeType ||
+      node1->mExtraName != node2->mExtraName) {
+    return 0;
+  }
+
+  if (node1->mName) {
+    if (node2->mName) {
+      return (node1->mName == node2->mName);
+    }
+    return (node1->mName->Equals(*(node2->mNameString)));
+  }
+  if (node2->mName) {
+    return (node2->mName->Equals(*(node1->mNameString)));
+  }
+  return (node1->mNameString->Equals(*(node2->mNameString)));
+}
+
+
+static void* PR_CALLBACK
+AllocTable(void* pool, size_t size)
+{
+  return malloc(size);
+}
+
+static void PR_CALLBACK
+FreeTable(void* pool, void* item)
+{
+  free(item);
+}
+
+static PLHashEntry* PR_CALLBACK
+AllocEntry(void* pool, const void* key)
+{
+  return (PLHashEntry*)malloc(sizeof(PLHashEntry));
+}
+
+static void PR_CALLBACK
+FreeEntry(void* pool, PLHashEntry* he, unsigned flag)
+{
+  if (flag == HT_FREE_ENTRY) {
+    free(he);
+  }
+}
+
+static PLHashAllocOps allocOps =
+  { AllocTable, FreeTable, AllocEntry, FreeEntry };
+
+nsNodeInfoManager::nsNodeInfoManager()
+  : mDocument(nullptr),
+    mNonDocumentNodeInfos(0),
+    mTextNodeInfo(nullptr),
+    mCommentNodeInfo(nullptr),
+    mDocumentNodeInfo(nullptr)
+{
+  nsLayoutStatics::AddRef();
+
+  if (gNodeInfoManagerLeakPRLog)
+    MOZ_LOG(gNodeInfoManagerLeakPRLog, LogLevel::Debug,
+           ("NODEINFOMANAGER %p created", this));
+
+  mNodeInfoHash = PL_NewHashTable(32, GetNodeInfoInnerHashValue,
+                                  NodeInfoInnerKeyCompare,
+                                  PL_CompareValues, &allocOps, nullptr);
+}
+
+
+nsNodeInfoManager::~nsNodeInfoManager()
+{
+  if (mNodeInfoHash)
+    PL_HashTableDestroy(mNodeInfoHash);
+
+  // Note: mPrincipal may be null here if we never got inited correctly
+  mPrincipal = nullptr;
+
+  mBindingManager = nullptr;
+
+  if (gNodeInfoManagerLeakPRLog)
+    MOZ_LOG(gNodeInfoManagerLeakPRLog, LogLevel::Debug,
+           ("NODEINFOMANAGER %p destroyed", this));
+
+  nsLayoutStatics::Release();
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsNodeInfoManager)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_0(nsNodeInfoManager)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsNodeInfoManager)
+  if (tmp->mNonDocumentNodeInfos) {
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mDocument)
+  }
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBindingManager)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsNodeInfoManager, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsNodeInfoManager, Release)
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsNodeInfoManager)
+  if (tmp->mDocument) {
+    return NS_CYCLE_COLLECTION_PARTICIPANT(nsDocument)->CanSkip(tmp->mDocument, aRemovingAllowed);
+  }
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsNodeInfoManager)
+  if (tmp->mDocument) {
+    return NS_CYCLE_COLLECTION_PARTICIPANT(nsDocument)->CanSkipInCC(tmp->mDocument);
+  }
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsNodeInfoManager)
+  if (tmp->mDocument) {
+    return NS_CYCLE_COLLECTION_PARTICIPANT(nsDocument)->CanSkipThis(tmp->mDocument);
+  }
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
+
+nsresult
+nsNodeInfoManager::Init(nsIDocument *aDocument)
+{
+  NS_ENSURE_TRUE(mNodeInfoHash, NS_ERROR_OUT_OF_MEMORY);
+
+  NS_PRECONDITION(!mPrincipal,
+                  "Being inited when we already have a principal?");
+
+  mPrincipal = nsNullPrincipal::Create();
+
+  if (aDocument) {
+    mBindingManager = new nsBindingManager(aDocument);
+  }
+
+  mDefaultPrincipal = mPrincipal;
+
+  mDocument = aDocument;
+
+  if (gNodeInfoManagerLeakPRLog)
+    MOZ_LOG(gNodeInfoManagerLeakPRLog, LogLevel::Debug,
+           ("NODEINFOMANAGER %p Init document=%p", this, aDocument));
+
+  return NS_OK;
+}
+
+// static
+int
+nsNodeInfoManager::DropNodeInfoDocument(PLHashEntry *he, int hashIndex, void *arg)
+{
+  static_cast<mozilla::dom::NodeInfo*>(he->value)->mDocument = nullptr;
+  return HT_ENUMERATE_NEXT;
+}
+
+void
+nsNodeInfoManager::DropDocumentReference()
+{
+  if (mBindingManager) {
+    mBindingManager->DropDocumentReference();
+  }
+
+  // This is probably not needed anymore.
+  PL_HashTableEnumerateEntries(mNodeInfoHash, DropNodeInfoDocument, nullptr);
+
+  NS_ASSERTION(!mNonDocumentNodeInfos, "Shouldn't have non-document nodeinfos!");
+  mDocument = nullptr;
+}
+
+
+already_AddRefed<mozilla::dom::NodeInfo>
+nsNodeInfoManager::GetNodeInfo(nsIAtom *aName, nsIAtom *aPrefix,
+                               int32_t aNamespaceID, uint16_t aNodeType,
+                               nsIAtom* aExtraName /* = nullptr */)
+{
+  CheckValidNodeInfo(aNodeType, aName, aNamespaceID, aExtraName);
+
+  NodeInfo::NodeInfoInner tmpKey(aName, aPrefix, aNamespaceID, aNodeType,
+                                 aExtraName);
+
+  void *node = PL_HashTableLookup(mNodeInfoHash, &tmpKey);
+
+  if (node) {
+    RefPtr<NodeInfo> nodeInfo = static_cast<NodeInfo*>(node);
+
+    return nodeInfo.forget();
+  }
+
+  RefPtr<NodeInfo> newNodeInfo =
+    new NodeInfo(aName, aPrefix, aNamespaceID, aNodeType, aExtraName, this);
+
+  DebugOnly<PLHashEntry*> he =
+    PL_HashTableAdd(mNodeInfoHash, &newNodeInfo->mInner, newNodeInfo);
+  MOZ_ASSERT(he, "PL_HashTableAdd() failed");
+
+  // Have to do the swap thing, because already_AddRefed<nsNodeInfo>
+  // doesn't cast to already_AddRefed<mozilla::dom::NodeInfo>
+  ++mNonDocumentNodeInfos;
+  if (mNonDocumentNodeInfos == 1) {
+    NS_IF_ADDREF(mDocument);
+  }
+
+  return newNodeInfo.forget();
+}
+
+
+nsresult
+nsNodeInfoManager::GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
+                               int32_t aNamespaceID, uint16_t aNodeType,
+                               NodeInfo** aNodeInfo)
+{
+#ifdef DEBUG
+  {
+    nsCOMPtr<nsIAtom> nameAtom = NS_Atomize(aName);
+    CheckValidNodeInfo(aNodeType, nameAtom, aNamespaceID, nullptr);
+  }
+#endif
+
+  NodeInfo::NodeInfoInner tmpKey(aName, aPrefix, aNamespaceID, aNodeType);
+
+  void *node = PL_HashTableLookup(mNodeInfoHash, &tmpKey);
+
+  if (node) {
+    RefPtr<NodeInfo> nodeInfo = static_cast<NodeInfo*>(node);
+    nodeInfo.forget(aNodeInfo);
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIAtom> nameAtom = NS_Atomize(aName);
+  NS_ENSURE_TRUE(nameAtom, NS_ERROR_OUT_OF_MEMORY);
+
+  RefPtr<NodeInfo> newNodeInfo =
+    new NodeInfo(nameAtom, aPrefix, aNamespaceID, aNodeType, nullptr, this);
+  NS_ENSURE_TRUE(newNodeInfo, NS_ERROR_OUT_OF_MEMORY);
+
+  PLHashEntry *he;
+  he = PL_HashTableAdd(mNodeInfoHash, &newNodeInfo->mInner, newNodeInfo);
+  NS_ENSURE_TRUE(he, NS_ERROR_FAILURE);
+
+  ++mNonDocumentNodeInfos;
+  if (mNonDocumentNodeInfos == 1) {
+    NS_IF_ADDREF(mDocument);
+  }
+
+  newNodeInfo.forget(aNodeInfo);
+
+  return NS_OK;
+}
+
+
+nsresult
+nsNodeInfoManager::GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
+                               const nsAString& aNamespaceURI,
+                               uint16_t aNodeType,
+                               NodeInfo** aNodeInfo)
+{
+  int32_t nsid = kNameSpaceID_None;
+
+  if (!aNamespaceURI.IsEmpty()) {
+    nsresult rv = nsContentUtils::NameSpaceManager()->
+      RegisterNameSpace(aNamespaceURI, nsid);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return GetNodeInfo(aName, aPrefix, nsid, aNodeType, aNodeInfo);
+}
+
+already_AddRefed<NodeInfo>
+nsNodeInfoManager::GetTextNodeInfo()
+{
+  RefPtr<mozilla::dom::NodeInfo> nodeInfo;
+
+  if (!mTextNodeInfo) {
+    nodeInfo = GetNodeInfo(nsGkAtoms::textTagName, nullptr, kNameSpaceID_None,
+                           nsIDOMNode::TEXT_NODE, nullptr);
+    // Hold a weak ref; the nodeinfo will let us know when it goes away
+    mTextNodeInfo = nodeInfo;
+  } else {
+    nodeInfo = mTextNodeInfo;
+  }
+
+  return nodeInfo.forget();
+}
+
+already_AddRefed<NodeInfo>
+nsNodeInfoManager::GetCommentNodeInfo()
+{
+  RefPtr<NodeInfo> nodeInfo;
+
+  if (!mCommentNodeInfo) {
+    nodeInfo = GetNodeInfo(nsGkAtoms::commentTagName, nullptr,
+                           kNameSpaceID_None, nsIDOMNode::COMMENT_NODE,
+                           nullptr);
+    // Hold a weak ref; the nodeinfo will let us know when it goes away
+    mCommentNodeInfo = nodeInfo;
+  }
+  else {
+    nodeInfo = mCommentNodeInfo;
+  }
+
+  return nodeInfo.forget();
+}
+
+already_AddRefed<NodeInfo>
+nsNodeInfoManager::GetDocumentNodeInfo()
+{
+  RefPtr<NodeInfo> nodeInfo;
+
+  if (!mDocumentNodeInfo) {
+    NS_ASSERTION(mDocument, "Should have mDocument!");
+    nodeInfo = GetNodeInfo(nsGkAtoms::documentNodeName, nullptr,
+                           kNameSpaceID_None, nsIDOMNode::DOCUMENT_NODE,
+                           nullptr);
+    // Hold a weak ref; the nodeinfo will let us know when it goes away
+    mDocumentNodeInfo = nodeInfo;
+
+    --mNonDocumentNodeInfos;
+    if (!mNonDocumentNodeInfos) {
+      mDocument->Release(); // Don't set mDocument to null!
+    }
+  }
+  else {
+    nodeInfo = mDocumentNodeInfo;
+  }
+
+  return nodeInfo.forget();
+}
+
+void
+nsNodeInfoManager::SetDocumentPrincipal(nsIPrincipal *aPrincipal)
+{
+  mPrincipal = nullptr;
+  if (!aPrincipal) {
+    aPrincipal = mDefaultPrincipal;
+  }
+
+  NS_ASSERTION(aPrincipal, "Must have principal by this point!");
+  MOZ_DIAGNOSTIC_ASSERT(!nsContentUtils::IsExpandedPrincipal(aPrincipal),
+                        "Documents shouldn't have an expanded principal");
+  if (nsContentUtils::IsExpandedPrincipal(aPrincipal)) {
+    Telemetry::Accumulate(Telemetry::DOCUMENT_WITH_EXPANDED_PRINCIPAL, 1);
+  }
+
+  mPrincipal = aPrincipal;
+}
+
+void
+nsNodeInfoManager::RemoveNodeInfo(NodeInfo *aNodeInfo)
+{
+  NS_PRECONDITION(aNodeInfo, "Trying to remove null nodeinfo from manager!");
+
+  if (aNodeInfo == mDocumentNodeInfo) {
+    mDocumentNodeInfo = nullptr;
+    mDocument = nullptr;
+  } else {
+    if (--mNonDocumentNodeInfos == 0) {
+      if (mDocument) {
+        // Note, whoever calls this method should keep NodeInfoManager alive,
+        // even if mDocument gets deleted.
+        mDocument->Release();
+      }
+    }
+    // Drop weak reference if needed
+    if (aNodeInfo == mTextNodeInfo) {
+      mTextNodeInfo = nullptr;
+    }
+    else if (aNodeInfo == mCommentNodeInfo) {
+      mCommentNodeInfo = nullptr;
+    }
+  }
+
+#ifdef DEBUG
+  bool ret =
+#endif
+  PL_HashTableRemove(mNodeInfoHash, &aNodeInfo->mInner);
+
+  NS_POSTCONDITION(ret, "Can't find mozilla::dom::NodeInfo to remove!!!");
+}