Separate the id fast path in SelectorQuery.

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/SelectorQuery.h"
 
 #include <memory>
 #include "core/css/parser/CSSParser.h"
 #include "core/css/parser/CSSParserContext.h"
 #include "core/dom/Document.h"
@@ skipping 121 matching lines @@
       // Id in right most selector fast path.
       {"#A", false, 1, {1, 1, 0, 0, 0, 0, 0}},
       {"#multiple", false, 1, {1, 1, 0, 0, 0, 0, 0}},
       {"#multiple.two", false, 1, {1, 1, 0, 0, 0, 0, 0}},
       {"#multiple", true, 2, {2, 2, 0, 0, 0, 0, 0}},
       {"span#multiple", true, 1, {2, 2, 0, 0, 0, 0, 0}},
       {"#multiple.two", true, 2, {2, 2, 0, 0, 0, 0, 0}},
       {"body #multiple", false, 1, {1, 1, 0, 0, 0, 0, 0}},
       {"body span#multiple", false, 1, {2, 2, 0, 0, 0, 0, 0}},
       {"body #multiple", true, 2, {2, 2, 0, 0, 0, 0, 0}},
+      {"[id=multiple]", true, 2, {2, 2, 0, 0, 0, 0, 0}},
+      {"body [id=multiple]", true, 2, {2, 2, 0, 0, 0, 0, 0}},
 
       // Single selector tag fast path.
       {"span", false, 1, {4, 0, 0, 4, 0, 0, 0}},
       {"span", true, 9, {14, 0, 0, 14, 0, 0, 0}},
 
       // Single selector class fast path.
       {".two", false, 1, {6, 0, 6, 0, 0, 0, 0}},
       {".two", true, 4, {14, 0, 14, 0, 0, 0, 0}},
 
       // Class in the right most selector fast path.
-      {"body .two", false, 1, {6, 0, 0, 0, 6, 0, 0}},
-      {"div .two", false, 1, {12, 0, 0, 0, 12, 0, 0}},
+      {"body .two", false, 1, {6, 0, 6, 0, 0, 0, 0}},
+      {"div .two", false, 1, {12, 0, 12, 0, 0, 0, 0}},
 
       // Classes in the right most selector for querySelectorAll use a fast
       // path.
       {"body .two", true, 4, {14, 0, 14, 0, 0, 0, 0}},
       {"div .two", true, 2, {14, 0, 14, 0, 0, 0, 0}},
 
-      // TODO: querySelector disables the class fast path to favor the id, but
-      // this means some selectors always end up doing fastScan.
-      {"#second .two", false, 1, {2, 0, 0, 0, 2, 0, 0}},
-
-      // TODO(esprehn): This should have used getElementById instead of doing
-      // a fastClass scan. It could have looked at 4 elements instead.
-      {"#second .two", true, 2, {14, 0, 14, 0, 0, 0, 0}},
+      // TODO: We could use the fast class path to find the elements inside
+      // the id scope instead of the fast scan.
+      {"#second .two", false, 1, {3, 1, 0, 0, 2, 0, 0}},
+      {"#second .two", true, 2, {5, 1, 0, 0, 4, 0, 0}},
 
       // We combine the class fast path with the fast scan mode when possible.
-      {".B span", false, 1, {11, 0, 0, 0, 11, 0, 0}},
+      {".B span", false, 1, {11, 0, 10, 0, 1, 0, 0}},
       {".B span", true, 4, {14, 0, 10, 0, 4, 0, 0}},
 
       // We expand the scope of id selectors when affected by an adjectent
       // combinator.
-      {"#c + :last-child", false, 1, {4, 0, 0, 0, 4, 0, 0}},
-      {"#a ~ :last-child", false, 1, {4, 0, 0, 0, 4, 0, 0}},
-      {"#c + div", true, 1, {4, 0, 0, 0, 4, 0, 0}},
-      {"#a ~ span", true, 2, {4, 0, 0, 0, 4, 0, 0}},
+      {"#c + :last-child", false, 1, {5, 1, 0, 0, 4, 0, 0}},
+      {"#a ~ :last-child", false, 1, {5, 1, 0, 0, 4, 0, 0}},
+      {"#c + div", true, 1, {5, 1, 0, 0, 4, 0, 0}},
+      {"#a ~ span", true, 2, {5, 1, 0, 0, 4, 0, 0}},
 
       // We only expand the scope for id selectors if they're directly affected
       // the adjacent combinator.
-      {"#first span + span", false, 1, {2, 0, 0, 0, 2, 0, 0}},
-      {"#first span ~ span", false, 1, {2, 0, 0, 0, 2, 0, 0}},
-      {"#second span + span", true, 3, {4, 0, 0, 0, 4, 0, 0}},
-      {"#second span ~ span", true, 3, {4, 0, 0, 0, 4, 0, 0}},
+      {"#first span + span", false, 1, {3, 1, 0, 0, 2, 0, 0}},
+      {"#first span ~ span", false, 1, {3, 1, 0, 0, 2, 0, 0}},
+      {"#second span + span", true, 3, {5, 1, 0, 0, 4, 0, 0}},
+      {"#second span ~ span", true, 3, {5, 1, 0, 0, 4, 0, 0}},
 
       // We disable the fast path for class selectors when affected by adjacent
       // combinator.
       {".one + :last-child", false, 1, {8, 0, 0, 0, 8, 0, 0}},
       {".A ~ :last-child", false, 1, {9, 0, 0, 0, 9, 0, 0}},
       {".A + div", true, 1, {14, 0, 0, 0, 14, 0, 0}},
       {".one ~ span", true, 5, {14, 0, 0, 0, 14, 0, 0}},
 
       // We re-enable the fast path for classes once past the selector directly
       // affected by the adjacent combinator.
@@ skipping 66 matching lines @@
       // If an ancestor has the class name we fast scan all the descendants of
       // the scope.
       {".root-class span", true, 4, {7, 0, 0, 0, 7, 0, 0}},
 
       // If an ancestor has the class name in the middle of the selector we fast
       // scan all the descendants of the scope.
       {".root-class span:nth-child(2)", false, 1, {2, 0, 0, 0, 2, 0, 0}},
       {".root-class span:nth-child(2)", true, 1, {7, 0, 0, 0, 7, 0, 0}},
 
       // If the id is an ancestor we scan all the descendants.
-      {"#root-id span", true, 4, {7, 0, 0, 0, 7, 0, 0}},
+      {"#root-id span", true, 4, {8, 1, 0, 0, 7, 0, 0}},
   };
 
   {
     SCOPED_TRACE("Inside document");
     RunTests(*scope, kTestCases);
   }
 
   {
     // Run all the tests a second time but with a scope inside a shadow root,
     // all the fast paths should behave the same.
@@ skipping 15 matching lines @@
       "      <span id=one class=tWo></span>"
       "    </span>"
       "  </body>"
       "</html>");
   static const struct QueryTest kTestCases[] = {
       // Quirks mode always uses the slow path.
       {"#one", false, 1, {5, 0, 0, 0, 0, 5, 0}},
       {"#One", false, 1, {5, 0, 0, 0, 0, 5, 0}},
       {"#ONE", false, 1, {5, 0, 0, 0, 0, 5, 0}},
       {"#ONE", true, 2, {6, 0, 0, 0, 0, 6, 0}},
+      {"[id=One]", false, 1, {5, 0, 0, 0, 0, 5, 0}},
+      {"[id=One]", true, 1, {6, 0, 0, 0, 0, 6, 0}},
       {"span", false, 1, {4, 0, 0, 0, 0, 4, 0}},
       {"span", true, 3, {6, 0, 0, 0, 0, 6, 0}},
       {".two", false, 1, {5, 0, 0, 0, 0, 5, 0}},
       {".two", true, 2, {6, 0, 0, 0, 0, 6, 0}},
       {"body #first", false, 1, {4, 0, 0, 0, 0, 4, 0}},
       {"body #one", true, 2, {6, 0, 0, 0, 0, 6, 0}},
   };
   RunTests(*document, kTestCases);
 }
 
@@ skipping 37 matching lines @@
   {
     // Run all the tests a second time but with a scope inside a shadow root,
     // this tests for cases where we could have used the id map the ShadowRoot
     // is keeping track of.
     SCOPED_TRACE("Inside disconnected shadow root subtree");
     RunTests(shadowRoot, kTestCases);
   }
 }
 
 }  // namespace blink