Remove ClassElementList and reuse collectElementsByClassName in 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 46 matching lines @@
 
 struct AllElementsSelectorQueryTrait {
   typedef HeapVector<Member<Element>> OutputType;
   static const bool shouldOnlyMatchFirstElement = false;
   ALWAYS_INLINE static void appendElement(OutputType& output,
                                           Element& element) {
     output.push_back(&element);
   }
 };
 
-enum ClassElementListBehavior { AllElements, OnlyRoots };
-
-template <ClassElementListBehavior onlyRoots>
-class ClassElementList {
-  STACK_ALLOCATED();
-
- public:
-  ClassElementList(ContainerNode& rootNode, const AtomicString& className)
-      : m_className(className),
-        m_rootNode(&rootNode),
-        m_currentElement(
-            nextInternal(ElementTraversal::firstWithin(rootNode))) {}
-
-  bool isEmpty() const { return !m_currentElement; }
-
-  Element* next() {
-    Element* current = m_currentElement;
-    DCHECK(current);
-    if (onlyRoots)
-      m_currentElement = nextInternal(ElementTraversal::nextSkippingChildren(
-          *m_currentElement, m_rootNode));
-    else
-      m_currentElement =
-          nextInternal(ElementTraversal::next(*m_currentElement, m_rootNode));
-    return current;
-  }
-
- private:
-  Element* nextInternal(Element* element) {
-    for (; element; element = ElementTraversal::next(*element, m_rootNode)) {
-      if (element->hasClass() && element->classNames().contains(m_className))
-        return element;
-    }
-    return nullptr;
-  }
-
-  const AtomicString& m_className;
-  Member<ContainerNode> m_rootNode;
-  Member<Element> m_currentElement;
-};
+// TODO(esprehn): Move this to Element and update callers elsewhere.
+inline bool hasClassName(const Element& element,
+                         const AtomicString& className) {
+  return element.hasClass() && element.classNames().contains(className);
+}
 
 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;
@@ skipping 32 matching lines @@
   NthIndexCache nthIndexCache(rootNode.document());
   Element* matchedElement = nullptr;
   execute<SingleElementSelectorQueryTrait>(rootNode, matchedElement);
   return matchedElement;
 }
 
 template <typename SelectorQueryTrait>
 static void collectElementsByClassName(
     ContainerNode& rootNode,
     const AtomicString& className,
+    const CSSSelector* selector,
     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;
-    }
+    if (!hasClassName(element, className))
+      continue;
+    if (selector && !selectorMatches(*selector, element, rootNode))
+      continue;
+    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
@@ skipping 33 matching lines @@
   return m_selectors.size() == 1;
 }
 
 inline bool ancestorHasClassName(ContainerNode& rootNode,
                                  const AtomicString& className) {
   if (!rootNode.isElementNode())
     return false;
 
   for (Element* element = &toElement(rootNode); element;
        element = element->parentElement()) {
-    if (element->hasClass() && element->classNames().contains(className))
+    if (hasClassName(*element, className))
       return true;
   }
   return false;
 }
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::findTraverseRootsAndExecute(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   // We need to return the matches in document order. To use id lookup while
@@ skipping 25 matching lines @@
         return;
       executeForTraverseRoot<SelectorQueryTrait>(*start, rootNode, output);
       return;
     }
 
     // If we have both CSSSelector::Id and CSSSelector::Class at the same time,
     // we should use Id to find traverse root.
     if (!SelectorQueryTrait::shouldOnlyMatchFirstElement && !startFromParent &&
         selector->match() == CSSSelector::Class) {
       if (isRightmostSelector) {
-        ClassElementList<AllElements> traverseRoots(rootNode,
-                                                    selector->value());
-        while (!traverseRoots.isEmpty()) {
-          Element& element = *traverseRoots.next();
-          if (selectorMatches(*m_selectors[0], element, rootNode))
-            SelectorQueryTrait::appendElement(output, element);
-        }
+        collectElementsByClassName<SelectorQueryTrait>(
+            rootNode, selector->value(), m_selectors[0], output);
         return;
       }
       // Since there exists some ancestor element which has the class name, we
       // need to see all children of rootNode.
       if (ancestorHasClassName(rootNode, selector->value()))
         break;
 
-      ClassElementList<OnlyRoots> traverseRoots(rootNode, selector->value());
-      while (!traverseRoots.isEmpty()) {
-        executeForTraverseRoot<SelectorQueryTrait>(*traverseRoots.next(),
-                                                   rootNode, output);
+      const AtomicString& className = selector->value();
+      Element* element = ElementTraversal::firstWithin(rootNode);
+      while (element) {
+        if (hasClassName(*element, className)) {
+          executeForTraverseRoot<SelectorQueryTrait>(*element, rootNode,
+                                                     output);
+          element = ElementTraversal::nextSkippingChildren(*element, &rootNode);
+        } else {
+          element = ElementTraversal::next(*element, &rootNode);
+        }
       }
       return;
     }
 
     if (selector->relation() == CSSSelector::SubSelector)
       continue;
     isRightmostSelector = false;
     if (selector->relation() == CSSSelector::DirectAdjacent ||
         selector->relation() == CSSSelector::IndirectAdjacent)
       startFromParent = true;
@@ skipping 173 matching lines @@
     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);
+            rootNode, firstSelector.value(), nullptr, output);
         return;
       case CSSSelector::Tag:
         if (firstSelector.tagQName().namespaceURI() == starAtom) {
           collectElementsByTagName<SelectorQueryTrait>(
               rootNode, firstSelector.tagQName(), output);
           return;
         }
         // querySelector*() doesn't allow namespace prefix resolution and
         // throws before we get here, but we still may have selectors for
         // elements without a namespace.
@@ skipping 61 matching lines @@
   return m_entries
       .insert(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink