Use ASCII case-insensitive matching for ident-likes in the CSS parser

third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp

 // Copyright 2014 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/css/parser/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/frame/UseCounter.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 556 matching lines @@
         if (delimiter == '~')
             return CSSSelector::IndirectAdjacent;
         return CSSSelector::Child;
     }
 
     // Match /deep/
     if (delimiter != '/')
         return fallbackResult;
     range.consume();
     const CSSParserToken& ident = range.consume();
-    if (ident.type() != IdentToken || !ident.valueEqualsIgnoringCase("deep"))
+    if (ident.type() != IdentToken || !ident.valueEqualsIgnoringASCIICase("deep"))
         m_failedParsing = true;
     const CSSParserToken& slash = range.consumeIncludingWhitespace();
     if (slash.type() != DelimiterToken || slash.delimiter() != '/')
         m_failedParsing = true;
     return CSSSelector::ShadowDeep;
 }
 
 CSSSelector::Match CSSSelectorParser::consumeAttributeMatch(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.consumeIncludingWhitespace();
@@ skipping 15 matching lines @@
         m_failedParsing = true;
         return CSSSelector::AttributeExact;
     }
 }
 
 CSSSelector::AttributeMatchType CSSSelectorParser::consumeAttributeFlags(CSSParserTokenRange& range)
 {
     if (range.peek().type() != IdentToken)
         return CSSSelector::CaseSensitive;
     const CSSParserToken& flag = range.consumeIncludingWhitespace();
-    if (flag.valueEqualsIgnoringCase("i"))
+    if (flag.valueEqualsIgnoringASCIICase("i"))
         return CSSSelector::CaseInsensitive;
     m_failedParsing = true;
     return CSSSelector::CaseSensitive;
 }
 
 bool CSSSelectorParser::consumeANPlusB(CSSParserTokenRange& range, std::pair<int, int>& result)
 {
     const CSSParserToken& token = range.consume();
     if (token.type() == NumberToken && token.numericValueType() == IntegerValueType) {
         result = std::make_pair(0, static_cast<int>(token.numericValue()));
         return true;
     }
     if (token.type() == IdentToken) {
-        if (token.valueEqualsIgnoringCase("odd")) {
+        if (token.valueEqualsIgnoringASCIICase("odd")) {
             result = std::make_pair(2, 1);
             return true;
         }
-        if (token.valueEqualsIgnoringCase("even")) {
+        if (token.valueEqualsIgnoringASCIICase("even")) {
             result = std::make_pair(2, 0);
             return true;
         }
     }
 
     // The 'n' will end up as part of an ident or dimension. For a valid <an+b>,
     // this will store a string of the form 'n', 'n-', or 'n-123'.
     String nString;
 
     if (token.type() == DelimiterToken && token.delimiter() == '+' && range.peek().type() == IdentToken) {
@@ skipping 123 matching lines @@
 
     if (!splitAfter || !splitAfter->tagHistory())
         return compoundSelector;
 
     OwnPtr<CSSParserSelector> secondCompound = splitAfter->releaseTagHistory();
     secondCompound->appendTagHistory(secondCompound->pseudoType() == CSSSelector::PseudoSlotted ? CSSSelector::ShadowSlot : CSSSelector::ShadowPseudo, compoundSelector);
     return secondCompound.release();
 }
 
 } // namespace blink