Improve named grid areas parsing

third_party/WebKit/Source/core/css/parser/CSSTokenizer.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/CSSTokenizer.h"
 
 namespace blink {
 #include "core/CSSTokenizerCodepoints.cpp"
 }
 
+#include "core/css/parser/CSSParserIdioms.h"
 #include "core/css/parser/CSSParserObserverWrapper.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSTokenizerInputStream.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 CSSTokenizer::Scope::Scope(const String& string)
 : m_string(string)
@@ skipping 55 matching lines @@
 CSSParserTokenRange CSSTokenizer::Scope::tokenRange()
 {
     return m_tokens;
 }
 
 unsigned CSSTokenizer::Scope::tokenCount()
 {
     return m_tokens.size();
 }
 
-// http://dev.w3.org/csswg/css-syntax/#name-start-code-point
-static bool isNameStart(UChar c)
-{
-    if (isASCIIAlpha(c))
-        return true;
-    if (c == '_')
-        return true;
-    return !isASCII(c);
-}
-
-// http://dev.w3.org/csswg/css-syntax/#name-code-point
-static bool isNameChar(UChar c)
-{
-    return isNameStart(c) || isASCIIDigit(c) || c == '-';
-}
-
 static bool isNewLine(UChar cc)
 {
     // We check \r and \f here, since we have no preprocessing stage
     return (cc == '\r' || cc == '\n' || cc == '\f');
 }
 
 // http://dev.w3.org/csswg/css-syntax/#check-if-two-code-points-are-a-valid-escape
 static bool twoCharsAreValidEscape(UChar first, UChar second)
 {
     return first == '\\' && !isNewLine(second);
@@ skipping 152 matching lines @@
 }
 
 CSSParserToken CSSTokenizer::semiColon(UChar cc)
 {
     return CSSParserToken(SemicolonToken);
 }
 
 CSSParserToken CSSTokenizer::hash(UChar cc)
 {
     UChar nextChar = m_input.nextInputChar();
-    if (isNameChar(nextChar) || twoCharsAreValidEscape(nextChar, m_input.peek(1))) {
+    if (isNameCodePoint(nextChar) || twoCharsAreValidEscape(nextChar, m_input.peek(1))) {
         HashTokenType type = nextCharsAreIdentifier() ? HashTokenId : HashTokenUnrestricted;
         return CSSParserToken(type, consumeName());
     }
 
     return CSSParserToken(DelimiterToken, cc);
 }
 
 CSSParserToken CSSTokenizer::circumflexAccent(UChar cc)
 {
     ASSERT(cc == '^');
@@ skipping 392 matching lines @@
 }
 
 // http://www.w3.org/TR/css3-syntax/#consume-a-name
 CSSParserString CSSTokenizer::consumeName()
 {
     // Names without escapes get handled without allocations
     for (unsigned size = 0; ; ++size) {
         UChar cc = m_input.peekWithoutReplacement(size);
         if (cc == '\0' || cc == '\\')
             break;
-        if (!isNameChar(cc)) {
+        if (!isNameCodePoint(cc)) {
             unsigned startOffset = m_input.offset();
             m_input.advance(size);
             return m_input.rangeAsCSSParserString(startOffset, size);
         }
     }
 
     StringBuilder result;
     while (true) {
         UChar cc = consume();
-        if (isNameChar(cc)) {
+        if (isNameCodePoint(cc)) {
             result.append(cc);
             continue;
         }
         if (twoCharsAreValidEscape(cc, m_input.nextInputChar())) {
             result.append(consumeEscape());
             continue;
         }
         reconsume(cc);
         return registerString(result.toString());
     }
@@ skipping 50 matching lines @@
     UChar first = consume();
     bool areNumber = nextCharsAreNumber(first);
     reconsume(first);
     return areNumber;
 }
 
 // http://dev.w3.org/csswg/css-syntax/#would-start-an-identifier
 bool CSSTokenizer::nextCharsAreIdentifier(UChar first)
 {
     UChar second = m_input.nextInputChar();
-    if (isNameStart(first) || twoCharsAreValidEscape(first, second))
+    if (isNameStartCodePoint(first) || twoCharsAreValidEscape(first, second))
         return true;
 
     if (first == '-')
-        return isNameStart(second) || second == '-' || nextTwoCharsAreValidEscape();
+        return isNameStartCodePoint(second) || second == '-' || nextTwoCharsAreValidEscape();
 
     return false;
 }
 
 bool CSSTokenizer::nextCharsAreIdentifier()
 {
     UChar first = consume();
     bool areIdentifier = nextCharsAreIdentifier(first);
     reconsume(first);
     return areIdentifier;
 }
 
 CSSParserString CSSTokenizer::registerString(const String& string)
 {
     m_scope.storeString(string);
     CSSParserString result;
     result.init(string);
     return result;
 }
 
 } // namespace blink