Match 'i' attribute selector modifier case-insensitively

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 590 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 (String(flag.value()) == "i")
+    if (flag.valueEqualsIgnoringASCIICase("i"))

[rune, 2016/01/22 21:48:01]

Briefly looking through the relevant specs, it seems every keyword is supposed
to be matched ascii-case-insensitively. Looking at the use of
valueEqualsIgnoringCase/equalsIgnoringCase, it seems it should always have been
valueEqualsIgnoringASCIICase/equalsIgnoringASCIICase.

If so, could we just get rid of the unicode-case-insensitive matching functions?

[fs, 2016/01/22 23:53:17]

I was hoping we could. I was planning on doing that in follow-up CLs (want this
as pristine as possible since I want to try to merge it to M49) - not looking
forward to chasing testcases for all uses though, so hopefully we can punt on
those a bit... (else I'll need to read the case-folding tables very
thoroughly...)

[rune, 2016/01/24 10:46:26]

In another context I was trying to find out if we case folding were we'd make
'i' 'I' case-equal to some other character, and couldn't. Maybe you could just
use valueEqualsIgnoringCase for this CL instead?

[fs, 2016/01/25 09:47:19]

If you look at the TC I added, you'll see one example of a non-ascii char that
maps to lower-case ('i') and one that maps to upper-case ('I'):

http://www.fileformat.info/info/unicode/char/0130/index.htm
http://www.fileformat.info/info/unicode/char/0131/index.htm

I did consider just using valueEqualsIgnoringCase "for now" though since that
would mean a trivial backport (merge). This is not that much larger though, so
it felt reasonable to "set the example" =). (Also, you newer know what level of
picky reviewers will choose ;-))

[rune, 2016/01/25 10:15:29]

I ran your new cases locally, and those test pass with valueEqualsIgnoringCase.
We do a simpler for of folding than what's required to make those fail, I think.

[fs, 2016/01/25 11:30:31]

Ok, so looks like it pans out fine in these cases, so I guess we can run with
scissors for a while longer.

         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()));
@@ skipping 141 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