Merge SelectorDataList into SelectorQuery.

third_party/WebKit/Source/core/dom/SelectorQuery.cpp

 /*
  * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * 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.
@@ skipping 86 matching lines @@
         return element;
     }
     return nullptr;
   }
 
   const AtomicString& m_className;
   Member<ContainerNode> m_rootNode;
   Member<Element> m_currentElement;
 };
 
-void SelectorDataList::initialize(const CSSSelectorList& selectorList) {
-  DCHECK(m_selectors.isEmpty());
-
-  unsigned selectorCount = 0;
-  for (const CSSSelector* selector = selectorList.first(); selector;
-       selector = CSSSelectorList::next(*selector))
-    selectorCount++;
-
-  m_usesDeepCombinatorOrShadowPseudo = false;
-  m_needsUpdatedDistribution = false;
-  m_selectors.reserveInitialCapacity(selectorCount);
-  for (const CSSSelector* selector = selectorList.first(); selector;
-       selector = CSSSelectorList::next(*selector)) {
-    if (selector->matchesPseudoElement())
-      continue;
-    m_selectors.uncheckedAppend(selector);
-    m_usesDeepCombinatorOrShadowPseudo |=
-        selector->hasDeepCombinatorOrShadowPseudo();
-    m_needsUpdatedDistribution |= selector->needsUpdatedDistribution();
-  }
-}
-
-inline bool SelectorDataList::selectorMatches(
-    const CSSSelector& selector,
-    Element& element,
-    const ContainerNode& rootNode) const {
+inline bool selectorMatches(const CSSSelector& selector,
+                            Element& element,
+                            const ContainerNode& rootNode) {
   SelectorChecker::Init init;
   init.mode = SelectorChecker::QueryingRules;
   SelectorChecker checker(init);
   SelectorChecker::SelectorCheckingContext context(
       &element, SelectorChecker::VisitedMatchDisabled);
   context.selector = &selector;
   context.scope = &rootNode;
   return checker.match(context);
 }
 
-bool SelectorDataList::matches(Element& targetElement) const {
+bool SelectorQuery::matches(Element& targetElement) const {
   if (m_needsUpdatedDistribution)
     targetElement.updateDistribution();
 
   for (const auto& selector : m_selectors) {
     if (selectorMatches(*selector, targetElement, targetElement))
       return true;
   }
 
   return false;
 }
 
-Element* SelectorDataList::closest(Element& targetElement) const {
+Element* SelectorQuery::closest(Element& targetElement) const {
   if (m_selectors.size() == 0)
     return nullptr;
   if (m_needsUpdatedDistribution)
     targetElement.updateDistribution();
 
   for (Element* currentElement = &targetElement; currentElement;
        currentElement = currentElement->parentElement()) {
     for (const auto& selector : m_selectors) {
       if (selectorMatches(*selector, *currentElement, targetElement))
         return currentElement;
     }
   }
   return nullptr;
 }
 
-StaticElementList* SelectorDataList::queryAll(ContainerNode& rootNode) const {
+StaticElementList* SelectorQuery::queryAll(ContainerNode& rootNode) const {
   HeapVector<Member<Element>> result;
   execute<AllElementsSelectorQueryTrait>(rootNode, result);
   return StaticElementList::adopt(result);
 }
 
-Element* SelectorDataList::queryFirst(ContainerNode& rootNode) const {
+Element* SelectorQuery::queryFirst(ContainerNode& rootNode) const {
   Element* matchedElement = nullptr;
   execute<SingleElementSelectorQueryTrait>(rootNode, matchedElement);
   return matchedElement;
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::collectElementsByClassName(
+static void collectElementsByClassName(
     ContainerNode& rootNode,
     const AtomicString& className,
-    typename SelectorQueryTrait::OutputType& output) const {
+    typename SelectorQueryTrait::OutputType& output) {
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
     if (element.hasClass() && element.classNames().contains(className)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
 inline bool matchesTagName(const QualifiedName& tagName,
                            const Element& element) {
   if (tagName == anyQName())
     return true;
   if (element.hasLocalName(tagName.localName()))
     return true;
   // Non-html elements in html documents are normalized to their camel-cased
   // version during parsing if applicable. Yet, type selectors are lower-cased
   // for selectors in html documents. Compare the upper case converted names
   // instead to allow matching SVG elements like foreignObject.
   if (!element.isHTMLElement() && element.document().isHTMLDocument())
     return element.tagQName().localNameUpper() == tagName.localNameUpper();
   return false;
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::collectElementsByTagName(
+static void collectElementsByTagName(
     ContainerNode& rootNode,
     const QualifiedName& tagName,
-    typename SelectorQueryTrait::OutputType& output) const {
+    typename SelectorQueryTrait::OutputType& output) {
   DCHECK_EQ(tagName.namespaceURI(), starAtom);
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
     if (matchesTagName(tagName, element)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
-inline bool SelectorDataList::canUseFastQuery(
+inline bool SelectorQuery::canUseFastQuery(
     const ContainerNode& rootNode) const {
   if (m_usesDeepCombinatorOrShadowPseudo)
     return false;
   if (m_needsUpdatedDistribution)
     return false;
   if (rootNode.document().inQuirksMode())
     return false;
   if (!rootNode.isConnected())
     return false;
   return m_selectors.size() == 1;
@@ skipping 15 matching lines @@
 // If returns true, traversalRoots has the elements that may match the selector
 // query.
 //
 // If returns false, traversalRoots has the rootNode parameter or descendants of
 // rootNode representing the subtree for which we can limit the querySelector
 // traversal.
 //
 // The travseralRoots may be empty, regardless of the returned bool value, if
 // this method finds that the selectors won't match any element.
 template <typename SelectorQueryTrait>
-void SelectorDataList::findTraverseRootsAndExecute(
+void SelectorQuery::findTraverseRootsAndExecute(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   // We need to return the matches in document order. To use id lookup while
   // there is possiblity of multiple matches we would need to sort the
   // results. For now, just traverse the document in that case.
   DCHECK_EQ(m_selectors.size(), 1u);
 
   bool isRightmostSelector = true;
   bool startFromParent = false;
 
@@ skipping 62 matching lines @@
       startFromParent = true;
     else
       startFromParent = false;
   }
 
   executeForTraverseRoot<SelectorQueryTrait>(
       *m_selectors[0], &rootNode, DoesNotMatchTraverseRoots, rootNode, output);
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::executeForTraverseRoot(
+void SelectorQuery::executeForTraverseRoot(
     const CSSSelector& selector,
     ContainerNode* traverseRoot,
     MatchTraverseRootState matchTraverseRoot,
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   if (!traverseRoot)
     return;
 
   if (matchTraverseRoot) {
     if (selectorMatches(selector, toElement(*traverseRoot), rootNode))
       SelectorQueryTrait::appendElement(output, toElement(*traverseRoot));
     return;
   }
 
   for (Element& element : ElementTraversal::descendantsOf(*traverseRoot)) {
     if (selectorMatches(selector, element, rootNode)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
 template <typename SelectorQueryTrait, typename SimpleElementListType>
-void SelectorDataList::executeForTraverseRoots(
+void SelectorQuery::executeForTraverseRoots(
     const CSSSelector& selector,
     SimpleElementListType& traverseRoots,
     MatchTraverseRootState matchTraverseRoots,
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   if (traverseRoots.isEmpty())
     return;
 
   if (matchTraverseRoots) {
     while (!traverseRoots.isEmpty()) {
@@ skipping 13 matching lines @@
       if (selectorMatches(selector, element, rootNode)) {
         SelectorQueryTrait::appendElement(output, element);
         if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
           return;
       }
     }
   }
 }
 
 template <typename SelectorQueryTrait>
-bool SelectorDataList::selectorListMatches(
+bool SelectorQuery::selectorListMatches(
     ContainerNode& rootNode,
     Element& element,
     typename SelectorQueryTrait::OutputType& output) const {
   for (const auto& selector : m_selectors) {
     if (selectorMatches(*selector, element, rootNode)) {
       SelectorQueryTrait::appendElement(output, element);
       return true;
     }
   }
   return false;
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::executeSlow(
+void SelectorQuery::executeSlow(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
     if (selectorListMatches<SelectorQueryTrait>(rootNode, element, output) &&
         SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 // FIXME: Move the following helper functions, authorShadowRootOf,
@@ skipping 43 matching lines @@
              youngerShadowRoot->type() == ShadowRootType::Open);
       return youngerShadowRoot;
     }
 
     current = &shadowRoot->host();
   }
   return nullptr;
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::executeSlowTraversingShadowTree(
+void SelectorQuery::executeSlowTraversingShadowTree(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   for (ContainerNode* node = firstWithinTraversingShadowTree(rootNode); node;
        node = nextTraversingShadowTree(*node, &rootNode)) {
     if (!node->isElementNode())
       continue;
     Element* element = toElement(node);
     if (selectorListMatches<SelectorQueryTrait>(rootNode, *element, output) &&
         SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
@@ skipping 12 matching lines @@
         selector->attribute() == idAttr &&
         selector->attributeMatch() == CSSSelector::CaseSensitive)
       return selector;
     if (selector->relation() != CSSSelector::SubSelector)
       break;
   }
   return nullptr;
 }
 
 template <typename SelectorQueryTrait>
-void SelectorDataList::execute(
+void SelectorQuery::execute(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   if (m_selectors.isEmpty())
     return;
 
   if (!canUseFastQuery(rootNode)) {
     if (m_needsUpdatedDistribution)
       rootNode.updateDistribution();
     if (m_usesDeepCombinatorOrShadowPseudo) {
       executeSlowTraversingShadowTree<SelectorQueryTrait>(rootNode, output);
@@ skipping 62 matching lines @@
   findTraverseRootsAndExecute<SelectorQueryTrait>(rootNode, output);
 }
 
 std::unique_ptr<SelectorQuery> SelectorQuery::adopt(
     CSSSelectorList selectorList) {
   return WTF::wrapUnique(new SelectorQuery(std::move(selectorList)));
 }
 
 SelectorQuery::SelectorQuery(CSSSelectorList selectorList) {
   m_selectorList = std::move(selectorList);
-  m_selectors.initialize(m_selectorList);
-}
+  DCHECK(m_selectors.isEmpty());
 
-bool SelectorQuery::matches(Element& element) const {
-  return m_selectors.matches(element);
-}
+  unsigned selectorCount = 0;
+  for (const CSSSelector* selector = m_selectorList.first(); selector;
+       selector = CSSSelectorList::next(*selector))
+    selectorCount++;
 
-Element* SelectorQuery::closest(Element& element) const {
-  return m_selectors.closest(element);
-}
-
-StaticElementList* SelectorQuery::queryAll(ContainerNode& rootNode) const {
-  return m_selectors.queryAll(rootNode);
-}
-
-Element* SelectorQuery::queryFirst(ContainerNode& rootNode) const {
-  return m_selectors.queryFirst(rootNode);
+  m_usesDeepCombinatorOrShadowPseudo = false;
+  m_needsUpdatedDistribution = false;
+  m_selectors.reserveInitialCapacity(selectorCount);
+  for (const CSSSelector* selector = m_selectorList.first(); selector;
+       selector = CSSSelectorList::next(*selector)) {
+    if (selector->matchesPseudoElement())
+      continue;
+    m_selectors.uncheckedAppend(selector);
+    m_usesDeepCombinatorOrShadowPseudo |=
+        selector->hasDeepCombinatorOrShadowPseudo();
+    m_needsUpdatedDistribution |= selector->needsUpdatedDistribution();
+  }
 }
 
 SelectorQuery* SelectorQueryCache::add(const AtomicString& selectors,
                                        const Document& document,
                                        ExceptionState& exceptionState) {
   HashMap<AtomicString, std::unique_ptr<SelectorQuery>>::iterator it =
       m_entries.find(selectors);
   if (it != m_entries.end())
     return it->value.get();
 
@@ skipping 15 matching lines @@
   return m_entries
       .insert(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink