From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- dom/base/nsDOMAttributeMap.h | 176 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 dom/base/nsDOMAttributeMap.h (limited to 'dom/base/nsDOMAttributeMap.h') diff --git a/dom/base/nsDOMAttributeMap.h b/dom/base/nsDOMAttributeMap.h new file mode 100644 index 0000000000..5ed1e96544 --- /dev/null +++ b/dom/base/nsDOMAttributeMap.h @@ -0,0 +1,176 @@ +/* -*- 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/. */ + +/* + * Implementation of the |attributes| property of DOM Core's Element object. + */ + +#ifndef nsDOMAttributeMap_h +#define nsDOMAttributeMap_h + +#include "mozilla/MemoryReporting.h" +#include "nsCycleCollectionParticipant.h" +#include "nsRefPtrHashtable.h" +#include "nsString.h" +#include "nsWrapperCache.h" + +class nsAtom; +class nsINode; + +namespace mozilla { +class ErrorResult; + +namespace dom { +class Attr; +class DocGroup; +class Document; +class Element; +class NodeInfo; +} // namespace dom +} // namespace mozilla + +/** + * Structure used as a key for caching Attrs in nsDOMAttributeMap's + * mAttributeCache. + */ +class nsAttrKey { + public: + /** + * The namespace of the attribute + */ + int32_t mNamespaceID; + + /** + * The atom for attribute, stored as void*, to make sure that we only use it + * for the hashcode, and we can never dereference it. + */ + void* mLocalName; + + nsAttrKey(int32_t aNs, nsAtom* aName) + : mNamespaceID(aNs), mLocalName(aName) {} + + nsAttrKey(const nsAttrKey& aAttr) = default; +}; + +/** + * PLDHashEntryHdr implementation for nsAttrKey. + */ +class nsAttrHashKey : public PLDHashEntryHdr { + public: + using KeyType = const nsAttrKey&; + using KeyTypePointer = const nsAttrKey*; + + explicit nsAttrHashKey(KeyTypePointer aKey) : mKey(*aKey) {} + nsAttrHashKey(const nsAttrHashKey& aCopy) + : PLDHashEntryHdr{}, mKey(aCopy.mKey) {} + ~nsAttrHashKey() = default; + + KeyType GetKey() const { return mKey; } + bool KeyEquals(KeyTypePointer aKey) const { + return mKey.mLocalName == aKey->mLocalName && + mKey.mNamespaceID == aKey->mNamespaceID; + } + + static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; } + static PLDHashNumber HashKey(KeyTypePointer aKey) { + if (!aKey) return 0; + + return mozilla::HashGeneric(aKey->mNamespaceID, aKey->mLocalName); + } + enum { ALLOW_MEMMOVE = true }; + + private: + nsAttrKey mKey; +}; + +class nsDOMAttributeMap final : public nsISupports, public nsWrapperCache { + public: + using Attr = mozilla::dom::Attr; + using DocGroup = mozilla::dom::DocGroup; + using Document = mozilla::dom::Document; + using Element = mozilla::dom::Element; + using ErrorResult = mozilla::ErrorResult; + + explicit nsDOMAttributeMap(Element* aContent); + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS(nsDOMAttributeMap) + + void DropReference(); + + Element* GetContent() { return mContent; } + + /** + * Called when mContent is moved into a new document. + * Updates the nodeinfos of all owned nodes. + */ + nsresult SetOwnerDocument(Document* aDocument); + + /** + * Drop an attribute from the map's cache (does not remove the attribute + * from the node!) + */ + void DropAttribute(int32_t aNamespaceID, nsAtom* aLocalName); + + /** + * Returns the number of attribute nodes currently in the map. + * Note: this is just the number of cached attribute nodes, not the number of + * attributes in mContent. + * + * @return The number of attribute nodes in the map. + */ + uint32_t Count() const; + + using AttrCache = nsRefPtrHashtable; + + static void BlastSubtreeToPieces(nsINode* aNode); + + Element* GetParentObject() const { return mContent; } + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + DocGroup* GetDocGroup() const; + + // WebIDL + Attr* GetNamedItem(const nsAString& aAttrName); + Attr* NamedGetter(const nsAString& aAttrName, bool& aFound); + already_AddRefed RemoveNamedItem(mozilla::dom::NodeInfo* aNodeInfo, + ErrorResult& aError); + already_AddRefed RemoveNamedItem(const nsAString& aName, + ErrorResult& aError); + + Attr* Item(uint32_t aIndex); + Attr* IndexedGetter(uint32_t aIndex, bool& aFound); + uint32_t Length() const; + + Attr* GetNamedItemNS(const nsAString& aNamespaceURI, + const nsAString& aLocalName); + already_AddRefed SetNamedItemNS(Attr& aNode, ErrorResult& aError); + already_AddRefed RemoveNamedItemNS(const nsAString& aNamespaceURI, + const nsAString& aLocalName, + ErrorResult& aError); + + void GetSupportedNames(nsTArray& aNames); + + size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; + + protected: + virtual ~nsDOMAttributeMap(); + + private: + nsCOMPtr mContent; + + /** + * Cache of Attrs. + */ + AttrCache mAttributeCache; + + already_AddRefed GetAttrNodeInfo( + const nsAString& aNamespaceURI, const nsAString& aLocalName); + + Attr* GetAttribute(mozilla::dom::NodeInfo* aNodeInfo); +}; + +#endif /* nsDOMAttributeMap_h */ -- cgit v1.2.3