Use CSSTokenizerInputStream::peekWithoutReplacement instead of peek().

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)
 {
     // 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
+    // * CSSTokenizerInputStream::nextInputChar() 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);
@@ skipping 144 matching lines @@
 {
     ASSERT(cc == '*');
     if (consumeIfNext('='))
         return CSSParserToken(SubstringMatchToken);
     return CSSParserToken(DelimiterToken, '*');
 }
 
 CSSParserToken CSSTokenizer::lessThan(UChar cc)
 {
     ASSERT(cc == '<');
-    if (m_input.peek(0) == '!' && m_input.peek(1) == '-' && m_input.peek(2) == '-') {
+    if (m_input.peekWithoutReplacement(0) == '!'
+        && m_input.peekWithoutReplacement(1) == '-'
+        && m_input.peekWithoutReplacement(2) == '-') {
         m_input.advance(3);
         return CSSParserToken(CDOToken);
     }
     return CSSParserToken(DelimiterToken, '<');
 }
 
 CSSParserToken CSSTokenizer::comma(UChar cc)
 {
     return CSSParserToken(CommaToken);
 }
 
 CSSParserToken CSSTokenizer::hyphenMinus(UChar cc)
 {
     if (nextCharsAreNumber(cc)) {
         reconsume(cc);
         return consumeNumericToken();
     }
-    if (m_input.peek(0) == '-' && m_input.peek(1) == '>') {
+    if (m_input.peekWithoutReplacement(0) == '-'
+        && m_input.peekWithoutReplacement(1) == '>') {
         m_input.advance(2);
         return CSSParserToken(CDCToken);
     }
     if (nextCharsAreIdentifier(cc)) {
         reconsume(cc);
         return consumeIdentLikeToken();
     }
     return CSSParserToken(DelimiterToken, cc);
 }
 
@@ skipping 14 matching lines @@
 }
 
 CSSParserToken CSSTokenizer::semiColon(UChar cc)
 {
     return CSSParserToken(SemicolonToken);
 }
 
 CSSParserToken CSSTokenizer::hash(UChar cc)
 {
     UChar nextChar = m_input.nextInputChar();
-    if (isNameCodePoint(nextChar) || twoCharsAreValidEscape(nextChar, m_input.peek(1))) {
+    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)
 {
     ASSERT(cc == '^');
@@ skipping 47 matching lines @@
 
 CSSParserToken CSSTokenizer::asciiDigit(UChar cc)
 {
     reconsume(cc);
     return consumeNumericToken();
 }
 
 CSSParserToken CSSTokenizer::letterU(UChar cc)
 {
     if (m_input.nextInputChar() == '+'
-        && (isASCIIHexDigit(m_input.peek(1)) || m_input.peek(1) == '?')) {
+        && (isASCIIHexDigit(m_input.peekWithoutReplacement(1))
+            || m_input.peekWithoutReplacement(1) == '?')) {
         m_input.advance();
         return consumeUnicodeRange();
     }
     reconsume(cc);
     return consumeIdentLikeToken();
 }
 
 CSSParserToken CSSTokenizer::nameStart(UChar cc)
 {
     reconsume(cc);
@@ skipping 50 matching lines @@
 static double getInteger(CSSTokenizerInputStream& input, unsigned& offset)
 {
     unsigned intStartPos = offset;
     offset = input.skipWhilePredicate<isASCIIDigit>(offset);
     unsigned intEndPos = offset;
     return input.getDouble(intStartPos, intEndPos);
 }
 
 static double getFraction(CSSTokenizerInputStream& input, unsigned& offset)
 {
-    if (input.peek(offset) != '.' || !isASCIIDigit(input.peek(offset + 1)))
+    if (input.peekWithoutReplacement(offset) != '.'
+        || !isASCIIDigit(input.peekWithoutReplacement(offset + 1)))
         return 0;
     unsigned startOffset = offset;
     offset = input.skipWhilePredicate<isASCIIDigit>(offset + 1);
     return input.getDouble(startOffset, offset);
 }
 
 static double getExponent(CSSTokenizerInputStream& input, unsigned& offset, int& sign)
 {
     unsigned exponentStartPos = 0;
     unsigned exponentEndPos = 0;
-    if ((input.peek(offset) == 'E' || input.peek(offset) == 'e')) {
-        int offsetBeforeExponent = offset;
+    UChar next = input.peekWithoutReplacement(offset);
+    if (next != 'E' && next != 'e')
+        return 0;
+    int offsetBeforeExponent = offset;
+    ++offset;
+    next = input.peekWithoutReplacement(offset);
+    if (next == '+') {
         ++offset;
-        if (input.peek(offset) == '+') {
-            ++offset;
-        } else if (input.peek(offset) =='-') {
-            sign = -1;
-            ++offset;
-        }
-        exponentStartPos = offset;
-        offset = input.skipWhilePredicate<isASCIIDigit>(offset);
-        exponentEndPos = offset;
-        if (exponentEndPos == exponentStartPos)
-            offset = offsetBeforeExponent;
+    } else if (next =='-') {
+        sign = -1;
+        ++offset;
     }
+    exponentStartPos = offset;
+    offset = input.skipWhilePredicate<isASCIIDigit>(offset);
+    exponentEndPos = offset;
+    if (exponentEndPos == exponentStartPos)
+        offset = offsetBeforeExponent;
     return input.getDouble(exponentStartPos, exponentEndPos);
 }
 
 // This method merges the following spec sections for efficiency
 // http://www.w3.org/TR/css3-syntax/#consume-a-number
 // http://www.w3.org/TR/css3-syntax/#convert-a-string-to-a-number
 CSSParserToken CSSTokenizer::consumeNumber()
 {
     ASSERT(nextCharsAreNumber());
     NumericValueType type = IntegerValueType;
@@ skipping 99 matching lines @@
         --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.peek(1))) {
+    } else if (m_input.nextInputChar() == '-' && 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()));
     }
 
     return CSSParserToken(UnicodeRangeToken, start, end);
@@ skipping 62 matching lines @@
             return;
         if (twoCharsAreValidEscape(cc, m_input.nextInputChar()))
             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.peek(1) == '\n')
+    if (c == '\r' && m_input.peekWithoutReplacement(1) == '\n')
         m_input.advance(2);
     else if (isHTMLSpace(c))
         m_input.advance();
 }
 
 void CSSTokenizer::consumeUntilCommentEndFound()
 {
     UChar c = consume();
     while (true) {
         if (c == kEndOfFileMarker)
@@ skipping 76 matching lines @@
         return codePoint;
     }
 
     if (cc == kEndOfFileMarker)
         return replacementCharacter;
     return cc;
 }
 
 bool CSSTokenizer::nextTwoCharsAreValidEscape()
 {
-    return twoCharsAreValidEscape(m_input.nextInputChar(), m_input.peek(1));
+    return twoCharsAreValidEscape(m_input.nextInputChar(), 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();
     if (isASCIIDigit(first))
         return true;
     if (first == '+' || first == '-')
-        return ((isASCIIDigit(second)) || (second == '.' && isASCIIDigit(m_input.peek(1))));
+        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);
@@ skipping 21 matching lines @@
     return areIdentifier;
 }
 
 StringView CSSTokenizer::registerString(const String& string)
 {
     m_scope.storeString(string);
     return string;
 }
 
 } // namespace blink