CSS Tokenizer: Add an on-stack tokenizer scope

Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleRuleKeyframe.h"
 #include "core/css/StyleRuleNamespace.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSSupportsParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/parser/MediaQueryParser.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/UseCounter.h"
 #include "wtf/BitArray.h"
 
 namespace blink {
 
-CSSParserImpl::CSSParserImpl(const CSSParserContext& context, const String& string, StyleSheetContents* styleSheet)
+CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)
 : m_context(context)
 , m_defaultNamespace(starAtom)
 , m_styleSheet(styleSheet)
 {
-    CSSTokenizer::tokenize(string, m_tokens);
 }
 
 bool CSSParserImpl::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
 {
-    CSSParserImpl parser(context, string);
+    CSSParserImpl parser(context);
     StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = StyleRule::Viewport;
-    parser.consumeDeclarationValue(CSSParserTokenRange(parser.m_tokens), propertyID, important, ruleType);
+    CSSTokenizer::Scope scope(string);
+    parser.consumeDeclarationValue(scope.tokenRange(), propertyID, important, ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     declaration->addParsedProperties(parser.m_parsedProperties);
     return true;
 }
 
 static inline void filterProperties(bool important, const WillBeHeapVector<CSSProperty, 256>& input, WillBeHeapVector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties)
 {
     // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found.
     for (size_t i = input.size(); i--; ) {
@@ skipping 19 matching lines @@
 
     return ImmutableStylePropertySet::create(results.data() + unusedEntries, results.size() - unusedEntries, mode);
 }
 
 PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> CSSParserImpl::parseInlineStyleDeclaration(const String& string, Element* element)
 {
     Document& document = element->document();
     CSSParserContext context = CSSParserContext(document.elementSheet().contents()->parserContext(), UseCounter::getFrom(&document));
     CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode() ? HTMLStandardMode : HTMLQuirksMode;
     context.setMode(mode);
-    CSSParserImpl parser(context, string);
-    parser.consumeDeclarationList(CSSParserTokenRange(parser.m_tokens), StyleRule::Style);
+    CSSParserImpl parser(context);
+    CSSTokenizer::Scope scope(string);
+    parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);
     return createStylePropertySet(parser.m_parsedProperties, mode);
 }
 
 bool CSSParserImpl::parseDeclaration(MutableStylePropertySet* declaration, const String& string, const CSSParserContext& context)
 {
-    CSSParserImpl parser(context, string);
+    CSSParserImpl parser(context);
     StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = StyleRule::Viewport;
-    parser.consumeDeclarationList(CSSParserTokenRange(parser.m_tokens), ruleType);
+    CSSTokenizer::Scope scope(string);
+    parser.consumeDeclarationList(scope.tokenRange(), ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     declaration->addParsedProperties(parser.m_parsedProperties);
     return true;
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::parseRule(const String& string, const CSSParserContext& context, AllowedRulesType allowedRules)
 {
-    CSSParserImpl parser(context, string);
-    CSSParserTokenRange range(parser.m_tokens);
+    CSSParserImpl parser(context);
+    CSSTokenizer::Scope scope(string);
+    CSSParserTokenRange range = scope.tokenRange();
     range.consumeWhitespaceAndComments();
     if (range.atEnd())
         return nullptr; // Parse error, empty rule
     RefPtrWillBeRawPtr<StyleRuleBase> rule;
     if (range.peek().type() == AtKeywordToken)
         rule = parser.consumeAtRule(range, allowedRules);
     else
         rule = parser.consumeQualifiedRule(range, allowedRules);
     if (!rule)
         return nullptr; // Parse error, failed to consume rule
     range.consumeWhitespaceAndComments();
     if (!rule || !range.atEnd())
         return nullptr; // Parse error, trailing garbage
     return rule;
 }
 
 void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet)
 {
-    CSSParserImpl parser(context, string, styleSheet);
-    parser.consumeRuleList(parser.m_tokens, TopLevelRuleList, [&styleSheet](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) {
+    CSSParserImpl parser(context, styleSheet);
+    CSSTokenizer::Scope scope(string);
+    parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) {
         styleSheet->parserAppendRule(rule);
     });
 }
 
 PassOwnPtr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
 {
-    Vector<CSSParserToken> tokens;
-    CSSTokenizer::tokenize(keyList, tokens);
-    return consumeKeyframeKeyList(tokens);
+    return consumeKeyframeKeyList(CSSTokenizer::Scope(keyList).tokenRange());
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range)
 {
     ASSERT(m_parsedProperties.isEmpty());
     consumeDeclaration(range, StyleRule::Style);
     bool result = !m_parsedProperties.isEmpty();
     m_parsedProperties.clear();
     return result;
 }
@@ skipping 416 matching lines @@
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result.release();
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink