summaryrefslogtreecommitdiffstats
path: root/dom/base/nsContentList.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/nsContentList.cpp')
-rw-r--r--dom/base/nsContentList.cpp1181
1 files changed, 1181 insertions, 0 deletions
diff --git a/dom/base/nsContentList.cpp b/dom/base/nsContentList.cpp
new file mode 100644
index 0000000000..de8fb46d89
--- /dev/null
+++ b/dom/base/nsContentList.cpp
@@ -0,0 +1,1181 @@
+/* -*- 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).
+ */
+
+#include "nsContentList.h"
+#include "nsIContent.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/ContentIterator.h"
+#include "mozilla/dom/Element.h"
+#include "nsWrapperCacheInlines.h"
+#include "nsContentUtils.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsGkAtoms.h"
+#include "mozilla/dom/HTMLCollectionBinding.h"
+#include "mozilla/dom/NodeListBinding.h"
+#include "mozilla/Likely.h"
+#include "nsGenericHTMLElement.h"
+#include "jsfriendapi.h"
+#include <algorithm>
+#include "mozilla/dom/NodeInfoInlines.h"
+#include "mozilla/MruCache.h"
+#include "mozilla/StaticPtr.h"
+
+#include "PLDHashTable.h"
+#include "nsTHashtable.h"
+
+#ifdef DEBUG_CONTENT_LIST
+# define ASSERT_IN_SYNC AssertInSync()
+#else
+# define ASSERT_IN_SYNC PR_BEGIN_MACRO PR_END_MACRO
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+nsBaseContentList::~nsBaseContentList() = default;
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(nsBaseContentList)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsBaseContentList)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mElements)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->RemoveFromCaches();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsBaseContentList)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mElements)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsBaseContentList)
+ if (nsCCUncollectableMarker::sGeneration && tmp->HasKnownLiveWrapper()) {
+ for (uint32_t i = 0; i < tmp->mElements.Length(); ++i) {
+ nsIContent* c = tmp->mElements[i];
+ if (c->IsPurple()) {
+ c->RemovePurple();
+ }
+ Element::MarkNodeChildren(c);
+ }
+ return true;
+ }
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsBaseContentList)
+ return nsCCUncollectableMarker::sGeneration && tmp->HasKnownLiveWrapper();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsBaseContentList)
+ return nsCCUncollectableMarker::sGeneration && tmp->HasKnownLiveWrapper();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
+
+// QueryInterface implementation for nsBaseContentList
+NS_INTERFACE_TABLE_HEAD(nsBaseContentList)
+ NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY
+ NS_INTERFACE_TABLE(nsBaseContentList, nsINodeList)
+ NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsBaseContentList)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsBaseContentList)
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(nsBaseContentList,
+ LastRelease())
+
+nsIContent* nsBaseContentList::Item(uint32_t aIndex) {
+ return mElements.SafeElementAt(aIndex);
+}
+
+int32_t nsBaseContentList::IndexOf(nsIContent* aContent, bool aDoFlush) {
+ return mElements.IndexOf(aContent);
+}
+
+int32_t nsBaseContentList::IndexOf(nsIContent* aContent) {
+ return IndexOf(aContent, true);
+}
+
+size_t nsBaseContentList::SizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+ n += mElements.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ return n;
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(nsSimpleContentList, nsBaseContentList,
+ mRoot)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsSimpleContentList)
+NS_INTERFACE_MAP_END_INHERITING(nsBaseContentList)
+
+NS_IMPL_ADDREF_INHERITED(nsSimpleContentList, nsBaseContentList)
+NS_IMPL_RELEASE_INHERITED(nsSimpleContentList, nsBaseContentList)
+
+JSObject* nsSimpleContentList::WrapObject(JSContext* cx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return NodeList_Binding::Wrap(cx, this, aGivenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(nsEmptyContentList, nsBaseContentList, mRoot)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsEmptyContentList)
+ NS_INTERFACE_MAP_ENTRY(nsIHTMLCollection)
+NS_INTERFACE_MAP_END_INHERITING(nsBaseContentList)
+
+NS_IMPL_ADDREF_INHERITED(nsEmptyContentList, nsBaseContentList)
+NS_IMPL_RELEASE_INHERITED(nsEmptyContentList, nsBaseContentList)
+
+JSObject* nsEmptyContentList::WrapObject(JSContext* cx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return HTMLCollection_Binding::Wrap(cx, this, aGivenProto);
+}
+
+mozilla::dom::Element* nsEmptyContentList::GetElementAt(uint32_t index) {
+ return nullptr;
+}
+
+mozilla::dom::Element* nsEmptyContentList::GetFirstNamedElement(
+ const nsAString& aName, bool& aFound) {
+ aFound = false;
+ return nullptr;
+}
+
+void nsEmptyContentList::GetSupportedNames(nsTArray<nsString>& aNames) {}
+
+nsIContent* nsEmptyContentList::Item(uint32_t aIndex) { return nullptr; }
+
+struct ContentListCache
+ : public MruCache<nsContentListKey, nsContentList*, ContentListCache> {
+ static HashNumber Hash(const nsContentListKey& aKey) {
+ return aKey.GetHash();
+ }
+ static bool Match(const nsContentListKey& aKey, const nsContentList* aVal) {
+ return aVal->MatchesKey(aKey);
+ }
+};
+
+static ContentListCache sRecentlyUsedContentLists;
+
+class nsContentList::HashEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = const nsContentListKey*;
+ using KeyTypePointer = KeyType;
+
+ // Note that this is creating a blank entry, so you'll have to manually
+ // initialize it after it has been inserted into the hash table.
+ explicit HashEntry(KeyTypePointer aKey) : mContentList(nullptr) {}
+
+ HashEntry(HashEntry&& aEnt) : mContentList(std::move(aEnt.mContentList)) {}
+
+ ~HashEntry() {
+ if (mContentList) {
+ MOZ_RELEASE_ASSERT(mContentList->mInHashtable);
+ mContentList->mInHashtable = false;
+ }
+ }
+
+ bool KeyEquals(KeyTypePointer aKey) const {
+ return mContentList->MatchesKey(*aKey);
+ }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+
+ static PLDHashNumber HashKey(KeyTypePointer aKey) { return aKey->GetHash(); }
+
+ nsContentList* GetContentList() const { return mContentList; }
+ void SetContentList(nsContentList* aContentList) {
+ MOZ_RELEASE_ASSERT(!mContentList);
+ MOZ_ASSERT(aContentList);
+ MOZ_RELEASE_ASSERT(!aContentList->mInHashtable);
+ mContentList = aContentList;
+ mContentList->mInHashtable = true;
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ nsContentList* MOZ_UNSAFE_REF(
+ "This entry will be removed in nsContentList::RemoveFromHashtable "
+ "before mContentList is destroyed") mContentList;
+};
+
+// Hashtable for storing nsContentLists
+static StaticAutoPtr<nsTHashtable<nsContentList::HashEntry>>
+ gContentListHashTable;
+
+already_AddRefed<nsContentList> NS_GetContentList(nsINode* aRootNode,
+ int32_t aMatchNameSpaceId,
+ const nsAString& aTagname) {
+ NS_ASSERTION(aRootNode, "content list has to have a root");
+
+ RefPtr<nsContentList> list;
+ nsContentListKey hashKey(aRootNode, aMatchNameSpaceId, aTagname,
+ aRootNode->OwnerDoc()->IsHTMLDocument());
+ auto p = sRecentlyUsedContentLists.Lookup(hashKey);
+ if (p) {
+ list = p.Data();
+ return list.forget();
+ }
+
+ // Initialize the hashtable if needed.
+ if (!gContentListHashTable) {
+ gContentListHashTable = new nsTHashtable<nsContentList::HashEntry>();
+ }
+
+ // First we look in our hashtable. Then we create a content list if needed
+ auto entry = gContentListHashTable->PutEntry(&hashKey, fallible);
+ if (entry) {
+ list = entry->GetContentList();
+ }
+
+ if (!list) {
+ // We need to create a ContentList and add it to our new entry, if
+ // we have an entry
+ RefPtr<nsAtom> xmlAtom = NS_Atomize(aTagname);
+ RefPtr<nsAtom> htmlAtom;
+ if (aMatchNameSpaceId == kNameSpaceID_Unknown) {
+ nsAutoString lowercaseName;
+ nsContentUtils::ASCIIToLower(aTagname, lowercaseName);
+ htmlAtom = NS_Atomize(lowercaseName);
+ } else {
+ htmlAtom = xmlAtom;
+ }
+ list = new nsContentList(aRootNode, aMatchNameSpaceId, htmlAtom, xmlAtom);
+ if (entry) {
+ entry->SetContentList(list);
+ }
+ }
+
+ p.Set(list);
+ return list.forget();
+}
+
+#ifdef DEBUG
+const nsCacheableFuncStringContentList::ContentListType
+ nsCachableElementsByNameNodeList::sType =
+ nsCacheableFuncStringContentList::eNodeList;
+const nsCacheableFuncStringContentList::ContentListType
+ nsCacheableFuncStringHTMLCollection::sType =
+ nsCacheableFuncStringContentList::eHTMLCollection;
+#endif
+
+class nsCacheableFuncStringContentList::HashEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = const nsFuncStringCacheKey*;
+ using KeyTypePointer = KeyType;
+
+ // Note that this is creating a blank entry, so you'll have to manually
+ // initialize it after it has been inserted into the hash table.
+ explicit HashEntry(KeyTypePointer aKey) : mContentList(nullptr) {}
+
+ HashEntry(HashEntry&& aEnt) : mContentList(std::move(aEnt.mContentList)) {}
+
+ ~HashEntry() {
+ if (mContentList) {
+ MOZ_RELEASE_ASSERT(mContentList->mInHashtable);
+ mContentList->mInHashtable = false;
+ }
+ }
+
+ bool KeyEquals(KeyTypePointer aKey) const {
+ return mContentList->Equals(aKey);
+ }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+
+ static PLDHashNumber HashKey(KeyTypePointer aKey) { return aKey->GetHash(); }
+
+ nsCacheableFuncStringContentList* GetContentList() const {
+ return mContentList;
+ }
+ void SetContentList(nsCacheableFuncStringContentList* aContentList) {
+ MOZ_RELEASE_ASSERT(!mContentList);
+ MOZ_ASSERT(aContentList);
+ MOZ_RELEASE_ASSERT(!aContentList->mInHashtable);
+ mContentList = aContentList;
+ mContentList->mInHashtable = true;
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ nsCacheableFuncStringContentList* MOZ_UNSAFE_REF(
+ "This entry will be removed in "
+ "nsCacheableFuncStringContentList::RemoveFromFuncStringHashtable "
+ "before mContentList is destroyed") mContentList;
+};
+
+// Hashtable for storing nsCacheableFuncStringContentList
+static StaticAutoPtr<nsTHashtable<nsCacheableFuncStringContentList::HashEntry>>
+ gFuncStringContentListHashTable;
+
+template <class ListType>
+already_AddRefed<nsContentList> GetFuncStringContentList(
+ nsINode* aRootNode, nsContentListMatchFunc aFunc,
+ nsContentListDestroyFunc aDestroyFunc,
+ nsFuncStringContentListDataAllocator aDataAllocator,
+ const nsAString& aString) {
+ NS_ASSERTION(aRootNode, "content list has to have a root");
+
+ RefPtr<nsCacheableFuncStringContentList> list;
+
+ // Initialize the hashtable if needed.
+ if (!gFuncStringContentListHashTable) {
+ gFuncStringContentListHashTable =
+ new nsTHashtable<nsCacheableFuncStringContentList::HashEntry>();
+ }
+
+ nsCacheableFuncStringContentList::HashEntry* entry = nullptr;
+ // First we look in our hashtable. Then we create a content list if needed
+ if (gFuncStringContentListHashTable) {
+ nsFuncStringCacheKey hashKey(aRootNode, aFunc, aString);
+
+ entry = gFuncStringContentListHashTable->PutEntry(&hashKey, fallible);
+ if (entry) {
+ list = entry->GetContentList();
+#ifdef DEBUG
+ MOZ_ASSERT_IF(list, list->mType == ListType::sType);
+#endif
+ }
+ }
+
+ if (!list) {
+ // We need to create a ContentList and add it to our new entry, if
+ // we have an entry
+ list =
+ new ListType(aRootNode, aFunc, aDestroyFunc, aDataAllocator, aString);
+ if (entry) {
+ entry->SetContentList(list);
+ }
+ }
+
+ // Don't cache these lists globally
+
+ return list.forget();
+}
+
+// Explicit instantiations to avoid link errors
+template already_AddRefed<nsContentList>
+GetFuncStringContentList<nsCachableElementsByNameNodeList>(
+ nsINode* aRootNode, nsContentListMatchFunc aFunc,
+ nsContentListDestroyFunc aDestroyFunc,
+ nsFuncStringContentListDataAllocator aDataAllocator,
+ const nsAString& aString);
+template already_AddRefed<nsContentList>
+GetFuncStringContentList<nsCacheableFuncStringHTMLCollection>(
+ nsINode* aRootNode, nsContentListMatchFunc aFunc,
+ nsContentListDestroyFunc aDestroyFunc,
+ nsFuncStringContentListDataAllocator aDataAllocator,
+ const nsAString& aString);
+
+//-----------------------------------------------------
+// nsContentList implementation
+
+nsContentList::nsContentList(nsINode* aRootNode, int32_t aMatchNameSpaceId,
+ nsAtom* aHTMLMatchAtom, nsAtom* aXMLMatchAtom,
+ bool aDeep, bool aLiveList)
+ : nsBaseContentList(),
+ mRootNode(aRootNode),
+ mMatchNameSpaceId(aMatchNameSpaceId),
+ mHTMLMatchAtom(aHTMLMatchAtom),
+ mXMLMatchAtom(aXMLMatchAtom),
+ mState(State::Dirty),
+ mDeep(aDeep),
+ mFuncMayDependOnAttr(false),
+ mIsHTMLDocument(aRootNode->OwnerDoc()->IsHTMLDocument()),
+ mNamedItemsCacheValid(false),
+ mIsLiveList(aLiveList),
+ mInHashtable(false) {
+ NS_ASSERTION(mRootNode, "Must have root");
+ if (nsGkAtoms::_asterisk == mHTMLMatchAtom) {
+ NS_ASSERTION(mXMLMatchAtom == nsGkAtoms::_asterisk,
+ "HTML atom and XML atom are not both asterisk?");
+ mMatchAll = true;
+ } else {
+ mMatchAll = false;
+ }
+ // This is aLiveList instead of mIsLiveList to avoid Valgrind errors.
+ if (aLiveList) {
+ SetEnabledCallbacks(nsIMutationObserver::kNodeWillBeDestroyed);
+ mRootNode->AddMutationObserver(this);
+ }
+
+ // We only need to flush if we're in an non-HTML document, since the
+ // HTML5 parser doesn't need flushing. Further, if we're not in a
+ // document at all right now (in the GetUncomposedDoc() sense), we're
+ // not parser-created and don't need to be flushing stuff under us
+ // to get our kids right.
+ Document* doc = mRootNode->GetUncomposedDoc();
+ mFlushesNeeded = doc && !doc->IsHTMLDocument();
+}
+
+nsContentList::nsContentList(nsINode* aRootNode, nsContentListMatchFunc aFunc,
+ nsContentListDestroyFunc aDestroyFunc, void* aData,
+ bool aDeep, nsAtom* aMatchAtom,
+ int32_t aMatchNameSpaceId,
+ bool aFuncMayDependOnAttr, bool aLiveList)
+ : nsBaseContentList(),
+ mRootNode(aRootNode),
+ mMatchNameSpaceId(aMatchNameSpaceId),
+ mHTMLMatchAtom(aMatchAtom),
+ mXMLMatchAtom(aMatchAtom),
+ mFunc(aFunc),
+ mDestroyFunc(aDestroyFunc),
+ mData(aData),
+ mState(State::Dirty),
+ mMatchAll(false),
+ mDeep(aDeep),
+ mFuncMayDependOnAttr(aFuncMayDependOnAttr),
+ mIsHTMLDocument(false),
+ mNamedItemsCacheValid(false),
+ mIsLiveList(aLiveList),
+ mInHashtable(false) {
+ NS_ASSERTION(mRootNode, "Must have root");
+ // This is aLiveList instead of mIsLiveList to avoid Valgrind errors.
+ if (aLiveList) {
+ SetEnabledCallbacks(nsIMutationObserver::kNodeWillBeDestroyed);
+ mRootNode->AddMutationObserver(this);
+ }
+
+ // We only need to flush if we're in an non-HTML document, since the
+ // HTML5 parser doesn't need flushing. Further, if we're not in a
+ // document at all right now (in the GetUncomposedDoc() sense), we're
+ // not parser-created and don't need to be flushing stuff under us
+ // to get our kids right.
+ Document* doc = mRootNode->GetUncomposedDoc();
+ mFlushesNeeded = doc && !doc->IsHTMLDocument();
+}
+
+nsContentList::~nsContentList() {
+ RemoveFromHashtable();
+ if (mIsLiveList && mRootNode) {
+ mRootNode->RemoveMutationObserver(this);
+ }
+
+ if (mDestroyFunc) {
+ // Clean up mData
+ (*mDestroyFunc)(mData);
+ }
+}
+
+JSObject* nsContentList::WrapObject(JSContext* cx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return HTMLCollection_Binding::Wrap(cx, this, aGivenProto);
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsContentList, nsBaseContentList, nsIHTMLCollection,
+ nsIMutationObserver)
+
+uint32_t nsContentList::Length(bool aDoFlush) {
+ BringSelfUpToDate(aDoFlush);
+
+ return mElements.Length();
+}
+
+nsIContent* nsContentList::Item(uint32_t aIndex, bool aDoFlush) {
+ if (mRootNode && aDoFlush && mFlushesNeeded) {
+ // XXX sXBL/XBL2 issue
+ Document* doc = mRootNode->GetUncomposedDoc();
+ if (doc) {
+ // Flush pending content changes Bug 4891.
+ doc->FlushPendingNotifications(FlushType::ContentAndNotify);
+ }
+ }
+
+ if (mState != State::UpToDate) {
+ PopulateSelf(std::min(aIndex, UINT32_MAX - 1) + 1);
+ }
+
+ ASSERT_IN_SYNC;
+ NS_ASSERTION(!mRootNode || mState != State::Dirty,
+ "PopulateSelf left the list in a dirty (useless) state!");
+
+ return mElements.SafeElementAt(aIndex);
+}
+
+inline void nsContentList::InsertElementInNamedItemsCache(
+ nsIContent& aContent) {
+ const bool hasName = aContent.HasName();
+ const bool hasId = aContent.HasID();
+ if (!hasName && !hasId) {
+ return;
+ }
+
+ Element* el = aContent.AsElement();
+ MOZ_ASSERT_IF(hasName, el->IsHTMLElement());
+
+ uint32_t i = 0;
+ while (BorrowedAttrInfo info = el->GetAttrInfoAt(i++)) {
+ const bool valid = (info.mName->Equals(nsGkAtoms::name) && hasName) ||
+ (info.mName->Equals(nsGkAtoms::id) && hasId);
+ if (!valid) {
+ continue;
+ }
+
+ if (!mNamedItemsCache) {
+ mNamedItemsCache = MakeUnique<NamedItemsCache>();
+ }
+
+ nsAtom* name = info.mValue->GetAtomValue();
+ // NOTE: LookupOrInsert makes sure we keep the first element we find for a
+ // given name.
+ mNamedItemsCache->LookupOrInsert(name, el);
+ }
+}
+
+inline void nsContentList::InvalidateNamedItemsCacheForAttributeChange(
+ int32_t aNamespaceID, nsAtom* aAttribute) {
+ if (!mNamedItemsCacheValid) {
+ return;
+ }
+ if ((aAttribute == nsGkAtoms::id || aAttribute == nsGkAtoms::name) &&
+ aNamespaceID == kNameSpaceID_None) {
+ InvalidateNamedItemsCache();
+ }
+}
+
+inline void nsContentList::InvalidateNamedItemsCacheForInsertion(
+ Element& aElement) {
+ if (!mNamedItemsCacheValid) {
+ return;
+ }
+
+ InsertElementInNamedItemsCache(aElement);
+}
+
+inline void nsContentList::InvalidateNamedItemsCacheForDeletion(
+ Element& aElement) {
+ if (!mNamedItemsCacheValid) {
+ return;
+ }
+ if (aElement.HasName() || aElement.HasID()) {
+ InvalidateNamedItemsCache();
+ }
+}
+
+void nsContentList::EnsureNamedItemsCacheValid(bool aDoFlush) {
+ BringSelfUpToDate(aDoFlush);
+
+ if (mNamedItemsCacheValid) {
+ return;
+ }
+
+ MOZ_ASSERT(!mNamedItemsCache);
+
+ // https://dom.spec.whatwg.org/#dom-htmlcollection-nameditem-key
+ // XXX: Blink/WebKit don't follow the spec here, and searches first-by-id,
+ // then by name.
+ for (const nsCOMPtr<nsIContent>& content : mElements) {
+ InsertElementInNamedItemsCache(*content);
+ }
+
+ mNamedItemsCacheValid = true;
+}
+
+Element* nsContentList::NamedItem(const nsAString& aName, bool aDoFlush) {
+ if (aName.IsEmpty()) {
+ return nullptr;
+ }
+
+ EnsureNamedItemsCacheValid(aDoFlush);
+
+ if (!mNamedItemsCache) {
+ return nullptr;
+ }
+
+ // Typically IDs and names are atomized
+ RefPtr<nsAtom> name = NS_Atomize(aName);
+ NS_ENSURE_TRUE(name, nullptr);
+
+ return mNamedItemsCache->Get(name);
+}
+
+void nsContentList::GetSupportedNames(nsTArray<nsString>& aNames) {
+ BringSelfUpToDate(true);
+
+ AutoTArray<nsAtom*, 8> atoms;
+ for (uint32_t i = 0; i < mElements.Length(); ++i) {
+ nsIContent* content = mElements.ElementAt(i);
+ if (content->HasID()) {
+ nsAtom* id = content->GetID();
+ MOZ_ASSERT(id != nsGkAtoms::_empty, "Empty ids don't get atomized");
+ if (!atoms.Contains(id)) {
+ atoms.AppendElement(id);
+ }
+ }
+
+ nsGenericHTMLElement* el = nsGenericHTMLElement::FromNode(content);
+ if (el) {
+ // XXXbz should we be checking for particular tags here? How
+ // stable is this part of the spec?
+ // Note: nsINode::HasName means the name is exposed on the document,
+ // which is false for options, so we don't check it here.
+ const nsAttrValue* val = el->GetParsedAttr(nsGkAtoms::name);
+ if (val && val->Type() == nsAttrValue::eAtom) {
+ nsAtom* name = val->GetAtomValue();
+ MOZ_ASSERT(name != nsGkAtoms::_empty, "Empty names don't get atomized");
+ if (!atoms.Contains(name)) {
+ atoms.AppendElement(name);
+ }
+ }
+ }
+ }
+
+ uint32_t atomsLen = atoms.Length();
+ nsString* names = aNames.AppendElements(atomsLen);
+ for (uint32_t i = 0; i < atomsLen; ++i) {
+ atoms[i]->ToString(names[i]);
+ }
+}
+
+int32_t nsContentList::IndexOf(nsIContent* aContent, bool aDoFlush) {
+ BringSelfUpToDate(aDoFlush);
+
+ return mElements.IndexOf(aContent);
+}
+
+int32_t nsContentList::IndexOf(nsIContent* aContent) {
+ return IndexOf(aContent, true);
+}
+
+void nsContentList::NodeWillBeDestroyed(nsINode* aNode) {
+ // We shouldn't do anything useful from now on
+
+ RemoveFromCaches();
+ mRootNode = nullptr;
+
+ // We will get no more updates, so we can never know we're up to
+ // date
+ SetDirty();
+}
+
+void nsContentList::LastRelease() {
+ RemoveFromCaches();
+ if (mIsLiveList && mRootNode) {
+ mRootNode->RemoveMutationObserver(this);
+ mRootNode = nullptr;
+ }
+ SetDirty();
+}
+
+Element* nsContentList::GetElementAt(uint32_t aIndex) {
+ return static_cast<Element*>(Item(aIndex, true));
+}
+
+nsIContent* nsContentList::Item(uint32_t aIndex) {
+ return GetElementAt(aIndex);
+}
+
+void nsContentList::AttributeChanged(Element* aElement, int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ MOZ_ASSERT(aElement, "Must have a content node to work with");
+
+ if (mState == State::Dirty ||
+ !MayContainRelevantNodes(aElement->GetParentNode()) ||
+ !nsContentUtils::IsInSameAnonymousTree(mRootNode, aElement)) {
+ // Either we're already dirty or aElement will never match us.
+ return;
+ }
+
+ InvalidateNamedItemsCacheForAttributeChange(aNameSpaceID, aAttribute);
+
+ if (!mFunc || !mFuncMayDependOnAttr) {
+ // aElement might be relevant but the attribute change doesn't affect
+ // whether we match it.
+ return;
+ }
+
+ if (Match(aElement)) {
+ if (mElements.IndexOf(aElement) == mElements.NoIndex) {
+ // We match aElement now, and it's not in our list already. Just dirty
+ // ourselves; this is simpler than trying to figure out where to insert
+ // aElement.
+ SetDirty();
+ }
+ } else {
+ // We no longer match aElement. Remove it from our list. If it's
+ // already not there, this is a no-op (though a potentially
+ // expensive one). Either way, no change of mState is required
+ // here.
+ if (mElements.RemoveElement(aElement)) {
+ InvalidateNamedItemsCacheForDeletion(*aElement);
+ }
+ }
+}
+
+void nsContentList::ContentAppended(nsIContent* aFirstNewContent) {
+ nsIContent* container = aFirstNewContent->GetParent();
+ MOZ_ASSERT(container, "Can't get at the new content if no container!");
+
+ /*
+ * If the state is State::Dirty then we have no useful information in our list
+ * and we want to put off doing work as much as possible.
+ *
+ * Also, if container is anonymous from our point of view, we know that we
+ * can't possibly be matching any of the kids.
+ *
+ * Optimize out also the common case when just one new node is appended and
+ * it doesn't match us.
+ */
+ if (mState == State::Dirty ||
+ !nsContentUtils::IsInSameAnonymousTree(mRootNode, container) ||
+ !MayContainRelevantNodes(container) ||
+ (!aFirstNewContent->HasChildren() &&
+ !aFirstNewContent->GetNextSibling() && !MatchSelf(aFirstNewContent))) {
+ MaybeMarkDirty();
+ return;
+ }
+
+ /*
+ * We want to handle the case of ContentAppended by sometimes
+ * appending the content to our list, not just setting state to
+ * State::Dirty, since most of our ContentAppended notifications
+ * should come during pageload and be at the end of the document.
+ * Do a bit of work to see whether we could just append to what we
+ * already have.
+ */
+
+ uint32_t ourCount = mElements.Length();
+ const bool appendingToList = [&] {
+ if (ourCount == 0) {
+ return true;
+ }
+ if (mRootNode == container) {
+ return true;
+ }
+ return nsContentUtils::PositionIsBefore(mElements.LastElement(),
+ aFirstNewContent);
+ }();
+
+ if (!appendingToList) {
+ // The new stuff is somewhere in the middle of our list; check
+ // whether we need to invalidate
+ for (nsIContent* cur = aFirstNewContent; cur; cur = cur->GetNextSibling()) {
+ if (MatchSelf(cur)) {
+ // Uh-oh. We're gonna have to add elements into the middle
+ // of our list. That's not worth the effort.
+ SetDirty();
+ break;
+ }
+ }
+
+ ASSERT_IN_SYNC;
+ return;
+ }
+
+ /*
+ * At this point we know we could append. If we're not up to
+ * date, however, that would be a bad idea -- it could miss some
+ * content that we never picked up due to being lazy. Further, we
+ * may never get asked for this content... so don't grab it yet.
+ */
+ if (mState == State::Lazy) {
+ return;
+ }
+
+ /*
+ * We're up to date. That means someone's actively using us; we
+ * may as well grab this content....
+ */
+ if (mDeep) {
+ for (nsIContent* cur = aFirstNewContent; cur;
+ cur = cur->GetNextNode(container)) {
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ mElements.AppendElement(cur);
+ InvalidateNamedItemsCacheForInsertion(*cur->AsElement());
+ }
+ }
+ } else {
+ for (nsIContent* cur = aFirstNewContent; cur; cur = cur->GetNextSibling()) {
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ mElements.AppendElement(cur);
+ InvalidateNamedItemsCacheForInsertion(*cur->AsElement());
+ }
+ }
+ }
+
+ ASSERT_IN_SYNC;
+}
+
+void nsContentList::ContentInserted(nsIContent* aChild) {
+ // Note that aChild->GetParentNode() can be null here if we are inserting into
+ // the document itself; any attempted optimizations to this method should deal
+ // with that.
+ if (mState != State::Dirty &&
+ MayContainRelevantNodes(aChild->GetParentNode()) &&
+ nsContentUtils::IsInSameAnonymousTree(mRootNode, aChild) &&
+ MatchSelf(aChild)) {
+ SetDirty();
+ }
+
+ ASSERT_IN_SYNC;
+}
+
+void nsContentList::ContentRemoved(nsIContent* aChild,
+ nsIContent* aPreviousSibling) {
+ if (mState != State::Dirty &&
+ MayContainRelevantNodes(aChild->GetParentNode()) &&
+ nsContentUtils::IsInSameAnonymousTree(mRootNode, aChild) &&
+ MatchSelf(aChild)) {
+ SetDirty();
+ }
+
+ ASSERT_IN_SYNC;
+}
+
+bool nsContentList::Match(Element* aElement) {
+ if (mFunc) {
+ return (*mFunc)(aElement, mMatchNameSpaceId, mXMLMatchAtom, mData);
+ }
+
+ if (!mXMLMatchAtom) return false;
+
+ NodeInfo* ni = aElement->NodeInfo();
+
+ bool unknown = mMatchNameSpaceId == kNameSpaceID_Unknown;
+ bool wildcard = mMatchNameSpaceId == kNameSpaceID_Wildcard;
+ bool toReturn = mMatchAll;
+ if (!unknown && !wildcard) toReturn &= ni->NamespaceEquals(mMatchNameSpaceId);
+
+ if (toReturn) return toReturn;
+
+ bool matchHTML =
+ mIsHTMLDocument && aElement->GetNameSpaceID() == kNameSpaceID_XHTML;
+
+ if (unknown) {
+ return matchHTML ? ni->QualifiedNameEquals(mHTMLMatchAtom)
+ : ni->QualifiedNameEquals(mXMLMatchAtom);
+ }
+
+ if (wildcard) {
+ return matchHTML ? ni->Equals(mHTMLMatchAtom) : ni->Equals(mXMLMatchAtom);
+ }
+
+ return matchHTML ? ni->Equals(mHTMLMatchAtom, mMatchNameSpaceId)
+ : ni->Equals(mXMLMatchAtom, mMatchNameSpaceId);
+}
+
+bool nsContentList::MatchSelf(nsIContent* aContent) {
+ MOZ_ASSERT(aContent, "Can't match null stuff, you know");
+ MOZ_ASSERT(mDeep || aContent->GetParentNode() == mRootNode,
+ "MatchSelf called on a node that we can't possibly match");
+
+ if (!aContent->IsElement()) {
+ return false;
+ }
+
+ if (Match(aContent->AsElement())) return true;
+
+ if (!mDeep) return false;
+
+ for (nsIContent* cur = aContent->GetFirstChild(); cur;
+ cur = cur->GetNextNode(aContent)) {
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void nsContentList::PopulateSelf(uint32_t aNeededLength,
+ uint32_t aExpectedElementsIfDirty) {
+ if (!mRootNode) {
+ return;
+ }
+
+ ASSERT_IN_SYNC;
+
+ uint32_t count = mElements.Length();
+ NS_ASSERTION(mState != State::Dirty || count == aExpectedElementsIfDirty,
+ "Reset() not called when setting state to State::Dirty?");
+
+ if (count >= aNeededLength) // We're all set
+ return;
+
+ uint32_t elementsToAppend = aNeededLength - count;
+#ifdef DEBUG
+ uint32_t invariant = elementsToAppend + mElements.Length();
+#endif
+
+ if (mDeep) {
+ // If we already have nodes start searching at the last one, otherwise
+ // start searching at the root.
+ nsINode* cur = count ? mElements[count - 1].get() : mRootNode;
+ do {
+ cur = cur->GetNextNode(mRootNode);
+ if (!cur) {
+ break;
+ }
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ // Append AsElement() to get nsIContent instead of nsINode
+ mElements.AppendElement(cur->AsElement());
+ --elementsToAppend;
+ }
+ } while (elementsToAppend);
+ } else {
+ nsIContent* cur = count ? mElements[count - 1]->GetNextSibling()
+ : mRootNode->GetFirstChild();
+ for (; cur && elementsToAppend; cur = cur->GetNextSibling()) {
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ mElements.AppendElement(cur);
+ --elementsToAppend;
+ }
+ }
+ }
+
+ NS_ASSERTION(elementsToAppend + mElements.Length() == invariant,
+ "Something is awry!");
+
+ if (elementsToAppend != 0) {
+ mState = State::UpToDate;
+ } else {
+ mState = State::Lazy;
+ }
+
+ SetEnabledCallbacks(nsIMutationObserver::kAll);
+
+ ASSERT_IN_SYNC;
+}
+
+void nsContentList::RemoveFromHashtable() {
+ if (mFunc) {
+ // nsCacheableFuncStringContentList can be in a hash table without being
+ // in gContentListHashTable, but it will have been removed from the hash
+ // table in its dtor before it runs the nsContentList dtor.
+ MOZ_RELEASE_ASSERT(!mInHashtable);
+
+ // This can't be in gContentListHashTable.
+ return;
+ }
+
+ nsDependentAtomString str(mXMLMatchAtom);
+ nsContentListKey key(mRootNode, mMatchNameSpaceId, str, mIsHTMLDocument);
+ sRecentlyUsedContentLists.Remove(key);
+
+ if (gContentListHashTable) {
+ gContentListHashTable->RemoveEntry(&key);
+
+ if (gContentListHashTable->Count() == 0) {
+ gContentListHashTable = nullptr;
+ }
+ }
+
+ MOZ_RELEASE_ASSERT(!mInHashtable);
+}
+
+void nsContentList::BringSelfUpToDate(bool aDoFlush) {
+ if (mFlushesNeeded && mRootNode && aDoFlush) {
+ // XXX sXBL/XBL2 issue
+ if (Document* doc = mRootNode->GetUncomposedDoc()) {
+ // Flush pending content changes Bug 4891.
+ doc->FlushPendingNotifications(FlushType::ContentAndNotify);
+ }
+ }
+
+ if (mState != State::UpToDate) {
+ PopulateSelf(uint32_t(-1));
+ }
+
+ mMissedUpdates = 0;
+
+ ASSERT_IN_SYNC;
+ NS_ASSERTION(!mRootNode || mState == State::UpToDate,
+ "PopulateSelf dod not bring content list up to date!");
+}
+
+nsCacheableFuncStringContentList::~nsCacheableFuncStringContentList() {
+ RemoveFromFuncStringHashtable();
+}
+
+void nsCacheableFuncStringContentList::RemoveFromFuncStringHashtable() {
+ if (!gFuncStringContentListHashTable) {
+ MOZ_RELEASE_ASSERT(!mInHashtable);
+ return;
+ }
+
+ nsFuncStringCacheKey key(mRootNode, mFunc, mString);
+ gFuncStringContentListHashTable->RemoveEntry(&key);
+
+ if (gFuncStringContentListHashTable->Count() == 0) {
+ gFuncStringContentListHashTable = nullptr;
+ }
+
+ MOZ_RELEASE_ASSERT(!mInHashtable);
+}
+
+#ifdef DEBUG_CONTENT_LIST
+void nsContentList::AssertInSync() {
+ if (mState == State::Dirty) {
+ return;
+ }
+
+ if (!mRootNode) {
+ NS_ASSERTION(mElements.Length() == 0 && mState == State::Dirty,
+ "Empty iterator isn't quite empty?");
+ return;
+ }
+
+ // XXX This code will need to change if nsContentLists can ever match
+ // elements that are outside of the document element.
+ nsIContent* root = mRootNode->IsDocument()
+ ? mRootNode->AsDocument()->GetRootElement()
+ : mRootNode->AsContent();
+
+ PreContentIterator preOrderIter;
+ if (mDeep) {
+ preOrderIter.Init(root);
+ preOrderIter.First();
+ }
+
+ uint32_t cnt = 0, index = 0;
+ while (true) {
+ if (cnt == mElements.Length() && mState == State::Lazy) {
+ break;
+ }
+
+ nsIContent* cur =
+ mDeep ? preOrderIter.GetCurrentNode() : mRootNode->GetChildAt(index++);
+ if (!cur) {
+ break;
+ }
+
+ if (cur->IsElement() && Match(cur->AsElement())) {
+ NS_ASSERTION(cnt < mElements.Length() && mElements[cnt] == cur,
+ "Elements is out of sync");
+ ++cnt;
+ }
+
+ if (mDeep) {
+ preOrderIter.Next();
+ }
+ }
+
+ NS_ASSERTION(cnt == mElements.Length(), "Too few elements");
+}
+#endif
+
+//-----------------------------------------------------
+// nsCachableElementsByNameNodeList
+
+JSObject* nsCachableElementsByNameNodeList::WrapObject(
+ JSContext* cx, JS::Handle<JSObject*> aGivenProto) {
+ return NodeList_Binding::Wrap(cx, this, aGivenProto);
+}
+
+void nsCachableElementsByNameNodeList::AttributeChanged(
+ Element* aElement, int32_t aNameSpaceID, nsAtom* aAttribute,
+ int32_t aModType, const nsAttrValue* aOldValue) {
+ // No need to rebuild the list if the changed attribute is not the name
+ // attribute.
+ if (aAttribute != nsGkAtoms::name) {
+ InvalidateNamedItemsCacheForAttributeChange(aNameSpaceID, aAttribute);
+ return;
+ }
+
+ nsCacheableFuncStringContentList::AttributeChanged(
+ aElement, aNameSpaceID, aAttribute, aModType, aOldValue);
+}
+
+//-----------------------------------------------------
+// nsCacheableFuncStringHTMLCollection
+
+JSObject* nsCacheableFuncStringHTMLCollection::WrapObject(
+ JSContext* cx, JS::Handle<JSObject*> aGivenProto) {
+ return HTMLCollection_Binding::Wrap(cx, this, aGivenProto);
+}
+
+//-----------------------------------------------------
+// nsLabelsNodeList
+
+JSObject* nsLabelsNodeList::WrapObject(JSContext* cx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return NodeList_Binding::Wrap(cx, this, aGivenProto);
+}
+
+void nsLabelsNodeList::AttributeChanged(Element* aElement, int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ MOZ_ASSERT(aElement, "Must have a content node to work with");
+ if (mState == State::Dirty ||
+ !nsContentUtils::IsInSameAnonymousTree(mRootNode, aElement)) {
+ return;
+ }
+
+ InvalidateNamedItemsCacheForAttributeChange(aNameSpaceID, aAttribute);
+
+ // We need to handle input type changes to or from "hidden".
+ if (aElement->IsHTMLElement(nsGkAtoms::input) &&
+ aAttribute == nsGkAtoms::type && aNameSpaceID == kNameSpaceID_None) {
+ SetDirty();
+ return;
+ }
+}
+
+void nsLabelsNodeList::ContentAppended(nsIContent* aFirstNewContent) {
+ nsIContent* container = aFirstNewContent->GetParent();
+ // If a labelable element is moved to outside or inside of
+ // nested associated labels, we're gonna have to modify
+ // the content list.
+ if (mState != State::Dirty ||
+ nsContentUtils::IsInSameAnonymousTree(mRootNode, container)) {
+ SetDirty();
+ return;
+ }
+}
+
+void nsLabelsNodeList::ContentInserted(nsIContent* aChild) {
+ // If a labelable element is moved to outside or inside of
+ // nested associated labels, we're gonna have to modify
+ // the content list.
+ if (mState != State::Dirty ||
+ nsContentUtils::IsInSameAnonymousTree(mRootNode, aChild)) {
+ SetDirty();
+ return;
+ }
+}
+
+void nsLabelsNodeList::ContentRemoved(nsIContent* aChild,
+ nsIContent* aPreviousSibling) {
+ // If a labelable element is removed, we're gonna have to clean
+ // the content list.
+ if (mState != State::Dirty ||
+ nsContentUtils::IsInSameAnonymousTree(mRootNode, aChild)) {
+ SetDirty();
+ return;
+ }
+}
+
+void nsLabelsNodeList::MaybeResetRoot(nsINode* aRootNode) {
+ MOZ_ASSERT(aRootNode, "Must have root");
+ if (mRootNode == aRootNode) {
+ return;
+ }
+
+ MOZ_ASSERT(mIsLiveList, "nsLabelsNodeList is always a live list");
+ if (mRootNode) {
+ mRootNode->RemoveMutationObserver(this);
+ }
+ mRootNode = aRootNode;
+ mRootNode->AddMutationObserver(this);
+ SetDirty();
+}
+
+void nsLabelsNodeList::PopulateSelf(uint32_t aNeededLength,
+ uint32_t aExpectedElementsIfDirty) {
+ if (!mRootNode) {
+ return;
+ }
+
+ // Start searching at the root.
+ nsINode* cur = mRootNode;
+ if (mElements.IsEmpty() && cur->IsElement() && Match(cur->AsElement())) {
+ mElements.AppendElement(cur->AsElement());
+ ++aExpectedElementsIfDirty;
+ }
+
+ nsContentList::PopulateSelf(aNeededLength, aExpectedElementsIfDirty);
+}