Lazy Parse CSS

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)
+    : 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::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);
     while (true) {
         CSSParserToken token = tokenizer.nextToken();
         if (token.type() == CommentToken)
             continue;
         if (token.type() == EOFToken)
             return;
         m_tokens.append(token);
     }
 }
 
 CSSTokenizer::Scope::Scope(const String& string, CSSParserObserverWrapper& wrapper)
-: m_string(string)
+    : m_string(string)
 {
     if (string.isEmpty())
         return;
 
     CSSTokenizerInputStream input(string);
     CSSTokenizer tokenizer(input, *this);
 
     unsigned offset = 0;
     while (true) {
         CSSParserToken token = tokenizer.nextToken();
@@ skipping 15 matching lines @@
 CSSParserTokenRange CSSTokenizer::Scope::tokenRange()
 {
     return m_tokens;
 }
 
 unsigned CSSTokenizer::Scope::tokenCount()
 {
     return m_tokens.size();
 }
 
+void CSSTokenizer::Scope::storeString(const String& string)
+{
+    if (!m_stringPool)
+        m_stringPool.reset(new Vector<String>);
+    m_stringPool->append(string);
+}
+
 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 == '\\' && !isNewLine(second);
@@ skipping 629 matching lines @@
     return areIdentifier;
 }
 
 StringView CSSTokenizer::registerString(const String& string)
 {
     m_scope.storeString(string);
     return string;
 }
 
 } // namespace blink