Allow [id=X] selectors to use the querySelector ID fast path.

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.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/dom/SelectorQuery.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "core/HTMLNames.h"
 #include "core/css/SelectorChecker.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Node.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
+using namespace HTMLNames;
+
 struct SingleElementSelectorQueryTrait {
     typedef Element* OutputType;
     static const bool shouldOnlyMatchFirstElement = true;
     ALWAYS_INLINE static void appendElement(OutputType& output, Element& element)
     {
         DCHECK(!output);
         output = &element;
     }
 };
 
@@ skipping 383 matching lines @@
 {
     for (ContainerNode* node = firstWithinTraversingShadowTree(rootNode); node; node = nextTraversingShadowTree(*node, &rootNode)) {
         if (!node->isElementNode())
             continue;
         Element* element = toElement(node);
         if (selectorListMatches<SelectorQueryTrait>(rootNode, *element, output) && SelectorQueryTrait::shouldOnlyMatchFirstElement)
             return;
     }
 }
 
-const CSSSelector* SelectorDataList::selectorForIdLookup(const CSSSelector& firstSelector) const
+static const CSSSelector* selectorForIdLookup(const CSSSelector& firstSelector)
 {
     for (const CSSSelector* selector = &firstSelector; selector; selector = selector->tagHistory()) {
         if (selector->match() == CSSSelector::Id)
             return selector;
+        // 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 (selector->match() == CSSSelector::AttributeExact
+            && selector->attribute() == idAttr
+            && selector->attributeMatch() == CSSSelector::CaseSensitive)
+            return selector;

[sashab, 2016/07/12 01:37:03]

Would it be worth adding a StyleResolverStats for when this fast path is
triggered?

[esprehn, 2016/07/12 01:39:15]

It would be worth adding some metrics, but StyleResolverStats are only reported
from inside updateStyle so this wouldn't ever show up there since it's inside
querySelector(All). Recording a trace for every querySelector would probably be
pretty expensive, maybe a disabled by default one. We should consider that for a
future patch. :)

         if (selector->relation() != CSSSelector::SubSelector)
             break;
     }
     return nullptr;
 }
 
 template <typename SelectorQueryTrait>
 void SelectorDataList::execute(ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
 {
     if (m_selectors.isEmpty())
         return;
 
     if (!canUseFastQuery(rootNode)) {
         if (m_needsUpdatedDistribution)
             rootNode.updateDistribution();
         if (m_usesDeepCombinatorOrShadowPseudo) {
             executeSlowTraversingShadowTree<SelectorQueryTrait>(rootNode, output);
         } else {
             executeSlow<SelectorQueryTrait>(rootNode, output);
         }
         return;
     }
 
     DCHECK_EQ(m_selectors.size(), 1u);
+    DCHECK(!rootNode.document().inQuirksMode());
 
     const CSSSelector& selector = *m_selectors[0];
     const CSSSelector& firstSelector = selector;
 
-    // Fast path for querySelector*('#id'), querySelector*('tag#id').
+    // 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);
             size_t count = elements.size();
             for (size_t i = 0; i < count; ++i) {
                 Element& element = *elements[i];
                 if (!(isTreeScopeRoot(rootNode) || element.isDescendantOf(&rootNode)))
                     continue;
                 if (selectorMatches(selector, element, rootNode)) {
@@ skipping 86 matching lines @@
 
     return m_entries.add(selectors, SelectorQuery::adopt(std::move(selectorList))).storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate()
 {
     m_entries.clear();
 }
 
 } // namespace blink