Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 261 insertions, 0 deletions

diff --git a/dom/base/AttrArray.h b/dom/base/AttrArray.h
new file mode 100644
index 0000000000..47e91793ce
--- /dev/null
+++ b/dom/base/AttrArray.h
@@ -0,0 +1,261 @@
+/* -*- 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/. */
+
+/*
+ * Storage of the attributes of a DOM node.
+ */
+
+#ifndef AttrArray_h___
+#define AttrArray_h___
+
+#include "mozilla/Attributes.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Span.h"
+#include "mozilla/dom/BorrowedAttrInfo.h"
+
+#include "nscore.h"
+#include "nsAttrName.h"
+#include "nsAttrValue.h"
+#include "nsCaseTreatment.h"
+
+class nsINode;
+class nsIContent;
+class nsMappedAttributes;
+class nsHTMLStyleSheet;
+class nsRuleWalker;
+class nsMappedAttributeElement;
+
+class AttrArray {
+  using BorrowedAttrInfo = mozilla::dom::BorrowedAttrInfo;
+
+ public:
+  AttrArray() = default;
+  ~AttrArray() = default;
+
+  bool HasAttrs() const { return NonMappedAttrCount() || MappedAttrCount(); }
+
+  uint32_t AttrCount() const {
+    return NonMappedAttrCount() + MappedAttrCount();
+  }
+
+  const nsAttrValue* GetAttr(const nsAtom* aLocalName,
+                             int32_t aNamespaceID = kNameSpaceID_None) const;
+  // As above but using a string attr name and always using
+  // kNameSpaceID_None.  This is always case-sensitive.
+  const nsAttrValue* GetAttr(const nsAString& aName) const;
+  // Get an nsAttrValue by qualified name.  Can optionally do
+  // ASCII-case-insensitive name matching.
+  const nsAttrValue* GetAttr(const nsAString& aName,
+                             nsCaseTreatment aCaseSensitive) const;
+  const nsAttrValue* AttrAt(uint32_t aPos) const;
+  // SetAndSwapAttr swaps the current attribute value with aValue.
+  // If the attribute was unset, an empty value will be swapped into aValue
+  // and aHadValue will be set to false. Otherwise, aHadValue will be set to
+  // true.
+  nsresult SetAndSwapAttr(nsAtom* aLocalName, nsAttrValue& aValue,
+                          bool* aHadValue);
+  nsresult SetAndSwapAttr(mozilla::dom::NodeInfo* aName, nsAttrValue& aValue,
+                          bool* aHadValue);
+
+  // Remove the attr at position aPos.  The value of the attr is placed in
+  // aValue; any value that was already in aValue is destroyed.
+  nsresult RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue);
+
+  // Returns attribute name at given position, *not* out-of-bounds safe
+  const nsAttrName* AttrNameAt(uint32_t aPos) const;
+
+  // Returns the attribute info at a given position, *not* out-of-bounds safe
+  BorrowedAttrInfo AttrInfoAt(uint32_t aPos) const;
+
+  // Returns attribute name at given position or null if aPos is out-of-bounds
+  const nsAttrName* GetSafeAttrNameAt(uint32_t aPos) const;
+
+  const nsAttrName* GetExistingAttrNameFromQName(const nsAString& aName) const;
+  int32_t IndexOfAttr(const nsAtom* aLocalName,
+                      int32_t aNamespaceID = kNameSpaceID_None) const;
+
+  // SetAndSwapMappedAttr swaps the current attribute value with aValue.
+  // If the attribute was unset, an empty value will be swapped into aValue
+  // and aHadValue will be set to false. Otherwise, aHadValue will be set to
+  // true.
+  nsresult SetAndSwapMappedAttr(nsAtom* aLocalName, nsAttrValue& aValue,
+                                nsMappedAttributeElement* aContent,
+                                nsHTMLStyleSheet* aSheet, bool* aHadValue);
+  nsresult SetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet) {
+    if (!mImpl || !mImpl->mMappedAttrs) {
+      return NS_OK;
+    }
+    return DoSetMappedAttrStyleSheet(aSheet);
+  }
+
+  // Update the rule mapping function on our mapped attributes, if we have any.
+  // We take a nsMappedAttributeElement, not a nsMapRuleToAttributesFunc,
+  // because the latter is defined in a header we can't include here.
+  nsresult UpdateMappedAttrRuleMapper(nsMappedAttributeElement& aElement) {
+    if (!mImpl || !mImpl->mMappedAttrs) {
+      return NS_OK;
+    }
+    return DoUpdateMappedAttrRuleMapper(aElement);
+  }
+
+  void Compact();
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+  bool HasMappedAttrs() const { return MappedAttrCount(); }
+  const nsMappedAttributes* GetMapped() const;
+
+  // Force this to have mapped attributes, even if those attributes are empty.
+  nsresult ForceMapped(nsMappedAttributeElement* aContent,
+                       mozilla::dom::Document* aDocument);
+
+  // Clear the servo declaration block on the mapped attributes, if any
+  // Will assert off main thread
+  void ClearMappedServoStyle();
+
+  // Increases capacity (if necessary) to have enough space to accomodate the
+  // unmapped attributes of |aOther|.
+  nsresult EnsureCapacityToClone(const AttrArray& aOther);
+
+  enum AttrValuesState { ATTR_MISSING = -1, ATTR_VALUE_NO_MATCH = -2 };
+  using AttrValuesArray = nsStaticAtom* const;
+  int32_t FindAttrValueIn(int32_t aNameSpaceID, const nsAtom* aName,
+                          AttrValuesArray* aValues,
+                          nsCaseTreatment aCaseSensitive) const;
+
+  inline bool GetAttr(int32_t aNameSpaceID, const nsAtom* aName,
+                      nsAString& aResult) const {
+    MOZ_ASSERT(aResult.IsEmpty(), "Should have empty string coming in");
+
+    const nsAttrValue* val = GetAttr(aName, aNameSpaceID);
+    if (val) {
+      val->ToString(aResult);
+      return true;
+    }
+    return false;
+  }
+
+  inline bool HasAttr(int32_t aNameSpaceID, const nsAtom* aName) const {
+    return GetAttr(aName, aNameSpaceID) != nullptr;
+  }
+
+  inline bool AttrValueIs(int32_t aNameSpaceID, const nsAtom* aName,
+                          const nsAString& aValue,
+                          nsCaseTreatment aCaseSensitive) const {
+    NS_ASSERTION(aName, "Must have attr name");
+    NS_ASSERTION(aNameSpaceID != kNameSpaceID_Unknown, "Must have namespace");
+
+    const nsAttrValue* val = GetAttr(aName, aNameSpaceID);
+    return val && val->Equals(aValue, aCaseSensitive);
+  }
+
+  inline bool AttrValueIs(int32_t aNameSpaceID, const nsAtom* aName,
+                          const nsAtom* aValue,
+                          nsCaseTreatment aCaseSensitive) const {
+    NS_ASSERTION(aName, "Must have attr name");
+    NS_ASSERTION(aNameSpaceID != kNameSpaceID_Unknown, "Must have namespace");
+    NS_ASSERTION(aValue, "Null value atom");
+
+    const nsAttrValue* val = GetAttr(aName, aNameSpaceID);
+    return val && val->Equals(aValue, aCaseSensitive);
+  }
+
+  struct InternalAttr {
+    nsAttrName mName;
+    nsAttrValue mValue;
+  };
+
+ private:
+  AttrArray(const AttrArray& aOther) = delete;
+  AttrArray& operator=(const AttrArray& aOther) = delete;
+
+  uint32_t NonMappedAttrCount() const { return mImpl ? mImpl->mAttrCount : 0; }
+
+  uint32_t MappedAttrCount() const {
+    return mImpl && mImpl->mMappedAttrs ? DoGetMappedAttrCount() : 0;
+  }
+
+  uint32_t DoGetMappedAttrCount() const;
+
+  // Returns a non-null zero-refcount object.
+  nsMappedAttributes* GetModifiableMapped(nsMappedAttributeElement* aContent,
+                                          nsHTMLStyleSheet* aSheet,
+                                          bool aWillAddAttr,
+                                          int32_t aAttrCount = 1);
+  nsresult MakeMappedUnique(nsMappedAttributes* aAttributes);
+
+  bool GrowBy(uint32_t aGrowSize);
+
+  // Tries to create an attribute, growing the buffer if needed, with the given
+  // name and value.
+  //
+  // The value is moved from the argument.
+  //
+  // `Name` can be anything you construct a `nsAttrName` with (either an atom or
+  // a NodeInfo pointer).
+  template <typename Name>
+  nsresult AddNewAttribute(Name*, nsAttrValue&);
+
+  /**
+   * Guts of SetMappedAttrStyleSheet for the rare case when we have mapped attrs
+   */
+  nsresult DoSetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet);
+
+  /**
+   * Guts of UpdateMappedAttrRuleMapper for the case  when we have mapped attrs.
+   */
+  nsresult DoUpdateMappedAttrRuleMapper(nsMappedAttributeElement& aElement);
+
+#ifdef _MSC_VER
+// Disable MSVC warning 'nonstandard extension used: zero-sized array in
+// struct/union'
+#  pragma warning(push)
+#  pragma warning(disable : 4200)
+#endif
+  class Impl {
+   public:
+    constexpr static size_t AllocationSizeForAttributes(uint32_t aAttrCount) {
+      return sizeof(Impl) + aAttrCount * sizeof(InternalAttr);
+    }
+
+    auto NonMappedAttrs() const {
+      return mozilla::Span<const InternalAttr>{mBuffer, mAttrCount};
+    }
+
+    auto NonMappedAttrs() {
+      return mozilla::Span<InternalAttr>{mBuffer, mAttrCount};
+    }
+
+    Impl(const Impl&) = delete;
+    Impl(Impl&&) = delete;
+    ~Impl();
+
+    uint32_t mAttrCount;
+    uint32_t mCapacity;  // In number of InternalAttrs
+
+    // Manually refcounted.
+    nsMappedAttributes* mMappedAttrs;
+
+    // Allocated in the same buffer as `Impl`.
+    InternalAttr mBuffer[0];
+  };
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+  mozilla::Span<InternalAttr> NonMappedAttrs() {
+    return mImpl ? mImpl->NonMappedAttrs() : mozilla::Span<InternalAttr>();
+  }
+
+  mozilla::Span<const InternalAttr> NonMappedAttrs() const {
+    return mImpl ? mImpl->NonMappedAttrs()
+                 : mozilla::Span<const InternalAttr>();
+  }
+
+  mozilla::UniquePtr<Impl> mImpl;
+};
+
+#endif