Allow using SelectorQuery fast paths in quirks mode and disconnected subtrees.

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 23 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Node.h"
 #include "core/dom/NthIndexCache.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "platform/wtf/PtrUtil.h"
 
+// Uncomment to run the SelectorQueryTests for stats in a release build.
+// #define RELEASE_QUERY_STATS
+
 namespace blink {
 
 using namespace HTMLNames;
 
-#if DCHECK_IS_ON()
+#if DCHECK_IS_ON() || defined(RELEASE_QUERY_STATS)
 static SelectorQuery::QueryStats& CurrentQueryStats() {
   DEFINE_STATIC_LOCAL(SelectorQuery::QueryStats, stats, ());
   return stats;
 }
 
 SelectorQuery::QueryStats SelectorQuery::LastQueryStats() {
   return CurrentQueryStats();
 }
 
 #define QUERY_STATS_INCREMENT(name) \
@@ skipping 131 matching lines @@
   for (Element& element : ElementTraversal::DescendantsOf(root_node)) {
     QUERY_STATS_INCREMENT(fast_tag_name);
     if (MatchesTagName(tag_name, element)) {
       SelectorQueryTrait::AppendElement(output, element);
       if (SelectorQueryTrait::kShouldOnlyMatchFirstElement)
         return;
     }
   }
 }
 
-inline bool SelectorQuery::CanUseFastQuery(
-    const ContainerNode& root_node) const {
-  if (uses_deep_combinator_or_shadow_pseudo_)
-    return false;
-  if (needs_updated_distribution_)
-    return false;
-  if (root_node.GetDocument().InQuirksMode())
-    return false;
-  if (!root_node.isConnected())
-    return false;
-  return selectors_.size() == 1;
-}
-
 inline bool AncestorHasClassName(ContainerNode& root_node,
                                  const AtomicString& class_name) {
   if (!root_node.IsElementNode())
     return false;
 
   for (Element* element = &ToElement(root_node); element;
        element = element->parentElement()) {
     if (HasClassName(*element, class_name))
       return true;
   }
@@ skipping 157 matching lines @@
     SelectorQueryTrait::AppendElement(output, *element);
     if (SelectorQueryTrait::kShouldOnlyMatchFirstElement)
       return;
   }
 }
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::ExecuteWithId(
     ContainerNode& root_node,
     typename SelectorQueryTrait::OutputType& output) const {
+  DCHECK_EQ(selectors_.size(), 1u);
+  DCHECK(!root_node.GetDocument().InQuirksMode());
+
   const CSSSelector& first_selector = *selectors_[0];
   const TreeScope& scope = root_node.ContainingTreeScope();
 
   if (scope.ContainsMultipleElementsWithId(selector_id_)) {
     // We don't currently handle cases where there's multiple elements with the
     // id and it's not in the rightmost selector.
     if (!selector_id_is_rightmost_) {
       FindTraverseRootsAndExecute<SelectorQueryTrait>(root_node, output);
       return;
     }
@@ skipping 33 matching lines @@
   ExecuteForTraverseRoot<SelectorQueryTrait>(*start, root_node, output);
 }
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::Execute(
     ContainerNode& root_node,
     typename SelectorQueryTrait::OutputType& output) const {
   if (selectors_.IsEmpty())
     return;
 
-  if (!CanUseFastQuery(root_node)) {
+  if (use_slow_scan_) {
     if (needs_updated_distribution_)
       root_node.UpdateDistribution();
     if (uses_deep_combinator_or_shadow_pseudo_) {
       ExecuteSlowTraversingShadowTree<SelectorQueryTrait>(root_node, output);
     } else {
       ExecuteSlow<SelectorQueryTrait>(root_node, output);
     }
     return;
   }
 
   DCHECK_EQ(selectors_.size(), 1u);
-  DCHECK(!root_node.GetDocument().InQuirksMode());
+  DCHECK(!needs_updated_distribution_);
+  DCHECK(!uses_deep_combinator_or_shadow_pseudo_);
 
-  if (selector_id_) {
+  // In quirks mode getElementById("a") is case sensitive and should only
+  // match elements with lowercase id "a", but querySelector is case-insensitive
+  // so querySelector("#a") == querySelector("#A"), which means we can only use
+  // the id fast path when we're in a standards mode document.
+  if (selector_id_ && root_node.IsInTreeScope() &&
+      !root_node.GetDocument().InQuirksMode()) {
     ExecuteWithId<SelectorQueryTrait>(root_node, output);
     return;
   }
 
   const CSSSelector& first_selector = *selectors_[0];
   if (!first_selector.TagHistory()) {
     // Fast path for querySelector*('.foo'), and querySelector*('div').
     switch (first_selector.Match()) {
       case CSSSelector::kClass:
         CollectElementsByClassName<SelectorQueryTrait>(
@@ skipping 21 matching lines @@
 std::unique_ptr<SelectorQuery> SelectorQuery::Adopt(
     CSSSelectorList selector_list) {
   return WTF::WrapUnique(new SelectorQuery(std::move(selector_list)));
 }
 
 SelectorQuery::SelectorQuery(CSSSelectorList selector_list)
     : selector_list_(std::move(selector_list)),
       selector_id_is_rightmost_(true),
       selector_id_affected_by_sibling_combinator_(false),
       uses_deep_combinator_or_shadow_pseudo_(false),
-      needs_updated_distribution_(false) {
+      needs_updated_distribution_(false),
+      use_slow_scan_(true) {
   selectors_.ReserveInitialCapacity(selector_list_.ComputeLength());
   for (const CSSSelector* selector = selector_list_.First(); selector;
        selector = CSSSelectorList::Next(*selector)) {
     if (selector->MatchesPseudoElement())
       continue;
     selectors_.UncheckedAppend(selector);
     uses_deep_combinator_or_shadow_pseudo_ |=
         selector->HasDeepCombinatorOrShadowPseudo();
     needs_updated_distribution_ |= selector->NeedsUpdatedDistribution();
   }
 
   if (selectors_.size() == 1 && !uses_deep_combinator_or_shadow_pseudo_ &&
       !needs_updated_distribution_) {
+    use_slow_scan_ = false;
     for (const CSSSelector* current = selectors_[0]; current;
          current = current->TagHistory()) {
       if (current->Match() == CSSSelector::kId) {
         selector_id_ = current->Value();
         break;
       }
       // We only use the fast path when in standards mode where #id selectors
       // are case sensitive, so we need the same behavior for [id=value].
       if (current->Match() == CSSSelector::kAttributeExact &&
           current->Attribute() == idAttr &&
@@ skipping 44 matching lines @@
   return entries_
       .insert(selectors, SelectorQuery::Adopt(std::move(selector_list)))
       .stored_value->value.get();
 }
 
 void SelectorQueryCache::Invalidate() {
   entries_.clear();
 }
 
 }  // namespace blink