Add m-esr52 at 52.6.0

1 files changed, 214 insertions, 0 deletions

diff --git a/dom/base/nsAttrName.h b/dom/base/nsAttrName.h
new file mode 100644
index 000000000..828d2689d
--- /dev/null
+++ b/dom/base/nsAttrName.h
@@ -0,0 +1,214 @@
+/* -*- 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/. */
+
+/*
+ * Class that represents the name (nodeinfo or atom) of an attribute;
+ * using nodeinfos all the time is too slow, so we use atoms when we
+ * can.
+ */
+
+#ifndef nsAttrName_h___
+#define nsAttrName_h___
+
+#include "mozilla/dom/NodeInfo.h"
+#include "nsIAtom.h"
+#include "nsDOMString.h"
+
+#define NS_ATTRNAME_NODEINFO_BIT 1
+class nsAttrName
+{
+public:
+  nsAttrName(const nsAttrName& aOther)
+    : mBits(aOther.mBits)
+  {
+    AddRefInternalName();
+  }
+
+  explicit nsAttrName(nsIAtom* aAtom)
+    : mBits(reinterpret_cast<uintptr_t>(aAtom))
+  {
+    NS_ASSERTION(aAtom, "null atom-name in nsAttrName");
+    NS_ADDREF(aAtom);
+  }
+
+  explicit nsAttrName(mozilla::dom::NodeInfo* aNodeInfo)
+  {
+    NS_ASSERTION(aNodeInfo, "null nodeinfo-name in nsAttrName");
+    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
+      NS_ADDREF(aNodeInfo->NameAtom());
+    }
+    else {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
+              NS_ATTRNAME_NODEINFO_BIT;
+      NS_ADDREF(aNodeInfo);
+    }
+  }
+
+  ~nsAttrName()
+  {
+    ReleaseInternalName();
+  }
+
+  void SetTo(mozilla::dom::NodeInfo* aNodeInfo)
+  {
+    NS_ASSERTION(aNodeInfo, "null nodeinfo-name in nsAttrName");
+
+    ReleaseInternalName();
+    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
+      NS_ADDREF(aNodeInfo->NameAtom());
+    }
+    else {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
+              NS_ATTRNAME_NODEINFO_BIT;
+      NS_ADDREF(aNodeInfo);
+    }
+  }
+
+  void SetTo(nsIAtom* aAtom)
+  {
+    NS_ASSERTION(aAtom, "null atom-name in nsAttrName");
+
+    ReleaseInternalName();
+    mBits = reinterpret_cast<uintptr_t>(aAtom);
+    NS_ADDREF(aAtom);
+  }
+
+  bool IsAtom() const
+  {
+    return !(mBits & NS_ATTRNAME_NODEINFO_BIT);
+  }
+
+  mozilla::dom::NodeInfo* NodeInfo() const
+  {
+    NS_ASSERTION(!IsAtom(), "getting nodeinfo-value of atom-name");
+    return reinterpret_cast<mozilla::dom::NodeInfo*>(mBits & ~NS_ATTRNAME_NODEINFO_BIT);
+  }
+
+  nsIAtom* Atom() const
+  {
+    NS_ASSERTION(IsAtom(), "getting atom-value of nodeinfo-name");
+    return reinterpret_cast<nsIAtom*>(mBits);
+  }
+
+  bool Equals(const nsAttrName& aOther) const
+  {
+    return mBits == aOther.mBits;
+  }
+
+  // Faster comparison in the case we know the namespace is null
+  bool Equals(nsIAtom* aAtom) const
+  {
+    return reinterpret_cast<uintptr_t>(aAtom) == mBits;
+  }
+
+  // And the same but without forcing callers to atomize
+  bool Equals(const nsAString& aLocalName) const
+  {
+    return IsAtom() && Atom()->Equals(aLocalName);
+  }
+
+  bool Equals(nsIAtom* aLocalName, int32_t aNamespaceID) const
+  {
+    if (aNamespaceID == kNameSpaceID_None) {
+      return Equals(aLocalName);
+    }
+    return !IsAtom() && NodeInfo()->Equals(aLocalName, aNamespaceID);
+  }
+
+  bool Equals(mozilla::dom::NodeInfo* aNodeInfo) const
+  {
+    return Equals(aNodeInfo->NameAtom(), aNodeInfo->NamespaceID());
+  }
+
+  int32_t NamespaceID() const
+  {
+    return IsAtom() ? kNameSpaceID_None : NodeInfo()->NamespaceID();
+  }
+
+  int32_t NamespaceEquals(int32_t aNamespaceID) const
+  {
+    return aNamespaceID == kNameSpaceID_None ?
+           IsAtom() :
+           (!IsAtom() && NodeInfo()->NamespaceEquals(aNamespaceID));
+  }
+
+  nsIAtom* LocalName() const
+  {
+    return IsAtom() ? Atom() : NodeInfo()->NameAtom();
+  }
+
+  nsIAtom* GetPrefix() const
+  {
+    return IsAtom() ? nullptr : NodeInfo()->GetPrefixAtom();
+  }
+
+  bool QualifiedNameEquals(const nsAString& aName) const
+  {
+    return IsAtom() ? Atom()->Equals(aName) :
+                      NodeInfo()->QualifiedNameEquals(aName);
+  }
+
+  void GetQualifiedName(nsAString& aStr) const
+  {
+    if (IsAtom()) {
+      Atom()->ToString(aStr);
+    }
+    else {
+      aStr = NodeInfo()->QualifiedName();
+    }
+  }
+
+#ifdef MOZILLA_INTERNAL_API
+  void GetPrefix(nsAString& aStr) const
+  {
+    if (IsAtom()) {
+      SetDOMStringToNull(aStr);
+    }
+    else {
+      NodeInfo()->GetPrefix(aStr);
+    }
+  }
+#endif
+
+  uint32_t HashValue() const
+  {
+    // mBits and uint32_t might have different size. This should silence
+    // any warnings or compile-errors. This is what the implementation of
+    // NS_PTR_TO_INT32 does to take care of the same problem.
+    return mBits - 0;
+  }
+
+  bool IsSmaller(nsIAtom* aOther) const
+  {
+    return mBits < reinterpret_cast<uintptr_t>(aOther);
+  }
+
+private:
+
+  void AddRefInternalName()
+  {
+    if (IsAtom()) {
+      NS_ADDREF(Atom());
+    } else {
+      NS_ADDREF(NodeInfo());
+    }
+  }
+
+  void ReleaseInternalName()
+  {
+    if (IsAtom()) {
+      Atom()->Release();
+    } else {
+      NodeInfo()->Release();
+    }
+  }
+
+  uintptr_t mBits;
+};
+
+#endif