Don't use consume() in CSSTokenizer when ignoring the return value.

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 96 matching lines @@
     m_input.pushBack(c);
 }
 
 UChar CSSTokenizer::consume()
 {
     UChar current = m_input.nextInputChar();
     m_input.advance();
     return current;
 }
 
-void CSSTokenizer::consume(unsigned offset)

[esprehn, 2016/06/27 21:46:29]

This is confusing, but there was actually two methods called consume(). One took
an argument and and just did advance(), the other right above this takes no
arguments and does:

    UChar current = m_input.nextInputChar();
    m_input.advance();
    return current;

which is what the comment is about.

-{
-    m_input.advance(offset);
-}
-
 CSSParserToken CSSTokenizer::whiteSpace(UChar cc)
 {
     m_input.advanceUntilNonWhitespace();
     return CSSParserToken(WhitespaceToken);
 }
 
 static bool popIfBlockMatches(Vector<CSSParserTokenType>& blockStack, CSSParserTokenType type)
 {
     if (!blockStack.isEmpty() && blockStack.last() == type) {
         blockStack.removeLast();
@@ skipping 65 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) == '-') {
-        consume(3);
+        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) == '>') {
-        consume(2);
+        m_input.advance(2);
         return CSSParserToken(CDCToken);
     }
     if (nextCharsAreIdentifier(cc)) {
         reconsume(cc);
         return consumeIdentLikeToken();
     }
     return CSSParserToken(DelimiterToken, cc);
 }
 
 CSSParserToken CSSTokenizer::solidus(UChar cc)
@@ skipping 82 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) == '?')) {
-        consume();
+        m_input.advance();
         return consumeUnicodeRange();
     }
     reconsume(cc);
     return consumeIdentLikeToken();
 }
 
 CSSParserToken CSSTokenizer::nameStart(UChar cc)
 {
     reconsume(cc);
     return consumeIdentLikeToken();
@@ skipping 195 matching lines @@
     }
 
     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))) {
-        consume();
+        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 @@
         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')
-        consume(2);
+        m_input.advance(2);
     else if (isHTMLSpace(c))
-        consume();
+        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) {
-        consume();
+        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
     for (unsigned size = 0; ; ++size) {
@@ skipping 103 matching lines @@
     return areIdentifier;
 }
 
 StringView CSSTokenizer::registerString(const String& string)
 {
     m_scope.storeString(string);
     return string;
 }
 
 } // namespace blink