CSS Custom Properties (Variables)

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/CSSVariableValue.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/CSSParserObserver.h"
 #include "core/css/parser/CSSParserObserverWrapper.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/CSSVariableParser.h"
 #include "core/css/parser/MediaQueryParser.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/UseCounter.h"
 #include "platform/TraceEvent.h"
 #include "wtf/BitArray.h"
 
 namespace blink {
 
 CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)
 : m_context(context)
 , m_defaultNamespace(starAtom)
 , m_styleSheet(styleSheet)
 , m_observerWrapper(nullptr)
 {
 }
 
 bool CSSParserImpl::parseValue(MutableStylePropertySet* declaration, CSSPropertyID unresolvedProperty, const String& string, bool important, const CSSParserContext& context)
 {
     CSSParserImpl parser(context);
     StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = StyleRule::Viewport;
-    CSSTokenizer::Scope scope(string);
+    CSSTokenizerScope scope(string);
     parser.consumeDeclarationValue(scope.tokenRange(), unresolvedProperty, important, ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     return declaration->addParsedProperties(parser.m_parsedProperties);
 }
 
 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--; ) {
         const CSSProperty& property = input[i];
         if (property.isImportant() != important)
             continue;
         const unsigned propertyIDIndex = property.id() - firstCSSProperty;
-        if (seenProperties.get(propertyIDIndex))
+        if (seenProperties.get(propertyIDIndex) && property.id() != CSSPropertyVariable)
             continue;
         seenProperties.set(propertyIDIndex);
         output[--unusedEntries] = property;
     }
 }
 
 static PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> createStylePropertySet(WillBeHeapVector<CSSProperty, 256>& parsedProperties, CSSParserMode mode)
 {
     BitArray<numCSSProperties> seenProperties;
     size_t unusedEntries = parsedProperties.size();
     WillBeHeapVector<CSSProperty, 256> results(unusedEntries);
 
     filterProperties(true, parsedProperties, results, unusedEntries, seenProperties);
     filterProperties(false, parsedProperties, results, unusedEntries, seenProperties);
 
     RefPtrWillBeRawPtr<ImmutableStylePropertySet> result = ImmutableStylePropertySet::create(results.data() + unusedEntries, results.size() - unusedEntries, mode);
     parsedProperties.clear();
     return result.release();
 }
 
 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, document.elementSheet().contents());
-    CSSTokenizer::Scope scope(string);
+    CSSTokenizerScope scope(string);
     parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);
     return createStylePropertySet(parser.m_parsedProperties, mode);
 }
 
 bool CSSParserImpl::parseDeclarationList(MutableStylePropertySet* declaration, const String& string, const CSSParserContext& context)
 {
     CSSParserImpl parser(context);
     StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = StyleRule::Viewport;
-    CSSTokenizer::Scope scope(string);
+    CSSTokenizerScope scope(string);
     parser.consumeDeclarationList(scope.tokenRange(), ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     return declaration->addParsedProperties(parser.m_parsedProperties);
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::parseRule(const String& string, const CSSParserContext& context, AllowedRulesType allowedRules)
 {
     CSSParserImpl parser(context);
-    CSSTokenizer::Scope scope(string);
+    CSSTokenizerScope scope(string);
     CSSParserTokenRange range = scope.tokenRange();
     range.consumeWhitespace();
     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.consumeWhitespace();
     if (!rule || !range.atEnd())
         return nullptr; // Parse error, trailing garbage
     return rule;
 }
 
 void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet)
 {
     TRACE_EVENT_BEGIN2(
         "blink,blink_style", "CSSParserImpl::parseStyleSheet",
         "baseUrl", context.baseURL().string().utf8(),
         "mode", context.mode());
 
     TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokenize");
-    CSSTokenizer::Scope scope(string);
+    CSSTokenizerScope scope(string);
     TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokenize");
 
     TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
     CSSParserImpl parser(context, styleSheet);
     bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) {
         if (rule->isCharsetRule())
             return;
         styleSheet->parserAppendRule(rule);
     });
     styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
     TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
 
     TRACE_EVENT_END2(
         "blink,blink_style", "CSSParserImpl::parseStyleSheet",
         "tokenCount", scope.tokenCount(),
         "length", string.length());
 }
 
 PassOwnPtr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
 {
-    return consumeKeyframeKeyList(CSSTokenizer::Scope(keyList).tokenRange());
+    return consumeKeyframeKeyList(CSSTokenizerScope(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;
 }
 
 void CSSParserImpl::parseDeclarationListForInspector(const String& declaration, const CSSParserContext& context, CSSParserObserver& observer)
 {
     CSSParserImpl parser(context);
     CSSParserObserverWrapper wrapper(observer);
     parser.m_observerWrapper = &wrapper;
-    CSSTokenizer::Scope scope(declaration, *parser.m_observerWrapper);
+    CSSTokenizerScope scope(declaration, *parser.m_observerWrapper);
     observer.startRuleHeader(StyleRule::Style, 0);
     observer.endRuleHeader(1);
     parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);
 }
 
 void CSSParserImpl::parseStyleSheetForInspector(const String& string, const CSSParserContext& context, CSSParserObserver& observer)
 {
     RefPtrWillBeRawPtr<StyleSheetContents> sheet = StyleSheetContents::create(strictCSSParserContext());
     CSSParserImpl parser(context, sheet.get());
     CSSParserObserverWrapper wrapper(observer);
     parser.m_observerWrapper = &wrapper;
-    CSSTokenizer::Scope scope(string, *parser.m_observerWrapper);
+    CSSTokenizerScope scope(string, *parser.m_observerWrapper);
     parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) { });
 }
 
 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(CSSParserImpl::AllowedRulesType allowedRules, StyleRuleBase* rule)
 {
     if (!rule || allowedRules == CSSParserImpl::KeyframeRules || allowedRules == CSSParserImpl::NoRules)
         return allowedRules;
     ASSERT(allowedRules <= CSSParserImpl::RegularRules);
     if (rule->isCharsetRule() || rule->isImportRule())
         return CSSParserImpl::AllowImportRules;
@@ skipping 453 matching lines @@
         m_observerWrapper->yieldCommentsBefore(range);
         m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(range));
     }
 }
 
 void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, StyleRule::Type ruleType)
 {
     CSSParserTokenRange rangeCopy = range; // For inspector callbacks
 
     ASSERT(range.peek().type() == IdentToken);
-    CSSPropertyID unresolvedProperty = range.consumeIncludingWhitespace().parseAsUnresolvedCSSPropertyID();
+    CSSParserToken token = range.consumeIncludingWhitespace();
+    CSSPropertyID unresolvedProperty = token.parseAsUnresolvedCSSPropertyID();
     if (range.consume().type() != ColonToken)
         return; // Parse error
 
     bool important = false;
     const CSSParserToken* declarationValueEnd = range.end();
     const CSSParserToken* last = range.end() - 1;
     while (last->type() == WhitespaceToken)
         --last;
+
+    if (unresolvedProperty == CSSPropertyVariable) {
+        ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+        AtomicString variableName = token.value();
+        m_styleSheet->parserSetUsesVariables(true);
+        consumeVariableDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), variableName);
+        return;
+    }
     if (last->type() == IdentToken && last->valueEqualsIgnoringCase("important")) {
         --last;
         while (last->type() == WhitespaceToken)
             --last;
         if (last->type() == DelimiterToken && last->delimiter() == '!') {
             important = true;
             declarationValueEnd = last;
         }
     }
 
     if (important && (ruleType == StyleRule::FontFace || ruleType == StyleRule::Keyframes))
         return;
 
     if (m_observerWrapper && ruleType == StyleRule::Style) {
         size_t propertiesCount = m_parsedProperties.size();
         if (unresolvedProperty != CSSPropertyInvalid)
             consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);
         m_observerWrapper->observer().observeProperty(
             m_observerWrapper->startOffset(rangeCopy), m_observerWrapper->endOffset(rangeCopy),
             important, m_parsedProperties.size() != propertiesCount);
+            consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);
         return;
     }
 
     if (unresolvedProperty == CSSPropertyInvalid)
         return;
 
     consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);
 }
 
+void CSSParserImpl::consumeVariableDeclarationValue(CSSParserTokenRange range, const AtomicString& variableName)
+{
+    switch (CSSVariableParser::parseVariableDefinition(range)) {
+    case CSSVariableParser::Invalid:
+        return;
+    case CSSVariableParser::Variable:
+        m_parsedProperties.append(CSSProperty(CSSPropertyVariable,
+            CSSVariableValue::create(variableName, CSSVariableData::create(range, false))));
+        return;
+    case CSSVariableParser::VariableWithReferences:
+        m_parsedProperties.append(CSSProperty(CSSPropertyVariable,
+            CSSVariableValue::create(variableName, CSSVariableData::create(range, true))));
+        return;
+    case CSSVariableParser::Initial:
+        m_parsedProperties.append(CSSProperty(CSSPropertyVariable,
+            CSSVariableValue::create(variableName, CSSValueInitial)));
+        return;
+    case CSSVariableParser::Inherit:
+        m_parsedProperties.append(CSSProperty(CSSPropertyVariable,
+            CSSVariableValue::create(variableName, CSSValueInherit)));
+        return;
+    }
+}
+
 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID unresolvedProperty, bool important, StyleRule::Type ruleType)
 {
-    bool usesRemUnits;
-    CSSParserValueList valueList(range, usesRemUnits);
+    bool usesRemUnits, usesVariables;
+    CSSParserValueList valueList(range, usesRemUnits, usesVariables);
     if (!valueList.size())
         return; // Parser error
-    if (usesRemUnits && m_styleSheet)
-        m_styleSheet->parserSetUsesRemUnits(true);
+    if (m_styleSheet) {
+        if (usesRemUnits)
+            m_styleSheet->parserSetUsesRemUnits(true);
+        if (usesVariables)
+            m_styleSheet->parserSetUsesVariables(true);
+    }
     CSSPropertyParser::parseValue(unresolvedProperty, important, &valueList, m_context, m_parsedProperties, ruleType);
 }
 
 PassOwnPtr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenRange range)
 {
     OwnPtr<Vector<double>> result = adoptPtr(new Vector<double>);
     while (true) {
         range.consumeWhitespace();
         const CSSParserToken& token = range.consumeIncludingWhitespace();
         if (token.type() == PercentageToken && token.numericValue() >= 0 && token.numericValue() <= 100)
             result->append(token.numericValue() / 100);
         else if (token.type() == IdentToken && token.valueEqualsIgnoringCase("from"))
             result->append(0);
         else if (token.type() == IdentToken && token.valueEqualsIgnoringCase("to"))
             result->append(1);
         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