Replace most callers of nextInputChar with peekWithoutReplacement in CSSTokenizer.

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"
 }
 
@@ skipping 228 matching lines @@
     return CSSParserToken(ColonToken);
 }
 
 CSSParserToken CSSTokenizer::semiColon(UChar cc)
 {
     return CSSParserToken(SemicolonToken);
 }
 
 CSSParserToken CSSTokenizer::hash(UChar cc)
 {
-    UChar nextChar = m_input.nextInputChar();
+    UChar nextChar = m_input.peekWithoutReplacement(0);
     if (isNameCodePoint(nextChar) || twoCharsAreValidEscape(nextChar, m_input.peekWithoutReplacement(1))) {
         HashTokenType type = nextCharsAreIdentifier() ? HashTokenId : HashTokenUnrestricted;
         return CSSParserToken(type, consumeName());
     }
 
     return CSSParserToken(DelimiterToken, cc);
 }
 
 CSSParserToken CSSTokenizer::circumflexAccent(UChar cc)
 {
@@ skipping 32 matching lines @@
 CSSParserToken CSSTokenizer::commercialAt(UChar cc)
 {
     ASSERT(cc == '@');
     if (nextCharsAreIdentifier())
         return CSSParserToken(AtKeywordToken, consumeName());
     return CSSParserToken(DelimiterToken, '@');
 }
 
 CSSParserToken CSSTokenizer::reverseSolidus(UChar cc)
 {
-    if (twoCharsAreValidEscape(cc, m_input.nextInputChar())) {
+    if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
         reconsume(cc);
         return consumeIdentLikeToken();
     }
     return CSSParserToken(DelimiterToken, cc);
 }
 
 CSSParserToken CSSTokenizer::asciiDigit(UChar cc)
 {
     reconsume(cc);
     return consumeNumericToken();
 }
 
 CSSParserToken CSSTokenizer::letterU(UChar cc)
 {
-    if (m_input.nextInputChar() == '+'
+    if (m_input.peekWithoutReplacement(0) == '+'
         && (isASCIIHexDigit(m_input.peekWithoutReplacement(1))
             || m_input.peekWithoutReplacement(1) == '?')) {
         m_input.advance();
         return consumeUnicodeRange();
     }
     reconsume(cc);
     return consumeIdentLikeToken();
 }
 
 CSSParserToken CSSTokenizer::nameStart(UChar cc)
@@ skipping 31 matching lines @@
         codePointFunc = &CSSTokenizer::nameStart;
     }
 
     if (codePointFunc)
         return ((this)->*(codePointFunc))(cc);
     return CSSParserToken(DelimiterToken, cc);
 }
 
 static NumericSign getSign(CSSTokenizerInputStream& input, unsigned& offset)
 {
-    if (input.nextInputChar() == '+') {
+    UChar next = input.peekWithoutReplacement(0);
+    if (next == '+') {
         ++offset;
         return PlusSign;
     }
-    if (input.nextInputChar() == '-') {
+    if (next == '-') {
         ++offset;
         return MinusSign;
     }
     return NoSign;
 }
 
 static double getInteger(CSSTokenizerInputStream& input, unsigned& offset)
 {
     unsigned intStartPos = offset;
     offset = input.skipWhilePredicate<isASCIIDigit>(offset);
@@ skipping 76 matching lines @@
 
 // http://dev.w3.org/csswg/css-syntax/#consume-ident-like-token
 CSSParserToken CSSTokenizer::consumeIdentLikeToken()
 {
     StringView name = consumeName();
     if (consumeIfNext('(')) {
         if (equalIgnoringASCIICase(name, "url")) {
             // The spec is slightly different so as to avoid dropping whitespace
             // tokens, but they wouldn't be used and this is easier.
             m_input.advanceUntilNonWhitespace();
-            UChar next = m_input.nextInputChar();
+            UChar next = m_input.peekWithoutReplacement(0);
             if (next != '"' && next != '\'')
                 return consumeUrlToken();
         }
         return blockStart(LeftParenthesisToken, FunctionToken, name);
     }
     return CSSParserToken(IdentToken, name);
 }
 
 // http://dev.w3.org/csswg/css-syntax/#consume-a-string-token
 CSSParserToken CSSTokenizer::consumeStringTokenUntil(UChar endingCodePoint)
@@ skipping 19 matching lines @@
         UChar cc = consume();
         if (cc == endingCodePoint || cc == kEndOfFileMarker)
             return CSSParserToken(StringToken, registerString(output.toString()));
         if (isNewLine(cc)) {
             reconsume(cc);
             return CSSParserToken(BadStringToken);
         }
         if (cc == '\\') {
             if (m_input.nextInputChar() == kEndOfFileMarker)
                 continue;
-            if (isNewLine(m_input.nextInputChar()))
+            if (isNewLine(m_input.peekWithoutReplacement(0)))
                 consumeSingleWhitespaceIfNext(); // This handles \r\n for us
             else
                 output.append(consumeEscape());
         } else {
             output.append(cc);
         }
     }
 }
 
 CSSParserToken CSSTokenizer::consumeUnicodeRange()
 {
-    ASSERT(isASCIIHexDigit(m_input.nextInputChar()) || m_input.nextInputChar() == '?');
+    DCHECK(isASCIIHexDigit(m_input.peekWithoutReplacement(0)) || m_input.peekWithoutReplacement(0) == '?');
     int lengthRemaining = 6;
     UChar32 start = 0;
 
-    while (lengthRemaining && isASCIIHexDigit(m_input.nextInputChar())) {
+    while (lengthRemaining && isASCIIHexDigit(m_input.peekWithoutReplacement(0))) {
         start = start * 16 + toASCIIHexValue(consume());
         --lengthRemaining;
     }
 
     UChar32 end = start;
     if (lengthRemaining && consumeIfNext('?')) {
         do {
             start *= 16;
             end = end * 16 + 0xF;
             --lengthRemaining;
         } while (lengthRemaining && consumeIfNext('?'));
-    } else if (m_input.nextInputChar() == '-' && isASCIIHexDigit(m_input.peekWithoutReplacement(1))) {
+    } else if (m_input.peekWithoutReplacement(0) == '-' && isASCIIHexDigit(m_input.peekWithoutReplacement(1))) {
         m_input.advance();
         lengthRemaining = 6;
         end = 0;
         do {
             end = end * 16 + toASCIIHexValue(consume());
             --lengthRemaining;
-        } while (lengthRemaining && isASCIIHexDigit(m_input.nextInputChar()));
+        } while (lengthRemaining && isASCIIHexDigit(m_input.peekWithoutReplacement(0)));
     }
 
     return CSSParserToken(UnicodeRangeToken, start, end);
 }
 
 // http://dev.w3.org/csswg/css-syntax/#non-printable-code-point
 static bool isNonPrintableCodePoint(UChar cc)
 {
     return (cc >= '\0' && cc <= '\x8') || cc == '\xb' || (cc >= '\xe' && cc <= '\x1f') || cc == '\x7f';
 }
@@ skipping 25 matching lines @@
             m_input.advanceUntilNonWhitespace();
             if (consumeIfNext(')') || m_input.nextInputChar() == kEndOfFileMarker)
                 return CSSParserToken(UrlToken, registerString(result.toString()));
             break;
         }
 
         if (cc == '"' || cc == '\'' || cc == '(' || isNonPrintableCodePoint(cc))
             break;
 
         if (cc == '\\') {
-            if (twoCharsAreValidEscape(cc, m_input.nextInputChar())) {
+            if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
                 result.append(consumeEscape());
                 continue;
             }
             break;
         }
 
         result.append(cc);
     }
 
     consumeBadUrlRemnants();
     return CSSParserToken(BadUrlToken);
 }
 
 // http://dev.w3.org/csswg/css-syntax/#consume-the-remnants-of-a-bad-url
 void CSSTokenizer::consumeBadUrlRemnants()
 {
     while (true) {
         UChar cc = consume();
         if (cc == ')' || cc == kEndOfFileMarker)
             return;
-        if (twoCharsAreValidEscape(cc, m_input.nextInputChar()))
+        if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0)))
             consumeEscape();
     }
 }
 
 void CSSTokenizer::consumeSingleWhitespaceIfNext()
 {
     // We check for \r\n and HTML spaces since we don't do preprocessing
-    UChar c = m_input.nextInputChar();
-    if (c == '\r' && m_input.peekWithoutReplacement(1) == '\n')
+    UChar next = m_input.peekWithoutReplacement(0);
+    if (next == '\r' && m_input.peekWithoutReplacement(1) == '\n')
         m_input.advance(2);
-    else if (isHTMLSpace(c))
+    else if (isHTMLSpace(next))
         m_input.advance();
 }
 
 void CSSTokenizer::consumeUntilCommentEndFound()
 {
     UChar c = consume();
     while (true) {
         if (c == kEndOfFileMarker)
             return;
         if (c != '*') {
             c = consume();
             continue;
         }
         c = consume();
         if (c == '/')
             return;
     }
 }
 
 bool CSSTokenizer::consumeIfNext(UChar character)
 {
-    if (m_input.nextInputChar() == character) {
+    // Since we're not doing replacement we can't tell the difference from
+    // a NUL in the middle and the kEndOfFileMarker, so character must not be
+    // NUL.
+    DCHECK(character);
+    if (m_input.peekWithoutReplacement(0) == character) {
         m_input.advance();
         return true;
     }
     return false;
 }
 
 // http://www.w3.org/TR/css3-syntax/#consume-a-name
 StringView CSSTokenizer::consumeName()
 {
     // Names without escapes get handled without allocations
@@ skipping 13 matching lines @@
         return m_input.rangeAt(startOffset, size);
     }
 
     StringBuilder result;
     while (true) {
         UChar cc = consume();
         if (isNameCodePoint(cc)) {
             result.append(cc);
             continue;
         }
-        if (twoCharsAreValidEscape(cc, m_input.nextInputChar())) {
+        if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
             result.append(consumeEscape());
             continue;
         }
         reconsume(cc);
         return registerString(result.toString());
     }
 }
 
 // http://dev.w3.org/csswg/css-syntax/#consume-an-escaped-code-point
 UChar32 CSSTokenizer::consumeEscape()
 {
     UChar cc = consume();
     ASSERT(!isNewLine(cc));
     if (isASCIIHexDigit(cc)) {
         unsigned consumedHexDigits = 1;
         StringBuilder hexChars;
         hexChars.append(cc);
-        while (consumedHexDigits < 6 && isASCIIHexDigit(m_input.nextInputChar())) {
+        while (consumedHexDigits < 6 && isASCIIHexDigit(m_input.peekWithoutReplacement(0))) {
             cc = consume();
             hexChars.append(cc);
             consumedHexDigits++;
         };
         consumeSingleWhitespaceIfNext();
         bool ok = false;
         UChar32 codePoint = hexChars.toString().toUIntStrict(&ok, 16);
         ASSERT(ok);
         if (codePoint == 0 || (0xD800 <= codePoint && codePoint <= 0xDFFF) || codePoint > 0x10FFFF)
             return replacementCharacter;
         return codePoint;
     }
 
     if (cc == kEndOfFileMarker)
         return replacementCharacter;
     return cc;
 }
 
 bool CSSTokenizer::nextTwoCharsAreValidEscape()
 {
-    return twoCharsAreValidEscape(m_input.nextInputChar(), m_input.peekWithoutReplacement(1));
+    return twoCharsAreValidEscape(m_input.peekWithoutReplacement(0), m_input.peekWithoutReplacement(1));
 }
 
 // http://www.w3.org/TR/css3-syntax/#starts-with-a-number
 bool CSSTokenizer::nextCharsAreNumber(UChar first)
 {
-    UChar second = m_input.nextInputChar();
+    UChar second = m_input.peekWithoutReplacement(0);
     if (isASCIIDigit(first))
         return true;
     if (first == '+' || first == '-')
         return ((isASCIIDigit(second)) || (second == '.' && isASCIIDigit(m_input.peekWithoutReplacement(1))));
     if (first =='.')
         return (isASCIIDigit(second));
     return false;
 }
 
 bool CSSTokenizer::nextCharsAreNumber()
 {
     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();
+    UChar second = m_input.peekWithoutReplacement(0);
     if (isNameStartCodePoint(first) || 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;
 }
 
 StringView CSSTokenizer::registerString(const String& string)
 {
     m_scope.storeString(string);
     return string;
 }
 
 } // namespace blink