Test cases for querySelector fast paths.

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 27 matching lines @@
 #include "core/dom/NthIndexCache.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
+#if DCHECK_IS_ON()
+static SelectorQuery::QueryStats& currentQueryStats() {
+  DEFINE_STATIC_LOCAL(SelectorQuery::QueryStats, stats, ());
+  return stats;
+}
+
+SelectorQuery::QueryStats SelectorQuery::lastQueryStats() {
+  return currentQueryStats();
+}
+
+#define QUERY_STATS_INCREMENT(name) \
+  (void)(currentQueryStats().totalCount++, currentQueryStats().name++);
+#define QUERY_STATS_RESET() (void)(currentQueryStats() = {});
+
+#else
+
+#define QUERY_STATS_INCREMENT(name)
+#define QUERY_STATS_RESET()
+
+#endif
+
 struct SingleElementSelectorQueryTrait {
   typedef Element* OutputType;
   static const bool shouldOnlyMatchFirstElement = true;
   ALWAYS_INLINE static void appendElement(OutputType& output,
                                           Element& element) {
     DCHECK(!output);
     output = &element;
   }
 };
 
@@ skipping 19 matching lines @@
   init.mode = SelectorChecker::QueryingRules;
   SelectorChecker checker(init);
   SelectorChecker::SelectorCheckingContext context(
       &element, SelectorChecker::VisitedMatchDisabled);
   context.selector = &selector;
   context.scope = &rootNode;
   return checker.match(context);
 }
 
 bool SelectorQuery::matches(Element& targetElement) const {
+  QUERY_STATS_RESET();
   if (m_needsUpdatedDistribution)
     targetElement.updateDistribution();
   return selectorListMatches(targetElement, targetElement);
 }
 
 Element* SelectorQuery::closest(Element& targetElement) const {
+  QUERY_STATS_RESET();
   if (m_selectors.isEmpty())
     return nullptr;
   if (m_needsUpdatedDistribution)
     targetElement.updateDistribution();
 
   for (Element* currentElement = &targetElement; currentElement;
        currentElement = currentElement->parentElement()) {
     if (selectorListMatches(targetElement, *currentElement))
       return currentElement;
   }
   return nullptr;
 }
 
 StaticElementList* SelectorQuery::queryAll(ContainerNode& rootNode) const {
+  QUERY_STATS_RESET();
   NthIndexCache nthIndexCache(rootNode.document());
   HeapVector<Member<Element>> result;
   execute<AllElementsSelectorQueryTrait>(rootNode, result);
   return StaticElementList::adopt(result);
 }
 
 Element* SelectorQuery::queryFirst(ContainerNode& rootNode) const {
+  QUERY_STATS_RESET();
   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)) {
+    QUERY_STATS_INCREMENT(fastClass);
     if (!hasClassName(element, className))
       continue;
     if (selector && !selectorMatches(*selector, element, rootNode))
       continue;
     SelectorQueryTrait::appendElement(output, element);
     if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
@@ skipping 12 matching lines @@
   return false;
 }
 
 template <typename SelectorQueryTrait>
 static void collectElementsByTagName(
     ContainerNode& rootNode,
     const QualifiedName& tagName,
     typename SelectorQueryTrait::OutputType& output) {
   DCHECK_EQ(tagName.namespaceURI(), starAtom);
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
+    QUERY_STATS_INCREMENT(fastTagName);
     if (matchesTagName(tagName, element)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
 inline bool SelectorQuery::canUseFastQuery(
     const ContainerNode& rootNode) const {
@@ skipping 100 matching lines @@
 template <typename SelectorQueryTrait>
 void SelectorQuery::executeForTraverseRoot(
     ContainerNode& traverseRoot,
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   DCHECK_EQ(m_selectors.size(), 1u);
 
   const CSSSelector& selector = *m_selectors[0];
 
   for (Element& element : ElementTraversal::descendantsOf(traverseRoot)) {
+    QUERY_STATS_INCREMENT(fastScan);
     if (selectorMatches(selector, element, rootNode)) {
       SelectorQueryTrait::appendElement(output, element);
       if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
 bool SelectorQuery::selectorListMatches(ContainerNode& rootNode,
                                         Element& element) const {
   for (const auto& selector : m_selectors) {
     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)) {
+    QUERY_STATS_INCREMENT(slowScan);
     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,
@@ skipping 40 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;
+    QUERY_STATS_INCREMENT(slowTraversingShadowTreeScan);
     Element* element = toElement(node);
     if (!selectorListMatches(rootNode, *element))
       continue;
     SelectorQueryTrait::appendElement(output, *element);
     if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 static const CSSSelector* selectorForIdLookup(
@@ skipping 41 matching lines @@
   // Fast path for querySelector*('#id'), querySelector*('tag#id'),
   // querySelector*('tag[id=example]').
   if (const CSSSelector* idSelector = selectorForIdLookup(firstSelector)) {
     const AtomicString& idToMatch = idSelector->value();
     if (rootNode.treeScope().containsMultipleElementsWithId(idToMatch)) {
       const HeapVector<Member<Element>>& elements =
           rootNode.treeScope().getAllElementsById(idToMatch);
       for (const auto& element : elements) {
         if (!element->isDescendantOf(&rootNode))
           continue;
+        QUERY_STATS_INCREMENT(fastId);
         if (selectorMatches(selector, *element, rootNode)) {
           SelectorQueryTrait::appendElement(output, *element);
           if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
             return;
         }
       }
       return;
     }
     Element* element = rootNode.treeScope().getElementById(idToMatch);
     if (!element)
       return;
     if (!element->isDescendantOf(&rootNode))
       return;
+    QUERY_STATS_INCREMENT(fastId);
     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>(
@@ skipping 72 matching lines @@
   return m_entries
       .insert(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink