NOT FOR LANDING: Hack up CSSParser for speed.

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)
+    : m_string(string)
 {
     // According to the spec, we should perform preprocessing here.
     // See: http://dev.w3.org/csswg/css-syntax/#input-preprocessing
     //
     // However, we can skip this step since:
     // * We're using HTML spaces (which accept \r and \f as a valid white space)
     // * Do not count white spaces
     // * CSSTokenizerInputStream::peek replaces NULLs for replacement characters
 
     if (string.isEmpty())
         return;
 
     // To avoid resizing we err on the side of reserving too much space.
     // Most strings we tokenize have about 3.5 to 5 characters per token.
     m_tokens.reserveInitialCapacity(string.length() / 3);
 
     CSSTokenizerInputStream input(string);
     CSSTokenizer tokenizer(input, *this);
     while (true) {
         CSSParserToken token = tokenizer.nextToken();
         if (token.type() == CommentToken)
             continue;
         if (token.type() == EOFToken)
             return;
         m_tokens.append(token);
     }
 }
 
 CSSTokenizer::Scope::Scope(const String& string, CSSParserObserverWrapper& wrapper)
-: m_string(string)
+    : m_string(string)
 {
     if (string.isEmpty())
         return;
 
     CSSTokenizerInputStream input(string);
     CSSTokenizer tokenizer(input, *this);
 
     unsigned offset = 0;
     while (true) {
         CSSParserToken token = tokenizer.nextToken();
         if (token.type() == EOFToken)
             break;
         if (token.type() == CommentToken) {
             wrapper.addComment(offset, input.offset(), m_tokens.size());
         } else {
             m_tokens.append(token);
             wrapper.addToken(offset);
         }
         offset = input.offset();
     }
 
     wrapper.addToken(offset);
     wrapper.finalizeConstruction(m_tokens.begin());
 }
 
 CSSParserTokenRange CSSTokenizer::Scope::tokenRange()
 {
-    return m_tokens;
+    return CSSParserTokenRange(m_tokens.begin(), m_tokens.end());
 }
 
 unsigned CSSTokenizer::Scope::tokenCount()
 {
     return m_tokens.size();
 }
 
 static bool isNewLine(UChar cc)
 {
     // We check \r and \f here, since we have no preprocessing stage
@@ skipping 28 matching lines @@
 {
     m_input.advance(offset);
 }
 
 CSSParserToken CSSTokenizer::whiteSpace(UChar cc)
 {
     consumeUntilNonWhitespace();
     return CSSParserToken(WhitespaceToken);
 }
 
-static bool popIfBlockMatches(Vector<CSSParserTokenType>& blockStack, CSSParserTokenType type)
+static bool popIfBlockMatches(Vector<CSSParserTokenType, 8>& blockStack, CSSParserTokenType type)
 {
     if (!blockStack.isEmpty() && blockStack.last() == type) {
         blockStack.removeLast();
         return true;
     }
     return false;
 }
 
 CSSParserToken CSSTokenizer::blockStart(CSSParserTokenType type)
 {
@@ skipping 212 matching lines @@
 CSSParserToken CSSTokenizer::nextToken()
 {
     // Unlike the HTMLTokenizer, the CSS Syntax spec is written
     // as a stateless, (fixed-size) look-ahead tokenizer.
     // We could move to the stateful model and instead create
     // states for all the "next 3 codepoints are X" cases.
     // State-machine tokenizers are easier to write to handle
     // incremental tokenization of partial sources.
     // However, for now we follow the spec exactly.
     UChar cc = consume();
-    CodePoint codePointFunc = 0;
 
-    if (isASCII(cc)) {
-        ASSERT_WITH_SECURITY_IMPLICATION(cc < codePointsNumber);
-        codePointFunc = codePoints[cc];
-    } else {
-        codePointFunc = &CSSTokenizer::nameStart;
+    switch (cc) {
+    case 0:
+        return endOfFile(cc);
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+        return CSSParserToken(DelimiterToken, cc);

[esprehn, 2016/04/22 23:30:58]

Skip the virtual call overhead of the lookup table. This also means we don't
need to pass arguments into the functions like comma() which don't need it.

[Timothy Loh, 2016/04/27 06:52:05]

This is definitely an improvement (I think using code generation to make the
lookup table is just unneeded complexity), but I'm not convinced this will
actually make any performance difference.

+    case 9:
+    case 10:
+        return whiteSpace(cc);
+    case 11:
+        return CSSParserToken(DelimiterToken, cc);
+    case 12:
+    case 13:
+        return whiteSpace(cc);
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+    case 28:
+    case 29:
+    case 30:
+    case 31:
+        return CSSParserToken(DelimiterToken, cc);
+    case 32:
+        return whiteSpace(cc);
+    case 33:
+        return CSSParserToken(DelimiterToken, cc);
+    case 34:
+        return stringStart(cc);
+    case 35:
+        return hash(cc);
+    case 36:
+        return dollarSign(cc);
+    case 37:
+    case 38:
+        return CSSParserToken(DelimiterToken, cc);
+    case 39:
+        return stringStart(cc);
+    case 40:
+        return leftParenthesis(cc);
+    case 41:
+        return rightParenthesis(cc);
+    case 42:
+        return asterisk(cc);
+    case 43:
+        return plusOrFullStop(cc);
+    case 44:
+        return comma(cc);
+    case 45:
+        return hyphenMinus(cc);
+    case 46:
+        return plusOrFullStop(cc);
+    case 47:
+        return solidus(cc);
+    case 48:
+    case 49:
+    case 50:
+    case 51:
+    case 52:
+    case 53:
+    case 54:
+    case 55:
+    case 56:
+    case 57:
+        return asciiDigit(cc);
+    case 58:
+        return colon(cc);
+    case 59:
+        return semiColon(cc);
+    case 60:
+        return lessThan(cc);
+    case 61:
+    case 62:
+    case 63:
+        return CSSParserToken(DelimiterToken, cc);
+    case 64:
+        return commercialAt(cc);
+    case 65:
+    case 66:
+    case 67:
+    case 68:
+    case 69:
+    case 70:
+    case 71:
+    case 72:
+    case 73:
+    case 74:
+    case 75:
+    case 76:
+    case 77:
+    case 78:
+    case 79:
+    case 80:
+    case 81:
+    case 82:
+    case 83:
+    case 84:
+        return nameStart(cc);
+    case 85:
+        return letterU(cc);
+    case 86:
+    case 87:
+    case 88:
+    case 89:
+    case 90:
+        return nameStart(cc);
+    case 91:
+        return leftBracket(cc);
+    case 92:
+        return reverseSolidus(cc);
+    case 93:
+        return rightBracket(cc);
+    case 94:
+        return circumflexAccent(cc);
+    case 95:
+        return nameStart(cc);
+    case 96:
+        return CSSParserToken(DelimiterToken, cc);
+    case 97:
+    case 98:
+    case 99:
+    case 100:
+    case 101:
+    case 102:
+    case 103:
+    case 104:
+    case 105:
+    case 106:
+    case 107:
+    case 108:
+    case 109:
+    case 110:
+    case 111:
+    case 112:
+    case 113:
+    case 114:
+    case 115:
+    case 116:
+        return nameStart(cc);
+    case 117:
+        return letterU(cc);
+    case 118:
+    case 119:
+    case 120:
+    case 121:
+    case 122:
+        return nameStart(cc);
+    case 123:
+        return leftBrace(cc);
+    case 124:
+        return verticalLine(cc);
+    case 125:
+        return rightBrace(cc);
+    case 126:
+        return tilde(cc);
+    case 127:
+        return CSSParserToken(DelimiterToken, cc);
     }
 
-    if (codePointFunc)
-        return ((this)->*(codePointFunc))(cc);
-    return CSSParserToken(DelimiterToken, cc);
+    ASSERT(!isASCII(cc));
+    return nameStart(cc);
 }
 
 static NumericSign getSign(CSSTokenizerInputStream& input, unsigned& offset)
 {
     if (input.nextInputChar() == '+') {
         ++offset;
         return PlusSign;
     }
     if (input.nextInputChar() == '-') {
         ++offset;
@@ skipping 229 matching lines @@
 {
     while (true) {
         UChar cc = consume();
         if (cc == ')' || cc == kEndOfFileMarker)
             return;
         if (twoCharsAreValidEscape(cc, m_input.nextInputChar()))
             consumeEscape();
     }
 }
 
-void CSSTokenizer::consumeUntilNonWhitespace()
+ALWAYS_INLINE void CSSTokenizer::consumeUntilNonWhitespace()
 {
     // Using HTML space here rather than CSS space since we don't do preprocessing
     while (isHTMLSpace<UChar>(m_input.nextInputChar()))
         consume();
 }
 
 void CSSTokenizer::consumeSingleWhitespaceIfNext()
 {
     // We check for \r\n and HTML spaces since we don't do preprocessing
     UChar c = m_input.nextInputChar();
@@ skipping 109 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)
 {
+    if (isNameStartCodePoint(first))
+        return true;
+
     UChar second = m_input.nextInputChar();
-    if (isNameStartCodePoint(first) || twoCharsAreValidEscape(first, second))
+    if (twoCharsAreValidEscape(first, second))
         return true;
 
     if (first == '-')
         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