CSS Tokenizer: Fix handling of escaped newlines

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 "config.h"
 #include "core/css/parser/CSSTokenizer.h"
 
 namespace blink {
 #include "core/CSSTokenizerCodepoints.cpp"
 }
@@ skipping 13 matching lines @@
         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 == '\\') && (second != '\n') && (second != kEndOfFileMarker));
+    return first == '\\' && !isNewLine(second) && second != kEndOfFileMarker;
 }
 
 CSSTokenizer::CSSTokenizer(CSSTokenizerInputStream& inputStream)
     : m_input(inputStream)
 {
 }
 
 void CSSTokenizer::reconsume(UChar c)
 {
     m_input.pushBack(c);
@@ skipping 298 matching lines @@
 // http://www.w3.org/TR/css3-syntax/#consume-an-ident-like-token
 CSSParserToken CSSTokenizer::consumeIdentLikeToken()
 {
     String name = consumeName();
     if (consumeIfNext('(')) {
         return blockStart(LeftParenthesisToken, FunctionToken, name);
     }
     return CSSParserToken(IdentToken, name);
 }
 
-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/#consume-a-string-token
 CSSParserToken CSSTokenizer::consumeStringTokenUntil(UChar endingCodePoint)
 {
     StringBuilder output;
     while (true) {
         UChar cc = consume();
         if (cc == endingCodePoint || cc == kEndOfFileMarker) {
             // The "reconsume" here deviates from the spec, but is required to avoid consuming past the EOF
             if (cc == kEndOfFileMarker)
                 reconsume(cc);
             return CSSParserToken(StringToken, output.toString());
         }
         if (isNewLine(cc)) {
             reconsume(cc);
             return CSSParserToken(BadStringToken);
         }
         if (cc == '\\') {
             if (m_input.nextInputChar() == kEndOfFileMarker)
                 continue;
             if (isNewLine(m_input.nextInputChar()))
-                consume();
+                consumeSingleWhitespaceIfNext(); // This handles \r\n for us
             else
                 output.append(consumeEscape());
         } else {
             output.append(cc);
         }
     }
 }
 
 void CSSTokenizer::consumeUntilNonWhitespace()
 {
@@ skipping 56 matching lines @@
         }
         reconsume(cc);
         return result.toString();
     }
 }
 
 // http://dev.w3.org/csswg/css-syntax/#consume-an-escaped-code-point
 UChar CSSTokenizer::consumeEscape()
 {
     UChar cc = consume();
-    ASSERT(cc != '\n');
+    ASSERT(!isNewLine(cc));
     if (isASCIIHexDigit(cc)) {
         unsigned consumedHexDigits = 1;
         StringBuilder hexChars;
         hexChars.append(cc);
         while (consumedHexDigits < 6 && isASCIIHexDigit(m_input.nextInputChar())) {
             cc = consume();
             hexChars.append(cc);
             consumedHexDigits++;
         };
         consumeSingleWhitespaceIfNext();
@@ skipping 56 matching lines @@
 
 bool CSSTokenizer::nextCharsAreIdentifier()
 {
     UChar first = consume();
     bool areIdentifier = nextCharsAreIdentifier(first);
     reconsume(first);
     return areIdentifier;
 }
 
 } // namespace blink