/* -*- 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/. */ /* * nsBaseContentList is a basic list of content nodes; nsContentList * is a commonly used NodeList implementation (used for * getElementsByTagName, some properties on HTMLDocument/Document, etc). */ #ifndef nsContentList_h___ #define nsContentList_h___ #include "mozilla/Attributes.h" #include "nsContentListDeclarations.h" #include "nsISupports.h" #include "nsTArray.h" #include "nsString.h" #include "nsIHTMLCollection.h" #include "nsINodeList.h" #include "nsStubMutationObserver.h" #include "nsAtom.h" #include "nsCycleCollectionParticipant.h" #include "nsNameSpaceManager.h" #include "nsWrapperCache.h" #include "nsHashKeys.h" #include "mozilla/HashFunctions.h" #include "mozilla/MemoryReporting.h" #include "mozilla/dom/NameSpaceConstants.h" namespace mozilla { namespace dom { class Element; } // namespace dom } // namespace mozilla class nsBaseContentList : public nsINodeList { public: NS_DECL_CYCLE_COLLECTING_ISUPPORTS // nsINodeList virtual int32_t IndexOf(nsIContent* aContent) override; virtual nsIContent* Item(uint32_t aIndex) override; uint32_t Length() override { return mElements.Length(); } NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS(nsBaseContentList) void AppendElement(nsIContent* aContent) { mElements.AppendElement(aContent); } void MaybeAppendElement(nsIContent* aContent) { if (aContent) AppendElement(aContent); } /** * Insert the element at a given index, shifting the objects at * the given index and later to make space. * @param aContent Element to insert, must not be null * @param aIndex Index to insert the element at. */ void InsertElementAt(nsIContent* aContent, int32_t aIndex) { NS_ASSERTION(aContent, "Element to insert must not be null"); mElements.InsertElementAt(aIndex, aContent); } void RemoveElement(nsIContent* aContent) { mElements.RemoveElement(aContent); } void Reset() { mElements.Clear(); } virtual int32_t IndexOf(nsIContent* aContent, bool aDoFlush); virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override = 0; void SetCapacity(uint32_t aCapacity) { mElements.SetCapacity(aCapacity); } virtual void LastRelease() {} // Memory reporting. For now, subclasses of nsBaseContentList don't really // need to report any members that are not part of the object itself, so we // don't need to make this virtual. size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; protected: virtual ~nsBaseContentList(); /** * To be called from non-destructor locations (e.g. unlink) that want to * remove from caches. Cacheable subclasses should override. */ virtual void RemoveFromCaches() {} AutoTArray, 10> mElements; }; class nsSimpleContentList : public nsBaseContentList { public: explicit nsSimpleContentList(nsINode* aRoot) : nsBaseContentList(), mRoot(aRoot) {} NS_DECL_ISUPPORTS_INHERITED NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsSimpleContentList, nsBaseContentList) virtual nsINode* GetParentObject() override { return mRoot; } virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override; protected: virtual ~nsSimpleContentList() {} private: // This has to be a strong reference, the root might go away before the list. nsCOMPtr mRoot; }; // Used for returning lists that will always be empty, such as the applets list // in HTML Documents class nsEmptyContentList final : public nsBaseContentList, public nsIHTMLCollection { public: explicit nsEmptyContentList(nsINode* aRoot) : nsBaseContentList(), mRoot(aRoot) {} NS_DECL_ISUPPORTS_INHERITED NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsEmptyContentList, nsBaseContentList) virtual nsINode* GetParentObject() override { return mRoot; } virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override; virtual JSObject* GetWrapperPreserveColorInternal() override { return nsWrapperCache::GetWrapperPreserveColor(); } virtual void PreserveWrapperInternal( nsISupports* aScriptObjectHolder) override { nsWrapperCache::PreserveWrapper(aScriptObjectHolder); } uint32_t Length() final { return 0; } virtual nsIContent* Item(uint32_t aIndex) override; virtual mozilla::dom::Element* GetElementAt(uint32_t index) override; virtual mozilla::dom::Element* GetFirstNamedElement(const nsAString& aName, bool& aFound) override; virtual void GetSupportedNames(nsTArray& aNames) override; protected: virtual ~nsEmptyContentList() {} private: // This has to be a strong reference, the root might go away before the list. nsCOMPtr mRoot; }; /** * Class that's used as the key to hash nsContentList implementations * for fast retrieval */ struct nsContentListKey { // We have to take an aIsHTMLDocument arg for two reasons: // 1) We don't want to include Document.h in this header. // 2) We need to do that to make nsContentList::RemoveFromHashtable // work, because by the time it's called the document of the // list's root node might have changed. nsContentListKey(nsINode* aRootNode, int32_t aMatchNameSpaceId, const nsAString& aTagname, bool aIsHTMLDocument) : mRootNode(aRootNode), mMatchNameSpaceId(aMatchNameSpaceId), mTagname(aTagname), mIsHTMLDocument(aIsHTMLDocument), mHash(mozilla::AddToHash(mozilla::HashString(aTagname), mRootNode, mMatchNameSpaceId, mIsHTMLDocument)) {} nsContentListKey(const nsContentListKey& aContentListKey) : mRootNode(aContentListKey.mRootNode), mMatchNameSpaceId(aContentListKey.mMatchNameSpaceId), mTagname(aContentListKey.mTagname), mIsHTMLDocument(aContentListKey.mIsHTMLDocument), mHash(aContentListKey.mHash) {} inline uint32_t GetHash(void) const { return mHash; } nsINode* const mRootNode; // Weak ref const int32_t mMatchNameSpaceId; const nsAString& mTagname; bool mIsHTMLDocument; const uint32_t mHash; }; /** * LIST_UP_TO_DATE means that the list is up to date and need not do * any walking to be able to answer any questions anyone may have. */ #define LIST_UP_TO_DATE 0 /** * LIST_DIRTY means that the list contains no useful information and * if anyone asks it anything it will have to populate itself before * answering. */ #define LIST_DIRTY 1 /** * LIST_LAZY means that the list has populated itself to a certain * extent and that that part of the list is still valid. Requests for * things outside that part of the list will require walking the tree * some more. When a list is in this state, the last thing in * mElements is the last node in the tree that the list looked at. */ #define LIST_LAZY 2 /** * Class that implements a possibly live NodeList that matches Elements * in the tree based on some criterion. */ class nsContentList : public nsBaseContentList, public nsIHTMLCollection, public nsStubMutationObserver { public: NS_DECL_ISUPPORTS_INHERITED /** * @param aRootNode The node under which to limit our search. * @param aMatchAtom An atom whose meaning depends on aMatchNameSpaceId. * The special value "*" always matches whatever aMatchAtom * is matched against. * @param aMatchNameSpaceId If kNameSpaceID_Unknown, then aMatchAtom is the * tagName to match. * If kNameSpaceID_Wildcard, then aMatchAtom is the * localName to match. * Otherwise we match nodes whose namespace is * aMatchNameSpaceId and localName matches * aMatchAtom. * @param aDeep If false, then look only at children of the root, nothing * deeper. If true, then look at the whole subtree rooted at * our root. * @param aLiveList Whether the created list should be a live list observing * mutations to the DOM tree. */ nsContentList(nsINode* aRootNode, int32_t aMatchNameSpaceId, nsAtom* aHTMLMatchAtom, nsAtom* aXMLMatchAtom, bool aDeep = true, bool aLiveList = true); /** * @param aRootNode The node under which to limit our search. * @param aFunc the function to be called to determine whether we match. * This function MUST NOT ever cause mutation of the DOM. * The nsContentList implementation guarantees that everything * passed to the function will be IsElement(). * @param aDestroyFunc the function that will be called to destroy aData * @param aData closure data that will need to be passed back to aFunc * @param aDeep If false, then look only at children of the root, nothing * deeper. If true, then look at the whole subtree rooted at * our root. * @param aMatchAtom an atom to be passed back to aFunc * @param aMatchNameSpaceId a namespace id to be passed back to aFunc * @param aFuncMayDependOnAttr a boolean that indicates whether this list is * sensitive to attribute changes. * @param aLiveList Whether the created list should be a live list observing * mutations to the DOM tree. */ nsContentList(nsINode* aRootNode, nsContentListMatchFunc aFunc, nsContentListDestroyFunc aDestroyFunc, void* aData, bool aDeep = true, nsAtom* aMatchAtom = nullptr, int32_t aMatchNameSpaceId = kNameSpaceID_None, bool aFuncMayDependOnAttr = true, bool aLiveList = true); // nsWrapperCache using nsWrapperCache::GetWrapperPreserveColor; using nsWrapperCache::PreserveWrapper; virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; protected: virtual ~nsContentList(); virtual JSObject* GetWrapperPreserveColorInternal() override { return nsWrapperCache::GetWrapperPreserveColor(); } virtual void PreserveWrapperInternal( nsISupports* aScriptObjectHolder) override { nsWrapperCache::PreserveWrapper(aScriptObjectHolder); } public: // nsBaseContentList overrides virtual int32_t IndexOf(nsIContent* aContent, bool aDoFlush) override; virtual int32_t IndexOf(nsIContent* aContent) override; virtual nsINode* GetParentObject() override { return mRootNode; } uint32_t Length() final { return Length(true); } nsIContent* Item(uint32_t aIndex) final; virtual mozilla::dom::Element* GetElementAt(uint32_t index) override; virtual mozilla::dom::Element* GetFirstNamedElement(const nsAString& aName, bool& aFound) override { mozilla::dom::Element* item = NamedItem(aName, true); aFound = !!item; return item; } virtual void GetSupportedNames(nsTArray& aNames) override; // nsContentList public methods uint32_t Length(bool aDoFlush); nsIContent* Item(uint32_t aIndex, bool aDoFlush); mozilla::dom::Element* NamedItem(const nsAString& aName, bool aDoFlush); // nsIMutationObserver NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED static nsContentList* FromSupports(nsISupports* aSupports) { nsINodeList* list = static_cast(aSupports); #ifdef DEBUG { nsCOMPtr list_qi = do_QueryInterface(aSupports); // If this assertion fires the QI implementation for the object in // question doesn't use the nsINodeList pointer as the nsISupports // pointer. That must be fixed, or we'll crash... NS_ASSERTION(list_qi == list, "Uh, fix QI!"); } #endif return static_cast(list); } bool MatchesKey(const nsContentListKey& aKey) const { // The root node is most commonly the same: the document. And the // most common namespace id is kNameSpaceID_Unknown. So check the // string first. Cases in which whether our root's ownerDocument // is HTML changes are extremely rare, so check those last. MOZ_ASSERT(mXMLMatchAtom, "How did we get here with a null match atom on our list?"); return mXMLMatchAtom->Equals(aKey.mTagname) && mRootNode == aKey.mRootNode && mMatchNameSpaceId == aKey.mMatchNameSpaceId && mIsHTMLDocument == aKey.mIsHTMLDocument; } /** * Sets the state to LIST_DIRTY and clears mElements array. * @note This is the only acceptable way to set state to LIST_DIRTY. */ void SetDirty() { mState = LIST_DIRTY; Reset(); } virtual void LastRelease() override; protected: /** * Returns whether the element matches our criterion * * @param aElement the element to attempt to match * @return whether we match */ bool Match(mozilla::dom::Element* aElement); /** * See if anything in the subtree rooted at aContent, including * aContent itself, matches our criterion. * * @param aContent the root of the subtree to match against * @return whether we match something in the tree rooted at aContent */ bool MatchSelf(nsIContent* aContent); /** * Populate our list. Stop once we have at least aNeededLength * elements. At the end of PopulateSelf running, either the last * node we examined is the last node in our array or we have * traversed the whole document (or both). * * @param aNeededLength the length the list should have when we are * done (unless it exhausts the document) * @param aExpectedElementsIfDirty is for debugging only to * assert that mElements has expected number of entries. */ virtual void PopulateSelf(uint32_t aNeededLength, uint32_t aExpectedElementsIfDirty = 0); /** * @param aContainer a content node which must be a descendant of * mRootNode * @return true if children or descendants of aContainer could match our * criterion. * false otherwise. */ bool MayContainRelevantNodes(nsINode* aContainer) { return mDeep || aContainer == mRootNode; } /** * Remove ourselves from the hashtable that caches commonly accessed * content lists. Generally done on destruction. */ void RemoveFromHashtable(); /** * If state is not LIST_UP_TO_DATE, fully populate ourselves with * all the nodes we can find. */ inline void BringSelfUpToDate(bool aDoFlush); /** * To be called from non-destructor locations that want to remove from caches. * Needed because if subclasses want to have cache behavior they can't just * override RemoveFromHashtable(), since we call that in our destructor. */ virtual void RemoveFromCaches() override { RemoveFromHashtable(); } nsINode* mRootNode; // Weak ref int32_t mMatchNameSpaceId; RefPtr mHTMLMatchAtom; RefPtr mXMLMatchAtom; /** * Function to use to determine whether a piece of content matches * our criterion */ nsContentListMatchFunc mFunc; /** * Cleanup closure data with this. */ nsContentListDestroyFunc mDestroyFunc; /** * Closure data to pass to mFunc when we call it */ void* mData; /** * The current state of the list (possible values are: * LIST_UP_TO_DATE, LIST_LAZY, LIST_DIRTY */ uint8_t mState; // The booleans have to use uint8_t to pack with mState, because MSVC won't // pack different typedefs together. Once we no longer have to worry about // flushes in XML documents, we can go back to using bool for the // booleans. /** * True if we are looking for elements named "*" */ uint8_t mMatchAll : 1; /** * Whether to actually descend the tree. If this is false, we won't * consider grandkids of mRootNode. */ uint8_t mDeep : 1; /** * Whether the return value of mFunc could depend on the values of * attributes. */ uint8_t mFuncMayDependOnAttr : 1; /** * Whether we actually need to flush to get our state correct. */ uint8_t mFlushesNeeded : 1; /** * Whether the ownerDocument of our root node at list creation time was an * HTML document. Only needed when we're doing a namespace/atom match, not * when doing function matching, always false otherwise. */ uint8_t mIsHTMLDocument : 1; /** * Whether the list observes mutations to the DOM tree. */ const uint8_t mIsLiveList : 1; #ifdef DEBUG_CONTENT_LIST void AssertInSync(); #endif }; /** * A class of cacheable content list; cached on the combination of aRootNode + * aFunc + aDataString */ class nsCacheableFuncStringContentList; class MOZ_STACK_CLASS nsFuncStringCacheKey { public: nsFuncStringCacheKey(nsINode* aRootNode, nsContentListMatchFunc aFunc, const nsAString& aString) : mRootNode(aRootNode), mFunc(aFunc), mString(aString) {} uint32_t GetHash(void) const { uint32_t hash = mozilla::HashString(mString); return mozilla::AddToHash(hash, mRootNode, mFunc); } private: friend class nsCacheableFuncStringContentList; nsINode* const mRootNode; const nsContentListMatchFunc mFunc; const nsAString& mString; }; // aDestroyFunc is allowed to be null // aDataAllocator must always return a non-null pointer class nsCacheableFuncStringContentList : public nsContentList { public: virtual ~nsCacheableFuncStringContentList(); bool Equals(const nsFuncStringCacheKey* aKey) { return mRootNode == aKey->mRootNode && mFunc == aKey->mFunc && mString == aKey->mString; } enum ContentListType { eNodeList, eHTMLCollection }; #ifdef DEBUG ContentListType mType; #endif protected: nsCacheableFuncStringContentList( nsINode* aRootNode, nsContentListMatchFunc aFunc, nsContentListDestroyFunc aDestroyFunc, nsFuncStringContentListDataAllocator aDataAllocator, const nsAString& aString, mozilla::DebugOnly aType) : nsContentList(aRootNode, aFunc, aDestroyFunc, nullptr), #ifdef DEBUG mType(aType), #endif mString(aString) { mData = (*aDataAllocator)(aRootNode, &mString); MOZ_ASSERT(mData); } virtual void RemoveFromCaches() override { RemoveFromFuncStringHashtable(); } void RemoveFromFuncStringHashtable(); nsString mString; }; class nsCachableElementsByNameNodeList : public nsCacheableFuncStringContentList { public: nsCachableElementsByNameNodeList( nsINode* aRootNode, nsContentListMatchFunc aFunc, nsContentListDestroyFunc aDestroyFunc, nsFuncStringContentListDataAllocator aDataAllocator, const nsAString& aString) : nsCacheableFuncStringContentList(aRootNode, aFunc, aDestroyFunc, aDataAllocator, aString, eNodeList) {} NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override; #ifdef DEBUG static const ContentListType sType; #endif }; class nsCacheableFuncStringHTMLCollection : public nsCacheableFuncStringContentList { public: nsCacheableFuncStringHTMLCollection( nsINode* aRootNode, nsContentListMatchFunc aFunc, nsContentListDestroyFunc aDestroyFunc, nsFuncStringContentListDataAllocator aDataAllocator, const nsAString& aString) : nsCacheableFuncStringContentList(aRootNode, aFunc, aDestroyFunc, aDataAllocator, aString, eHTMLCollection) {} virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override; #ifdef DEBUG static const ContentListType sType; #endif }; class nsLabelsNodeList final : public nsContentList { public: nsLabelsNodeList(nsINode* aRootNode, nsContentListMatchFunc aFunc, nsContentListDestroyFunc aDestroyFunc, void* aData) : nsContentList(aRootNode, aFunc, aDestroyFunc, aData) {} NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED virtual JSObject* WrapObject(JSContext* cx, JS::Handle aGivenProto) override; /** * Reset root, mutation observer, and clear content list * if the root has been changed. * * @param aRootNode The node under which to limit our search. */ void MaybeResetRoot(nsINode* aRootNode); private: /** * Start searching at the last one if we already have nodes, otherwise * start searching at the root. * * @param aNeededLength The list of length should have when we are * done (unless it exhausts the document). * @param aExpectedElementsIfDirty is for debugging only to * assert that mElements has expected number of entries. */ void PopulateSelf(uint32_t aNeededLength, uint32_t aExpectedElementsIfDirty = 0) override; }; #endif // nsContentList_h___