Smaller CSSParser UTF16 buffers for escaped strings.

Source/core/css/CSSTokenizer-in.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 286 matching lines @@
 {
     return m_currentCharacter8;
 }
 
 template <>
 inline UChar*& CSSTokenizer::currentCharacter<UChar>()
 {
     return m_currentCharacter16;
 }
 
-UChar*& CSSTokenizer::currentCharacter16()
+UChar* CSSTokenizer::allocateStringBuffer16(size_t len)
 {
-    if (!m_currentCharacter16) {
-        m_dataStart16 = adoptArrayPtr(new UChar[m_length]);
-        m_currentCharacter16 = m_dataStart16.get();
-    }
+    // Allocates and returns a CSSTokenizer owned buffer for storing
+    // UTF-16 data. Used to get a suitable life span for UTF-16
+    // strings, identifiers and URIs created by the tokenizer.
+    OwnPtr<UChar[]> buffer = adoptArrayPtr(new UChar[len]);
 
-    return m_currentCharacter16;
+    UChar* bufferPtr = buffer.get();
+
+    m_cssStrings16.append(buffer.release());
+    return bufferPtr;
 }
 
 template <>
 inline LChar* CSSTokenizer::dataStart<LChar>()
 {
     return m_dataStart8.get();
 }
 
 template <>
 inline UChar* CSSTokenizer::dataStart<UChar>()
@@ skipping 80 matching lines @@
         if (unicode > 0x10ffff)
             unicode = 0xfffd;
 
         // Optional space after the escape sequence.
         if (isHTMLSpace<CharacterType>(*src))
             ++src;
 
         return unicode;
     }
 
-    return *currentCharacter<CharacterType>()++;
+    return *src++;
 }
 
 template <>
 inline void CSSTokenizer::UnicodeToChars<LChar>(LChar*& result, unsigned unicode)
 {
     ASSERT(unicode <= 0xff);
     *result = unicode;
 
     ++result;
 }
 
 template <>
 inline void CSSTokenizer::UnicodeToChars<UChar>(UChar*& result, unsigned unicode)
 {
     // Replace unicode with a surrogate pairs when it is bigger than 0xffff
     if (U16_LENGTH(unicode) == 2) {
         *result++ = U16_LEAD(unicode);
         *result = U16_TRAIL(unicode);
     } else {
         *result = unicode;
     }
 
     ++result;
 }
 
+template <typename SrcCharacterType>
+size_t CSSTokenizer::peekMaxIdentifierLen(SrcCharacterType* src)
+{
+    // The decoded form of an identifier (after resolving escape
+    // sequences) will not contain more characters (ASCII or UTF-16
+    // codepoints) than the input. This code can therefore ignore
+    // escape sequences completely.
+    SrcCharacterType* start = src;
+    do {
+        if (LIKELY(*src != '\\'))
+            src++;
+        else
+            parseEscape<SrcCharacterType>(src);
+    } while (isCSSLetter(src[0]) || (src[0] == '\\' && isCSSEscape(src[1])));
+
+    return src - start;
+}
+
 template <typename SrcCharacterType, typename DestCharacterType>
 inline bool CSSTokenizer::parseIdentifierInternal(SrcCharacterType*& src, DestCharacterType*& result, bool& hasEscape)
 {
     hasEscape = false;
     do {
         if (LIKELY(*src != '\\')) {
             *result++ = *src++;
         } else {
             hasEscape = true;
             SrcCharacterType* savedEscapeStart = src;
@@ skipping 13 matching lines @@
 inline void CSSTokenizer::parseIdentifier(CharacterType*& result, CSSParserString& resultString, bool& hasEscape)
 {
     // If a valid identifier start is found, we can safely
     // parse the identifier until the next invalid character.
     ASSERT(isIdentifierStart<CharacterType>());
 
     CharacterType* start = currentCharacter<CharacterType>();
     if (UNLIKELY(!parseIdentifierInternal(currentCharacter<CharacterType>(), result, hasEscape))) {
         // Found an escape we couldn't handle with 8 bits, copy what has been recognized and continue
         ASSERT(is8BitSource());
-        UChar*& result16 = currentCharacter16();
+        UChar* result16 = allocateStringBuffer16((result - start) + peekMaxIdentifierLen(result));
         UChar* start16 = result16;
         int i = 0;
         for (; i < result - start; i++)
             result16[i] = start[i];
 
         result16 += i;
 
         parseIdentifierInternal(currentCharacter<CharacterType>(), result16, hasEscape);
 
         resultString.init(start16, result16 - start16);
 
         return;
     }
 
     resultString.init(start, result - start);
 }
 
+template <typename SrcCharacterType>
+size_t CSSTokenizer::peekMaxStringLen(SrcCharacterType* src, UChar quote)
+{
+    // The decoded form of a CSS string (after resolving escape
+    // sequences) will not contain more characters (ASCII or UTF-16
+    // codepoints) than the input. This code can therefore ignore
+    // escape sequences completely and just return the length of the
+    // input string (possibly including terminating quote if any).
+    SrcCharacterType* end = checkAndSkipString(src, quote);
+    return end ? end - src : 0;
+}
+
 template <typename SrcCharacterType, typename DestCharacterType>
 inline bool CSSTokenizer::parseStringInternal(SrcCharacterType*& src, DestCharacterType*& result, UChar quote)
 {
     while (true) {
         if (UNLIKELY(*src == quote)) {
             // String parsing is done.
             ++src;
             return true;
         }
         if (UNLIKELY(!*src)) {
@@ skipping 23 matching lines @@
 }
 
 template <typename CharacterType>
 inline void CSSTokenizer::parseString(CharacterType*& result, CSSParserString& resultString, UChar quote)
 {
     CharacterType* start = currentCharacter<CharacterType>();
 
     if (UNLIKELY(!parseStringInternal(currentCharacter<CharacterType>(), result, quote))) {
         // Found an escape we couldn't handle with 8 bits, copy what has been recognized and continue
         ASSERT(is8BitSource());
-        UChar*& result16 = currentCharacter16();
+        UChar* result16 = allocateStringBuffer16((result - start) + peekMaxStringLen(result, quote));
         UChar* start16 = result16;
         int i = 0;
         for (; i < result - start; i++)
             result16[i] = start[i];
 
         result16 += i;
 
         parseStringInternal(currentCharacter<CharacterType>(), result16, quote);
 
         resultString.init(start16, result16 - start16);
@@ skipping 27 matching lines @@
         }
     }
 
     end = skipWhiteSpace(end);
     if (*end != ')')
         return false;
 
     return true;
 }
 
+template <typename SrcCharacterType>
+inline size_t CSSTokenizer::peekMaxURILen(SrcCharacterType* src, UChar quote)
+{
+    // The decoded form of a URI (after resolving escape sequences)
+    // will not contain more characters (ASCII or UTF-16 codepoints)
+    // than the input. This code can therefore ignore escape sequences
+    // completely.
+    SrcCharacterType* start = src;
+    if (quote) {
+        ASSERT(quote == '"' || quote == '\'');
+        return peekMaxStringLen(src, quote);
+    }
+
+    while (isURILetter(*src)) {
+        if (LIKELY(*src != '\\'))
+            src++;
+        else
+            parseEscape<SrcCharacterType>(src);
+    }
+
+    return src - start;
+}
+
 template <typename SrcCharacterType, typename DestCharacterType>
 inline bool CSSTokenizer::parseURIInternal(SrcCharacterType*& src, DestCharacterType*& dest, UChar quote)
 {
     if (quote) {
         ASSERT(quote == '"' || quote == '\'');
         return parseStringInternal(src, dest, quote);
     }
 
     while (isURILetter(*src)) {
         if (LIKELY(*src != '\\')) {
             *dest++ = *src++;
         } else {
             unsigned unicode = parseEscape<SrcCharacterType>(src);
-            if (unicode > 0xff && sizeof(SrcCharacterType) == 1)
+            if (unicode > 0xff && sizeof(DestCharacterType) == 1)
                 return false;
             UnicodeToChars(dest, unicode);
         }
     }
 
     return true;
 }
 
 template <typename CharacterType>
 inline void CSSTokenizer::parseURI(CSSParserString& string)
 {
     CharacterType* uriStart;
     CharacterType* uriEnd;
     UChar quote;
     if (!findURI(uriStart, uriEnd, quote))
         return;
 
     CharacterType* dest = currentCharacter<CharacterType>() = uriStart;
     if (LIKELY(parseURIInternal(currentCharacter<CharacterType>(), dest, quote))) {
         string.init(uriStart, dest - uriStart);
     } else {
         // An escape sequence was encountered that can't be stored in 8 bits.
         // Reset the current character to the start of the URI and re-parse with
         // a 16-bit destination.
         ASSERT(is8BitSource());
-        UChar* uriStart16 = currentCharacter16();
+        UChar* result16 = allocateStringBuffer16(peekMaxURILen(uriStart, quote));
+        UChar* uriStart16 = result16;
         currentCharacter<CharacterType>() = uriStart;
-        bool result = parseURIInternal(currentCharacter<CharacterType>(), currentCharacter16(), quote);
+        bool result = parseURIInternal(currentCharacter<CharacterType>(), result16, quote);
         ASSERT_UNUSED(result, result);
-        string.init(uriStart16, currentCharacter16() - uriStart16);
+        string.init(uriStart16, result16 - uriStart16);
     }
 
     currentCharacter<CharacterType>() = uriEnd + 1;
     m_token = URI;
 }
 
 template <typename CharacterType>
 inline bool CSSTokenizer::parseUnicodeRange()
 {
     CharacterType* character = currentCharacter<CharacterType>() + 1;
@@ skipping 886 matching lines @@
     m_dataStart16[length - 1] = 0;
 
     m_is8BitSource = false;
     m_currentCharacter8 = 0;
     m_currentCharacter16 = m_dataStart16.get();
     setTokenStart<UChar>(m_currentCharacter16);
     m_lexFunc = &CSSTokenizer::realLex<UChar>;
 }
 
 } // namespace WebCore