Reuse selectorListMatches for all loops over the selectors 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 103 matching lines @@
   SelectorChecker::SelectorCheckingContext context(
       &element, SelectorChecker::VisitedMatchDisabled);
   context.selector = &selector;
   context.scope = &rootNode;
   return checker.match(context);
 }
 
 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;
+  return selectorListMatches(targetElement, targetElement);
 }
 
 Element* SelectorQuery::closest(Element& targetElement) const {
   if (m_selectors.isEmpty())
     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;
-    }
+    if (selectorListMatches(targetElement, *currentElement))
+      return currentElement;
   }
   return nullptr;
 }
 
 StaticElementList* SelectorQuery::queryAll(ContainerNode& rootNode) const {
   NthIndexCache nthIndexCache(rootNode.document());
   HeapVector<Member<Element>> result;
   execute<AllElementsSelectorQueryTrait>(rootNode, result);
   return StaticElementList::adopt(result);
 }
@@ skipping 164 matching lines @@
 
   for (Element& element : ElementTraversal::descendantsOf(*traverseRoot)) {
     if (selectorMatches(selector, element, rootNode)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
-template <typename SelectorQueryTrait>
-bool SelectorQuery::selectorListMatches(
-    ContainerNode& rootNode,
-    Element& element,
-    typename SelectorQueryTrait::OutputType& output) const {
+bool SelectorQuery::selectorListMatches(ContainerNode& rootNode,
+                                        Element& element) const {
   for (const auto& selector : m_selectors) {
-    if (selectorMatches(*selector, element, rootNode)) {
-      SelectorQueryTrait::appendElement(output, element);
+    if (selectorMatches(*selector, element, rootNode))
       return true;
-    }
   }
   return false;
 }
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::executeSlow(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
-    if (selectorListMatches<SelectorQueryTrait>(rootNode, element, output) &&
-        SelectorQueryTrait::shouldOnlyMatchFirstElement)
+    if (!selectorListMatches(rootNode, element))
+      continue;
+    SelectorQueryTrait::appendElement(output, element);
+    if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 // FIXME: Move the following helper functions, authorShadowRootOf,
 // firstWithinTraversingShadowTree, nextTraversingShadowTree to the best place,
 // e.g. NodeTraversal.
 static ShadowRoot* authorShadowRootOf(const ContainerNode& node) {
   if (!node.isElementNode())
     return nullptr;
@@ skipping 37 matching lines @@
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::executeSlowTraversingShadowTree(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   for (ContainerNode* node = nextTraversingShadowTree(rootNode, &rootNode);
        node; node = nextTraversingShadowTree(*node, &rootNode)) {
     if (!node->isElementNode())
       continue;
     Element* element = toElement(node);
-    if (selectorListMatches<SelectorQueryTrait>(rootNode, *element, output) &&
-        SelectorQueryTrait::shouldOnlyMatchFirstElement)
+    if (!selectorListMatches(rootNode, *element))
+      continue;
+    SelectorQueryTrait::appendElement(output, *element);
+    if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 static const CSSSelector* selectorForIdLookup(
     const CSSSelector& firstSelector) {
   for (const CSSSelector* selector = &firstSelector; selector;
        selector = selector->tagHistory()) {
     if (selector->match() == CSSSelector::Id)
       return selector;
@@ skipping 141 matching lines @@
   return m_entries
       .insert(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink