void SelectorDataList::execute(ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
if (!canUseFastQuery(rootNode)) {
if (m_needsUpdatedDistribution)
rootNode.updateDistribution();
if (m_crossesTreeBoundary) {
executeSlowTraversingShadowTree<SelectorQueryTrait>(rootNode, output);
} else {
executeSlow<SelectorQueryTrait>(rootNode, output);
}
return;
}
ASSERT(m_selectors.size() == 1);
const CSSSelector& selector = *m_selectors[0];
const CSSSelector& firstSelector = selector;
// Fast path for querySelector*('#id'), querySelector*('tag#id').
if (const CSSSelector* idSelector = selectorForIdLookup(firstSelector)) {
const AtomicString& idToMatch = idSelector->value();
if (rootNode.treeScope().containsMultipleElementsWithId(idToMatch)) {
const WillBeHeapVector<RawPtrWillBeMember<Element>>& elements = rootNode.treeScope().getAllElementsById(idToMatch);
size_t count = elements.size();
for (size_t i = 0; i < count; ++i) {
Element& element = *elements[i];
if (!(isTreeScopeRoot(rootNode) || element.isDescendantOf(&rootNode)))
continue;
if (selectorMatches(selector, element, rootNode)) {
SelectorQueryTrait::appendElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
return;
}
Element* element = rootNode.treeScope().getElementById(idToMatch);
if (!element || !(isTreeScopeRoot(rootNode) || element->isDescendantOf(&rootNode)))
return;
if (selectorMatches(selector, *element, rootNode))
SelectorQueryTrait::appendElement(output, *element);
return;
}
if (!firstSelector.tagHistory()) {
// Fast path for querySelector*('.foo'), and querySelector*('div').
switch (firstSelector.match()) {
case CSSSelector::Class:
collectElementsByClassName<SelectorQueryTrait>(rootNode, firstSelector.value(), output);
return;
case CSSSelector::Tag:
collectElementsByTagName<SelectorQueryTrait>(rootNode, firstSelector.tagQName(), output);
return;
default:
break; // If we need another fast path, add here.
}
}
findTraverseRootsAndExecute<SelectorQueryTrait>(rootNode, output);
}
void SelectorDataList::execute(ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
if (!canUseFastQuery(rootNode)) {
executeSlow<SelectorQueryTrait>(rootNode, output);
return;
}
ASSERT(m_selectors.size() == 1);
const SelectorData& selector = m_selectors[0];
const CSSSelector& firstSelector = selector.selector;
// Fast path for querySelector*('#id'), querySelector*('tag#id').
if (const CSSSelector* idSelector = selectorForIdLookup(firstSelector)) {
const AtomicString& idToMatch = idSelector->value();
Element* singleMatchingElement = 0;
if (rootNode.treeScope().getNumberOfElementsWithId(idToMatch, singleMatchingElement) > 1) {
const Vector<Element*>& elements = rootNode.treeScope().getAllElementsById(idToMatch);
size_t count = elements.size();
for (size_t i = 0; i < count; ++i) {
Element& element = *elements[i];
if (!(isTreeScopeRoot(rootNode) || element.isDescendantOf(&rootNode)))
continue;
if (selectorMatches(selector, element, rootNode)) {
SelectorQueryTrait::appendElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
return;
}
if (!singleMatchingElement || !(isTreeScopeRoot(rootNode) || singleMatchingElement->isDescendantOf(&rootNode)))
return;
if (selectorMatches(selector, *singleMatchingElement, rootNode))
SelectorQueryTrait::appendElement(output, *singleMatchingElement);
return;
}
if (!firstSelector.tagHistory()) {
// Fast path for querySelector*('.foo'), and querySelector*('div').
switch (firstSelector.m_match) {
case CSSSelector::Class:
collectElementsByClassName<SelectorQueryTrait>(rootNode, firstSelector.value(), output);
return;
case CSSSelector::Tag:
collectElementsByTagName<SelectorQueryTrait>(rootNode, firstSelector.tagQName(), output);
return;
default:
break; // If we need another fast path, add here.
}
}
findTraverseRootsAndExecute<SelectorQueryTrait>(rootNode, output);
}
void SelectorDataList::execute(Node* rootNode, Vector<RefPtr<Node> >& matchedElements) const
{
if (const CSSSelector* idSelector = selectorForIdLookup(rootNode)) {
ASSERT(m_selectors.size() == 1);
const AtomicString& idToMatch = idSelector->value();
if (UNLIKELY(rootNode->treeScope()->containsMultipleElementsWithId(idToMatch))) {
const Vector<Element*>* elements = rootNode->treeScope()->getAllElementsById(idToMatch);
ASSERT(elements);
size_t count = elements->size();
for (size_t i = 0; i < count; ++i) {
Element* element = elements->at(i);
if (selectorMatches(m_selectors[0], element, rootNode)) {
matchedElements.append(element);
if (firstMatchOnly)
return;
}
}
return;
}
Element* element = rootNode->treeScope()->getElementById(idToMatch);
if (!element || !(isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))
return;
if (selectorMatches(m_selectors[0], element, rootNode))
matchedElements.append(element);
return;
}
unsigned selectorCount = m_selectors.size();
if (selectorCount == 1) {
const SelectorData& selector = m_selectors[0];
for (Element* element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::next(element, rootNode)) {
if (selectorMatches(selector, element, rootNode)) {
matchedElements.append(element);
if (firstMatchOnly)
return;
}
}
return;
}
for (Element* element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::next(element, rootNode)) {
for (unsigned i = 0; i < selectorCount; ++i) {
if (selectorMatches(m_selectors[i], element, rootNode)) {
matchedElements.append(element);
if (firstMatchOnly)
return;
break;
}
}
}
}
ALWAYS_INLINE void SelectorDataList::execute(Node* rootNode, typename SelectorQueryTrait::OutputType& output) const
{
if (m_selectors.size() == 1) {
const SelectorData& selectorData = m_selectors[0];
if (const CSSSelector* idSelector = selectorForIdLookup(rootNode, selectorData.selector))
executeFastPathForIdSelector<SelectorQueryTrait>(rootNode, selectorData, idSelector, output);
else if (isSingleTagNameSelector(selectorData.selector))
executeSingleTagNameSelectorData<SelectorQueryTrait>(rootNode, selectorData, output);
else if (isSingleClassNameSelector(selectorData.selector))
executeSingleClassNameSelectorData<SelectorQueryTrait>(rootNode, selectorData, output);
else
executeSingleSelectorData<SelectorQueryTrait>(rootNode, selectorData, output);
return;
}
executeSingleMultiSelectorData<SelectorQueryTrait>(rootNode, output);
}
ALWAYS_INLINE void SelectorDataList::execute(Node* rootNode, Vector<RefPtr<Node> >& matchedElements) const
{
if (m_selectors.size() == 1) {
const SelectorData& selectorData = m_selectors[0];
if (const CSSSelector* idSelector = selectorForIdLookup(rootNode, selectorData.selector))
executeFastPathForIdSelector<firstMatchOnly>(rootNode, selectorData, idSelector, matchedElements);
else if (isSingleTagNameSelector(selectorData.selector))
executeSingleTagNameSelectorData<firstMatchOnly>(rootNode, selectorData, matchedElements);
else if (isSingleClassNameSelector(selectorData.selector))
executeSingleClassNameSelectorData<firstMatchOnly>(rootNode, selectorData, matchedElements);
else
executeSingleSelectorData<firstMatchOnly>(rootNode, selectorData, matchedElements);
return;
}
executeSingleMultiSelectorData<firstMatchOnly>(rootNode, matchedElements);
}
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 (selectorData.compilationStatus == SelectorCompilationStatus::SimpleSelectorChecker)
goto CompiledSingleCase;
#endif
}
FALLTHROUGH;
case CompilableSingleWithRootFilter:
case CompilableSingle:
{
#if ENABLE(CSS_SELECTOR_JIT)
const SelectorData& selectorData = m_selectors.first();
ASSERT(m_matchType == RightMostWithIdMatch || selectorData.compilationStatus == SelectorCompilationStatus::NotCompiled);
JSC::VM& vm = searchRootNode->document().scriptExecutionContext()->vm();
selectorData.compilationStatus = SelectorCompiler::compileSelector(selectorData.selector, &vm, SelectorCompiler::SelectorContext::QuerySelector, selectorData.compiledSelectorCodeRef);
RELEASE_ASSERT(selectorData.compilationStatus != SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
if (selectorData.compilationStatus == SelectorCompilationStatus::SimpleSelectorChecker) {
if (m_matchType == CompilableSingle) {
m_matchType = CompiledSingle;
goto CompiledSingleCase;
}
if (m_matchType == CompilableSingleWithRootFilter) {
m_matchType = CompiledSingleWithRootFilter;
goto CompiledSingleWithRootFilterCase;
}
goto CompiledSingleCase;
}
if (m_matchType != RightMostWithIdMatch)
m_matchType = SingleSelector;
goto SingleSelectorCase;
ASSERT_NOT_REACHED();
break;
#else
FALLTHROUGH;
#endif // ENABLE(CSS_SELECTOR_JIT)
}
case CompiledSingleWithRootFilter:
#if ENABLE(CSS_SELECTOR_JIT)
CompiledSingleWithRootFilterCase:
searchRootNode = &filterRootById(*searchRootNode, *m_selectors.first().selector);
#endif // ENABLE(CSS_SELECTOR_JIT)
FALLTHROUGH;
case CompiledSingle:
#if ENABLE(CSS_SELECTOR_JIT)
{
CompiledSingleCase:
const SelectorData& selectorData = m_selectors.first();
void* compiledSelectorChecker = selectorData.compiledSelectorCodeRef.code().executableAddress();
SelectorCompiler::SimpleSelectorChecker selectorChecker = SelectorCompiler::simpleSelectorCheckerFunction(compiledSelectorChecker, selectorData.compilationStatus);
executeCompiledSimpleSelectorChecker<SelectorQueryTrait>(*searchRootNode, selectorChecker, output);
break;
}
#else
FALLTHROUGH;
#endif // ENABLE(CSS_SELECTOR_JIT)
case SingleSelector:
#if ENABLE(CSS_SELECTOR_JIT)
SingleSelectorCase:
#endif
executeSingleSelectorData<SelectorQueryTrait>(*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 MultipleSelectorMatch:
executeSingleMultiSelectorData<SelectorQueryTrait>(*searchRootNode, output);
break;
}
}
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, *searchRootNode))
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.compilationStatus == SelectorCompilationStatus::NotCompiled);
ASSERT(m_matchType == CompilableSingle || m_matchType == CompilableSingleWithRootFilter);
if (compileSelector(selectorData, *searchRootNode)) {
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();
void* compiledSelectorChecker = selectorData.compiledSelectorCodeRef.code().executableAddress();
if (selectorData.compilationStatus == SelectorCompilationStatus::SimpleSelectorChecker) {
SelectorCompiler::QuerySelectorSimpleSelectorChecker selectorChecker = SelectorCompiler::querySelectorSimpleSelectorCheckerFunction(compiledSelectorChecker, selectorData.compilationStatus);
executeCompiledSimpleSelectorChecker<SelectorQueryTrait>(*searchRootNode, selectorChecker, output, selectorData);
} else {
ASSERT(selectorData.compilationStatus == SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
SelectorCompiler::QuerySelectorSelectorCheckerWithCheckingContext selectorChecker = SelectorCompiler::querySelectorSelectorCheckerFunctionWithCheckingContext(compiledSelectorChecker, selectorData.compilationStatus);
executeCompiledSelectorCheckerWithCheckingContext<SelectorQueryTrait>(rootNode, *searchRootNode, selectorChecker, output, selectorData);
}
break;
}
#else
case CompiledSingleWithRootFilter:
case CompiledSingle:
ASSERT_NOT_REACHED();
#if ASSERT_DISABLED
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, *searchRootNode)) {
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;
}
}
