Replace CSSParserString with StringView.

third_party/WebKit/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 "core/css/parser/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 172 matching lines @@
         "tokenCount", scope.tokenCount(),
         "length", string.length());
 }
 
 CSSSelectorList CSSParserImpl::parsePageSelector(CSSParserTokenRange range, StyleSheetContents* styleSheet)
 {
     // We only support a small subset of the css-page spec.
     range.consumeWhitespace();
     AtomicString typeSelector;
     if (range.peek().type() == IdentToken)
-        typeSelector = range.consume().value();
+        typeSelector = AtomicString(range.consume().value().toString());
 
     AtomicString pseudo;
     if (range.peek().type() == ColonToken) {
         range.consume();
         if (range.peek().type() != IdentToken)
             return CSSSelectorList();
-        pseudo = range.consume().value();
+        pseudo = AtomicString(range.consume().value().toString());
     }
 
     range.consumeWhitespace();
     if (!range.atEnd())
         return CSSSelectorList(); // Parse error; extra tokens in @page selector
 
     OwnPtr<CSSParserSelector> selector;
     if (!typeSelector.isNull() && pseudo.isNull()) {
         selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace()));
     } else {
@@ skipping 138 matching lines @@
             callback(rule);
         }
     }
 
     return firstRuleValid;
 }
 
 StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, AllowedRulesType allowedRules)
 {
     ASSERT(range.peek().type() == AtKeywordToken);
-    const CSSParserString& name = range.consume().value();
+    const StringView name = range.consume().value();
     const CSSParserToken* preludeStart = &range.peek();
     while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek().type() != SemicolonToken)
         range.consumeComponentValue();
 
     CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
     CSSAtRuleID id = cssAtRuleID(name);
     if (id != CSSAtRuleInvalid && m_context.useCounter())
         countAtRule(m_context.useCounter(), id);
 
     if (range.atEnd() || range.peek().type() == SemicolonToken) {
@@ skipping 59 matching lines @@
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 // This may still consume tokens if it fails
 static AtomicString consumeStringOrURI(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
 
     if (token.type() == StringToken || token.type() == UrlToken)
-        return range.consumeIncludingWhitespace().value();
+        return AtomicString(range.consumeIncludingWhitespace().value().toString());
 
     if (token.type() != FunctionToken || !token.valueEqualsIgnoringASCIICase("url"))
         return AtomicString();
 
     CSSParserTokenRange contents = range.consumeBlock();
     const CSSParserToken& uri = contents.consumeIncludingWhitespace();
     ASSERT(uri.type() == StringToken);
     if (!contents.atEnd())
         return AtomicString();
-    return uri.value();
+    return AtomicString(uri.value().toString());
 }
 
 StyleRuleCharset* CSSParserImpl::consumeCharsetRule(CSSParserTokenRange prelude)
 {
     prelude.consumeWhitespace();
     const CSSParserToken& string = prelude.consumeIncludingWhitespace();
     if (string.type() != StringToken || !prelude.atEnd())
         return nullptr; // Parse error, expected a single string
     return StyleRuleCharset::create();
 }
@@ skipping 14 matching lines @@
     }
 
     return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(prelude));
 }
 
 StyleRuleNamespace* CSSParserImpl::consumeNamespaceRule(CSSParserTokenRange prelude)
 {
     prelude.consumeWhitespace();
     AtomicString namespacePrefix;
     if (prelude.peek().type() == IdentToken)
-        namespacePrefix = prelude.consumeIncludingWhitespace().value();
+        namespacePrefix = AtomicString(prelude.consumeIncludingWhitespace().value().toString());
 
     AtomicString uri(consumeStringOrURI(prelude));
     prelude.consumeWhitespace();
     if (uri.isNull() || !prelude.atEnd())
         return nullptr; // Parse error, expected string or URI
 
     return StyleRuleNamespace::create(namespacePrefix, uri);
 }
 
 StyleRuleMedia* CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
@@ skipping 87 matching lines @@
 StyleRuleKeyframes* CSSParserImpl::consumeKeyframesRule(bool webkitPrefixed, CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     prelude.consumeWhitespace();
     CSSParserTokenRange rangeCopy = prelude; // For inspector callbacks
     const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();
     if (!prelude.atEnd())
         return nullptr; // Parse error; expected single non-whitespace token in @keyframes header
 
     String name;
     if (nameToken.type() == IdentToken) {
-        name = nameToken.value();
+        name = nameToken.value().toString();
     } else if (nameToken.type() == StringToken && webkitPrefixed) {
         if (m_context.useCounter())
             m_context.useCounter()->count(UseCounter::QuotedKeyframesRule);
-        name = nameToken.value();
+        name = nameToken.value().toString();
     } else {
         return nullptr; // Parse error; expected ident token in @keyframes header
     }
 
     if (m_observerWrapper) {
         m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframes, m_observerWrapper->startOffset(rangeCopy));
         m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
         m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));
         m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));
     }
@@ skipping 27 matching lines @@
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude)
 {
     ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
     prelude.consumeWhitespace();
     const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
     if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
         return; // Parse error, expected a single custom property name
     m_parsedProperties.append(CSSProperty(
         CSSPropertyApplyAtRule,
-        CSSCustomIdentValue::create(ident.value())));
+        CSSCustomIdentValue::create(ident.value().toString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
     if (!keyList)
         return nullptr;
 
     if (m_observerWrapper) {
         m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframe, m_observerWrapper->startOffset(prelude));
@@ skipping 110 matching lines @@
         while (last->type() == WhitespaceToken)
             --last;
         if (last->type() == DelimiterToken && last->delimiter() == '!') {
             important = true;
             declarationValueEnd = last;
         }
     }
 
     size_t propertiesCount = m_parsedProperties.size();
     if (RuntimeEnabledFeatures::cssVariablesEnabled() && unresolvedProperty == CSSPropertyInvalid && CSSVariableParser::isValidVariableName(token)) {
-        AtomicString variableName = token.value();
+        AtomicString variableName = AtomicString(token.value().toString());
         consumeVariableValue(range.makeSubRange(&range.peek(), declarationValueEnd), variableName, important);
     }
 
     if (important && (ruleType == StyleRule::FontFace || ruleType == StyleRule::Keyframe))
         return;
 
     if (unresolvedProperty != CSSPropertyInvalid) {
         if (m_styleSheet && m_styleSheet->singleOwnerDocument())
             Deprecation::warnOnDeprecatedProperties(m_styleSheet->singleOwnerDocument()->frame(), unresolvedProperty);
         consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);
@@ skipping 32 matching lines @@
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result;
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink