blob: 78e36be58bf3fb7d61c361b3d07dd2e81c30d7ab [file] [log] [blame]
/*
* Copyright (C) 2011-2020 Apple Inc. All rights reserved.
* Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "SelectorQuery.h"
#include "CSSParser.h"
#include "CommonAtomStrings.h"
#include "ElementIterator.h"
#include "HTMLNames.h"
#include "SelectorChecker.h"
#include "StaticNodeList.h"
#include "StyledElement.h"
namespace WebCore {
#if ASSERT_ENABLED
static bool isSingleTagNameSelector(const CSSSelector& selector)
{
return selector.isLastInTagHistory() && selector.match() == CSSSelector::Tag;
}
static bool isSingleClassNameSelector(const CSSSelector& selector)
{
return selector.isLastInTagHistory() && selector.match() == CSSSelector::Class;
}
#endif // ASSERT_ENABLED
enum class IdMatchingType : uint8_t {
None,
Rightmost,
Filter
};
static bool canBeUsedForIdFastPath(const CSSSelector& selector)
{
return selector.match() == CSSSelector::Id
|| (selector.match() == CSSSelector::Exact && selector.attribute() == HTMLNames::idAttr && !selector.attributeValueMatchingIsCaseInsensitive());
}
static IdMatchingType findIdMatchingType(const CSSSelector& firstSelector)
{
bool inRightmost = true;
for (const CSSSelector* selector = &firstSelector; selector; selector = selector->tagHistory()) {
if (canBeUsedForIdFastPath(*selector)) {
if (inRightmost)
return IdMatchingType::Rightmost;
return IdMatchingType::Filter;
}
if (selector->relation() != CSSSelector::Subselector)
inRightmost = false;
}
return IdMatchingType::None;
}
SelectorDataList::SelectorDataList(const CSSSelectorList& selectorList)
{
unsigned selectorCount = 0;
for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
selectorCount++;
m_selectors.reserveInitialCapacity(selectorCount);
for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
m_selectors.uncheckedAppend({ selector });
if (selectorCount == 1) {
const CSSSelector& selector = *m_selectors.first().selector;
if (selector.isLastInTagHistory()) {
switch (selector.match()) {
case CSSSelector::Tag:
m_matchType = TagNameMatch;
break;
case CSSSelector::Class:
m_matchType = ClassNameMatch;
break;
default:
if (canBeUsedForIdFastPath(selector))
m_matchType = RightMostWithIdMatch;
else
m_matchType = CompilableSingle;
break;
}
} else {
switch (findIdMatchingType(selector)) {
case IdMatchingType::None:
m_matchType = CompilableSingle;
break;
case IdMatchingType::Rightmost:
m_matchType = RightMostWithIdMatch;
break;
case IdMatchingType::Filter:
m_matchType = CompilableSingleWithRootFilter;
break;
}
}
} else
m_matchType = CompilableMultipleSelectorMatch;
}
inline bool SelectorDataList::selectorMatches(const SelectorData& selectorData, Element& element, const ContainerNode& rootNode) const
{
SelectorChecker selectorChecker(element.document());
SelectorChecker::CheckingContext selectorCheckingContext(SelectorChecker::Mode::QueryingRules);
selectorCheckingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
return selectorChecker.match(*selectorData.selector, element, selectorCheckingContext);
}
inline Element* SelectorDataList::selectorClosest(const SelectorData& selectorData, Element& element, const ContainerNode& rootNode) const
{
SelectorChecker selectorChecker(element.document());
SelectorChecker::CheckingContext selectorCheckingContext(SelectorChecker::Mode::QueryingRules);
selectorCheckingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
if (!selectorChecker.match(*selectorData.selector, element, selectorCheckingContext))
return nullptr;
return &element;
}
bool SelectorDataList::matches(Element& targetElement) const
{
for (auto& selctor : m_selectors) {
if (selectorMatches(selctor, targetElement, targetElement))
return true;
}
return false;
}
Element* SelectorDataList::closest(Element& targetElement) const
{
for (auto& currentElement : lineageOfType<Element>(targetElement)) {
for (auto& selector : m_selectors) {
if (auto* candidateElement = selectorClosest(selector, currentElement, targetElement))
return candidateElement;
}
}
return nullptr;
}
struct AllElementExtractorSelectorQueryTrait {
typedef Vector<Ref<Element>> OutputType;
static const bool shouldOnlyMatchFirstElement = false;
ALWAYS_INLINE static void appendOutputForElement(OutputType& output, Element* element) { ASSERT(element); output.append(*element); }
};
Ref<NodeList> SelectorDataList::queryAll(ContainerNode& rootNode) const
{
Vector<Ref<Element>> result;
execute<AllElementExtractorSelectorQueryTrait>(rootNode, result);
return StaticElementList::create(WTFMove(result));
}
struct SingleElementExtractorSelectorQueryTrait {
typedef Element* OutputType;
static const bool shouldOnlyMatchFirstElement = true;
ALWAYS_INLINE static void appendOutputForElement(OutputType& output, Element* element)
{
ASSERT(element);
ASSERT(!output);
output = element;
}
};
Element* SelectorDataList::queryFirst(ContainerNode& rootNode) const
{
Element* result = nullptr;
execute<SingleElementExtractorSelectorQueryTrait>(rootNode, result);
return result;
}
static const CSSSelector* selectorForIdLookup(const ContainerNode& rootNode, const CSSSelector& firstSelector)
{
if (!rootNode.isConnected())
return nullptr;
if (rootNode.document().inQuirksMode())
return nullptr;
for (const CSSSelector* selector = &firstSelector; selector; selector = selector->tagHistory()) {
if (canBeUsedForIdFastPath(*selector))
return selector;
if (selector->relation() != CSSSelector::Subselector)
break;
}
return nullptr;
}
static inline bool isTreeScopeRoot(const ContainerNode& node)
{
return node.isDocumentNode() || node.isShadowRoot();
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeFastPathForIdSelector(const ContainerNode& rootNode, const SelectorData& selectorData, const CSSSelector* idSelector, typename SelectorQueryTrait::OutputType& output) const
{
ASSERT(m_selectors.size() == 1);
ASSERT(idSelector);
const AtomString& idToMatch = idSelector->value();
if (UNLIKELY(rootNode.treeScope().containsMultipleElementsWithId(idToMatch))) {
const Vector<Element*>* elements = rootNode.treeScope().getAllElementsById(idToMatch);
ASSERT(elements);
bool rootNodeIsTreeScopeRoot = isTreeScopeRoot(rootNode);
for (auto& element : *elements) {
if ((rootNodeIsTreeScopeRoot || element->isDescendantOf(rootNode)) && selectorMatches(selectorData, *element, rootNode)) {
SelectorQueryTrait::appendOutputForElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
return;
}
Element* element = rootNode.treeScope().getElementById(idToMatch);
if (!element || !(isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))
return;
if (selectorMatches(selectorData, *element, rootNode))
SelectorQueryTrait::appendOutputForElement(output, element);
}
static ContainerNode& filterRootById(ContainerNode& rootNode, const CSSSelector& firstSelector)
{
if (!rootNode.isConnected())
return rootNode;
if (rootNode.document().inQuirksMode())
return rootNode;
// If there was an Id match in the rightmost Simple Selector, we should be in a RightMostWithIdMatch, not in filter.
// Thus we can skip the rightmost match.
const CSSSelector* selector = &firstSelector;
do {
ASSERT(!canBeUsedForIdFastPath(*selector));
if (selector->relation() != CSSSelector::Subselector)
break;
selector = selector->tagHistory();
} while (selector);
bool inAdjacentChain = false;
for (; selector; selector = selector->tagHistory()) {
if (canBeUsedForIdFastPath(*selector)) {
const AtomString& idToMatch = selector->value();
if (ContainerNode* searchRoot = rootNode.treeScope().getElementById(idToMatch)) {
if (LIKELY(!rootNode.treeScope().containsMultipleElementsWithId(idToMatch))) {
if (inAdjacentChain)
searchRoot = searchRoot->parentNode();
if (searchRoot && (isTreeScopeRoot(rootNode) || searchRoot == &rootNode || searchRoot->isDescendantOf(rootNode)))
return *searchRoot;
}
}
}
if (selector->relation() == CSSSelector::Subselector)
continue;
if (selector->relation() == CSSSelector::DirectAdjacent || selector->relation() == CSSSelector::IndirectAdjacent)
inAdjacentChain = true;
else
inAdjacentChain = false;
}
return rootNode;
}
static ALWAYS_INLINE bool localNameMatches(const Element& element, const AtomString& localName, const AtomString& lowercaseLocalName)
{
if (element.isHTMLElement() && element.document().isHTMLDocument())
return element.localName() == lowercaseLocalName;
return element.localName() == localName;
}
template <typename SelectorQueryTrait>
static inline void elementsForLocalName(const ContainerNode& rootNode, const AtomString& localName, const AtomString& lowercaseLocalName, typename SelectorQueryTrait::OutputType& output)
{
if (localName == lowercaseLocalName) {
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
if (element.tagQName().localName() == localName) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
} else {
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
if (localNameMatches(element, localName, lowercaseLocalName)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
}
template <typename SelectorQueryTrait>
static inline void anyElement(const ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output)
{
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeSingleTagNameSelectorData(const ContainerNode& rootNode, const SelectorData& selectorData, typename SelectorQueryTrait::OutputType& output) const
{
ASSERT(m_selectors.size() == 1);
ASSERT(isSingleTagNameSelector(*selectorData.selector));
const QualifiedName& tagQualifiedName = selectorData.selector->tagQName();
const AtomString& selectorLocalName = tagQualifiedName.localName();
const AtomString& selectorLowercaseLocalName = selectorData.selector->tagLowercaseLocalName();
const AtomString& selectorNamespaceURI = tagQualifiedName.namespaceURI();
if (selectorNamespaceURI == starAtom()) {
if (selectorLocalName != starAtom()) {
// Common case: name defined, selectorNamespaceURI is a wildcard.
elementsForLocalName<SelectorQueryTrait>(rootNode, selectorLocalName, selectorLowercaseLocalName, output);
} else {
// Other fairly common case: both are wildcards.
anyElement<SelectorQueryTrait>(rootNode, output);
}
} else {
// Fallback: NamespaceURI is set, selectorLocalName may be starAtom().
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
if (element.namespaceURI() == selectorNamespaceURI && localNameMatches(element, selectorLocalName, selectorLowercaseLocalName)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeSingleClassNameSelectorData(const ContainerNode& rootNode, const SelectorData& selectorData, typename SelectorQueryTrait::OutputType& output) const
{
ASSERT(m_selectors.size() == 1);
ASSERT(isSingleClassNameSelector(*selectorData.selector));
const AtomString& className = selectorData.selector->value();
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
if (element.hasClass() && element.classNames().contains(className)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeSingleSelectorData(const ContainerNode& rootNode, const ContainerNode& searchRootNode, const SelectorData& selectorData, typename SelectorQueryTrait::OutputType& output) const
{
ASSERT(m_selectors.size() == 1);
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(searchRootNode))) {
if (selectorMatches(selectorData, element, rootNode)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeSingleMultiSelectorData(const ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
for (auto& selector : m_selectors) {
if (selectorMatches(selector, element, rootNode)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
break;
}
}
}
}
#if ENABLE(CSS_SELECTOR_JIT)
template <typename SelectorQueryTrait, typename Checker>
ALWAYS_INLINE void SelectorDataList::executeCompiledSimpleSelectorChecker(const ContainerNode& searchRootNode, Checker selectorChecker, typename SelectorQueryTrait::OutputType& output, const SelectorData& selectorData) const
{
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(searchRootNode))) {
selectorData.compiledSelector.wasUsed();
if (selectorChecker(&element)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
template <typename SelectorQueryTrait, typename Checker>
ALWAYS_INLINE void SelectorDataList::executeCompiledSelectorCheckerWithCheckingContext(const ContainerNode& rootNode, const ContainerNode& searchRootNode, Checker selectorChecker, typename SelectorQueryTrait::OutputType& output, const SelectorData& selectorData) const
{
SelectorChecker::CheckingContext checkingContext(SelectorChecker::Mode::QueryingRules);
checkingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(searchRootNode))) {
selectorData.compiledSelector.wasUsed();
if (selectorChecker(&element, &checkingContext)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeCompiledSingleMultiSelectorData(const ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
SelectorChecker::CheckingContext checkingContext(SelectorChecker::Mode::QueryingRules);
checkingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
for (auto& element : descendantsOfType<Element>(const_cast<ContainerNode&>(rootNode))) {
for (auto& selector : m_selectors) {
selector.compiledSelector.wasUsed();
bool matched = false;
if (selector.compiledSelector.status == SelectorCompilationStatus::SimpleSelectorChecker)
matched = SelectorCompiler::querySelectorSimpleSelectorChecker(selector.compiledSelector, &element);
else {
ASSERT(selector.compiledSelector.status == SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
matched = SelectorCompiler::querySelectorSelectorCheckerWithCheckingContext(selector.compiledSelector, &element, &checkingContext);
}
if (matched) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
break;
}
}
}
}
bool SelectorDataList::compileSelector(const SelectorData& selectorData)
{
auto& compiledSelector = selectorData.compiledSelector;
if (compiledSelector.status == SelectorCompilationStatus::NotCompiled)
SelectorCompiler::compileSelector(compiledSelector, selectorData.selector, SelectorCompiler::SelectorContext::QuerySelector);
return compiledSelector.status != SelectorCompilationStatus::CannotCompile;
}
#endif // ENABLE(CSS_SELECTOR_JIT)
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::execute(ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
ContainerNode* searchRootNode = &rootNode;
switch (m_matchType) {
case RightMostWithIdMatch:
{
const SelectorData& selectorData = m_selectors.first();
if (const CSSSelector* idSelector = selectorForIdLookup(*searchRootNode, *selectorData.selector)) {
executeFastPathForIdSelector<SelectorQueryTrait>(*searchRootNode, m_selectors.first(), idSelector, output);
break;
}
#if ENABLE(CSS_SELECTOR_JIT)
if (compileSelector(selectorData))
goto CompiledSingleCase;
#endif // ENABLE(CSS_SELECTOR_JIT)
goto SingleSelectorCase;
ASSERT_NOT_REACHED();
}
case CompilableSingleWithRootFilter:
case CompilableSingle:
{
#if ENABLE(CSS_SELECTOR_JIT)
const SelectorData& selectorData = m_selectors.first();
ASSERT(selectorData.compiledSelector.status == SelectorCompilationStatus::NotCompiled);
ASSERT(m_matchType == CompilableSingle || m_matchType == CompilableSingleWithRootFilter);
if (compileSelector(selectorData)) {
if (m_matchType == CompilableSingle) {
m_matchType = CompiledSingle;
goto CompiledSingleCase;
}
ASSERT(m_matchType == CompilableSingleWithRootFilter);
m_matchType = CompiledSingleWithRootFilter;
goto CompiledSingleWithRootFilterCase;
}
#endif // ENABLE(CSS_SELECTOR_JIT)
if (m_matchType == CompilableSingle) {
m_matchType = SingleSelector;
goto SingleSelectorCase;
}
ASSERT(m_matchType == CompilableSingleWithRootFilter);
m_matchType = SingleSelectorWithRootFilter;
goto SingleSelectorWithRootFilterCase;
ASSERT_NOT_REACHED();
}
#if ENABLE(CSS_SELECTOR_JIT)
case CompiledSingleWithRootFilter:
CompiledSingleWithRootFilterCase:
searchRootNode = &filterRootById(*searchRootNode, *m_selectors.first().selector);
FALLTHROUGH;
case CompiledSingle:
{
CompiledSingleCase:
const SelectorData& selectorData = m_selectors.first();
if (selectorData.compiledSelector.status == SelectorCompilationStatus::SimpleSelectorChecker) {
executeCompiledSimpleSelectorChecker<SelectorQueryTrait>(*searchRootNode, [&] (const Element* element) {
return SelectorCompiler::querySelectorSimpleSelectorChecker(selectorData.compiledSelector, element);
}, output, selectorData);
} else {
ASSERT(selectorData.compiledSelector.status == SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
executeCompiledSelectorCheckerWithCheckingContext<SelectorQueryTrait>(rootNode, *searchRootNode, [&] (const Element* element, const SelectorChecker::CheckingContext* context) {
return SelectorCompiler::querySelectorSelectorCheckerWithCheckingContext(selectorData.compiledSelector, element, context);
}, output, selectorData);
}
break;
}
#else
case CompiledSingleWithRootFilter:
case CompiledSingle:
ASSERT_NOT_REACHED();
#if !ASSERT_ENABLED
FALLTHROUGH;
#endif
#endif // ENABLE(CSS_SELECTOR_JIT)
case SingleSelectorWithRootFilter:
SingleSelectorWithRootFilterCase:
searchRootNode = &filterRootById(*searchRootNode, *m_selectors.first().selector);
FALLTHROUGH;
case SingleSelector:
SingleSelectorCase:
executeSingleSelectorData<SelectorQueryTrait>(rootNode, *searchRootNode, m_selectors.first(), output);
break;
case TagNameMatch:
executeSingleTagNameSelectorData<SelectorQueryTrait>(*searchRootNode, m_selectors.first(), output);
break;
case ClassNameMatch:
executeSingleClassNameSelectorData<SelectorQueryTrait>(*searchRootNode, m_selectors.first(), output);
break;
case CompilableMultipleSelectorMatch:
#if ENABLE(CSS_SELECTOR_JIT)
{
for (auto& selector : m_selectors) {
if (!compileSelector(selector)) {
m_matchType = MultipleSelectorMatch;
goto MultipleSelectorMatch;
}
}
m_matchType = CompiledMultipleSelectorMatch;
goto CompiledMultipleSelectorMatch;
}
#else
FALLTHROUGH;
#endif // ENABLE(CSS_SELECTOR_JIT)
case CompiledMultipleSelectorMatch:
#if ENABLE(CSS_SELECTOR_JIT)
CompiledMultipleSelectorMatch:
executeCompiledSingleMultiSelectorData<SelectorQueryTrait>(*searchRootNode, output);
break;
#else
FALLTHROUGH;
#endif // ENABLE(CSS_SELECTOR_JIT)
case MultipleSelectorMatch:
#if ENABLE(CSS_SELECTOR_JIT)
MultipleSelectorMatch:
#endif
executeSingleMultiSelectorData<SelectorQueryTrait>(*searchRootNode, output);
break;
}
}
SelectorQuery::SelectorQuery(CSSSelectorList&& selectorList)
: m_selectorList(WTFMove(selectorList))
, m_selectors(m_selectorList)
{
}
ExceptionOr<SelectorQuery&> SelectorQueryCache::add(const String& selectors, Document& document)
{
if (auto* entry = m_entries.get(selectors))
return *entry;
CSSParser parser(document);
auto selectorList = parser.parseSelector(selectors);
if (!selectorList || selectorList->hasInvalidSelector())
return Exception { SyntaxError };
if (selectorList->selectorsNeedNamespaceResolution())
return Exception { SyntaxError };
const int maximumSelectorQueryCacheSize = 256;
if (m_entries.size() == maximumSelectorQueryCacheSize)
m_entries.remove(m_entries.random());
return *m_entries.add(selectors, makeUnique<SelectorQuery>(WTFMove(*selectorList))).iterator->value;
}
}