CSS Custom Properties (Variables)

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 "config.h"
 #include "core/css/parser/CSSParserImpl.h"
 
+#include "core/css/CSSCustomPropertyDeclaration.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/CSSParserObserver.h"
 #include "core/css/parser/CSSParserObserverWrapper.h"
 #include "core/css/parser/CSSParserSelector.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)
@@ skipping 16 matching lines @@
     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))
+        // CSSPropertyVariable is asserted to be one number before the firstCSSProperty. We need to include it here.
+        const unsigned propertyIDIndex = property.id() - CSSPropertyVariable;

[Timothy Loh, 2015/09/30 02:09:27]

This looks wrong, won't the last property access outside the range of the
bitarray? We don't need to set in the bitarray for variables, so just checking
for variables separately should work.

+        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();
@@ skipping 583 matching lines @@
         }
     }
 
     // Yield remaining comments
     if (useObserver) {
         m_observerWrapper->yieldCommentsBefore(range);
         m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(range));
     }
 }
 
+template <typename CharacterType>
+static bool isCustomProperty(const CharacterType* propertyName, unsigned length)
+{
+    return (length >= 2 && propertyName[0] == '-' && propertyName[1] == '-');
+}
+
+inline bool isCustomProperty(CSSParserToken token)

[Timothy Loh, 2015/09/30 02:09:27]

This is duplicated between here and CSSVariableParser, can we share them? (The
other one looks better since it doesn't have templates)

+{
+    CSSParserString string = token.value();
+    return string.is8Bit() ? isCustomProperty(string.characters8(), string.length()) : isCustomProperty(string.characters16(), string.length());
+}
+
 void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, StyleRule::Type ruleType)
 {
     CSSParserTokenRange rangeCopy = range; // For inspector callbacks
 
     ASSERT(range.peek().type() == IdentToken);
-    CSSPropertyID unresolvedProperty = range.consumeIncludingWhitespace().parseAsUnresolvedCSSPropertyID();
+    const 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 (last->type() == IdentToken && last->valueEqualsIgnoringCase("important")) {
         --last;
         while (last->type() == WhitespaceToken)
             --last;
         if (last->type() == DelimiterToken && last->delimiter() == '!') {
             important = true;
             declarationValueEnd = last;
         }
     }
+    if (RuntimeEnabledFeatures::cssVariablesEnabled() && unresolvedProperty == CSSPropertyInvalid && isCustomProperty(token)) {
+        AtomicString variableName = token.value();
+        consumeVariableDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), variableName, important);
+        return;
+    }
 
     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);
         return;
     }
 
     if (unresolvedProperty == CSSPropertyInvalid)
         return;
 
     consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);
 }
 
+void CSSParserImpl::consumeVariableDeclarationValue(CSSParserTokenRange range, const AtomicString& variableName, bool important)
+{
+    if (PassRefPtrWillBeRawPtr<CSSCustomPropertyDeclaration> value = CSSVariableParser::parseDeclarationValue(variableName, range))

[Timothy Loh, 2015/09/30 02:09:28]

I think this is supposed to be:

if (RefPtr..<> value)
   ... value.release()

+        m_parsedProperties.append(CSSProperty(CSSPropertyVariable, value, important));
+}
+
 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID unresolvedProperty, bool important, StyleRule::Type ruleType)
 {
     CSSPropertyParser::parseValue(unresolvedProperty, important, range, 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