CSS Custom Properties (Variables)

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 33 matching lines @@
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValuePool.h"
+#include "core/css/CSSCustomVariableValue.h"
 #include "core/css/Counter.h"
 #include "core/css/HashTools.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/GridCoordinate.h"
 #include "core/svg/SVGPathUtilities.h"
@@ skipping 164 matching lines @@
         && (!value->fValue // 0 can always be unitless.
             || isUnitLessLengthParsingEnabledForMode(cssParserMode) // HTML and SVG attribute values can always be unitless.
             || (cssParserMode == HTMLQuirksMode && (unitflags & FUnitlessQuirk)));
 }
 
 bool CSSPropertyParser::validUnit(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode, ReleaseParsedCalcValueCondition releaseCalc)
 {
     if (isCalculation(value))
         return validCalculationUnit(value, unitflags, releaseCalc);
 
+    if (RuntimeEnabledFeatures::cssVariablesEnabled() && isVariableReference(value))
+        return true;

[alancutter (OOO until 2018), 2015/07/14 06:12:57]

Is this ever hit?

+
     if (unitflags & FNonNeg && value->fValue < 0)
         return false;
     switch (value->unit) {
     case CSSPrimitiveValue::CSS_NUMBER:
         if (unitflags & FNumber)
             return true;
         if (shouldAcceptUnitLessValues(value, unitflags, cssParserMode)) {
             value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX : CSSPrimitiveValue::CSS_DEG;
             return true;
         }
@@ skipping 47 matching lines @@
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
     }
 
     ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
         || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
         || (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
         || (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM));
     return cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitType>(value->unit));
 }
 
+inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveVariableReferenceValue(CSSParserValue* value)
+{
+    ASSERT(value->unit == CSSParserValue::VariableValue);
+    return CSSPrimitiveValue::create(value->variableData);

[alancutter (OOO until 2018), 2015/07/14 06:12:57]

I think we can inline this.
The ASSERT is implicit at the call site so it can probably be dropped.

+}
+
 inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
 {
     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
 }
 
 inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_CUSTOM_IDENT);
@@ skipping 119 matching lines @@
             return false;
         addExpandedPropertyForValue(propId, cssValuePool().createExplicitInitialValue(), important);
         return true;
     } else if (id == CSSValueUnset) {
         if (m_valueList->size() != 1)
             return false;
         addExpandedPropertyForValue(propId, cssValuePool().createUnsetValue(), important);
         return true;
     }
 
+
     int num = inShorthand() ? 1 : m_valueList->size();
 
+    if (RuntimeEnabledFeatures::cssVariablesEnabled() && isVariableReference(value)) {
+        // We don't expand the shorthand here because crazypants.
+        m_parsedProperties.append(CSSProperty(propId, createPrimitiveVariableReferenceValue(value), important, false, 0, m_implicitShorthand));
+        m_valueList->next();
+        return true;
+    }
+
     if (CSSParserFastPaths::isKeywordPropertyID(propId)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
     bool validPrimitive = false;
@@ skipping 1100 matching lines @@
 
     // Properties below are validated inside parseViewportProperty, because we
     // check for parser state. We need to invalidate if someone adds them outside
     // a @viewport rule.
     case CSSPropertyMaxZoom:
     case CSSPropertyMinZoom:
     case CSSPropertyOrientation:
     case CSSPropertyUserZoom:
         validPrimitive = false;
         break;
-
     case CSSPropertyScrollSnapPointsX:
     case CSSPropertyScrollSnapPointsY:
         parsedValue = parseScrollSnapPoints();
         break;
     case CSSPropertyScrollSnapCoordinate:
         parsedValue = parseScrollSnapCoordinate();
         break;
     case CSSPropertyScrollSnapDestination:
         parsedValue = parsePosition(m_valueList);
         break;
-
     default:
         return parseSVGValue(propId, important);
     }
 
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
@@ skipping 3348 matching lines @@
 }
 
 
 bool CSSPropertyParser::isCalculation(CSSParserValue* value)
 {
     return (value->unit == CSSParserValue::Function)
         && (value->function->id == CSSValueCalc
             || value->function->id == CSSValueWebkitCalc);
 }
 
+bool CSSPropertyParser::isVariableReference(CSSParserValue* value)
+{
+    return value->unit == CSSParserValue::VariableValue;
+}

[alancutter (OOO until 2018), 2015/07/14 06:12:57]

Inlining this check will make it clearer that the access to value->variableData
is valid.

+
 inline int CSSPropertyParser::colorIntFromValue(CSSParserValue* v)
 {
     bool isPercent;
     double value;
 
     if (m_parsedCalculation) {
         isPercent = m_parsedCalculation->category() == CalcPercent;
         value = m_parsedCalculation->doubleValue();
         m_parsedCalculation.release();
     } else {
@@ skipping 2616 matching lines @@
 
     // If just one value is supplied, the second value
     // is implicitly initialized with the first value.
     if (numValues == 1)
         m_valueList->previous();
 
     return parseViewportProperty(second, important);
 }
 
 template <typename CharacterType>
+static bool isVariableDefinition(const CharacterType* propertyName, unsigned length)
+{
+    return (length >= 2 && propertyName[0] == '-' && propertyName[1] == '-');
+}
+
+template <typename CharacterType>
 static CSSPropertyID unresolvedCSSPropertyID(const CharacterType* propertyName, unsigned length)
 {
     char buffer[maxCSSPropertyNameLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = propertyName[i];
-        if (c == 0 || c >= 0x7F)
+        if (c == 0 || c >= 0x7F) {
+            if (isVariableDefinition(propertyName, length))
+                return CSSPropertyVariable;
             return CSSPropertyInvalid; // illegal character
+        }
         buffer[i] = toASCIILower(c);
     }
     buffer[length] = '\0';
 
     const char* name = buffer;
     const Property* hashTableEntry = findProperty(name, length);
-    if (!hashTableEntry)
+    if (!hashTableEntry) {
+        if (isVariableDefinition(propertyName, length))
+            return CSSPropertyVariable;
         return CSSPropertyInvalid;
+    }
     CSSPropertyID property = static_cast<CSSPropertyID>(hashTableEntry->id);
     if (!CSSPropertyMetadata::isEnabledProperty(property))
         return CSSPropertyInvalid;
     return property;
 }
 
 CSSPropertyID unresolvedCSSPropertyID(const String& string)
 {
     unsigned length = string.length();
 
     if (!length)
         return CSSPropertyInvalid;
-    if (length > maxCSSPropertyNameLength)
+    if (length > maxCSSPropertyNameLength) {
+        if (string.is8Bit() ? isVariableDefinition(string.characters8(), length) : isVariableDefinition(string.characters16(), length))
+            return CSSPropertyVariable;
         return CSSPropertyInvalid;
+    }
 
     return string.is8Bit() ? unresolvedCSSPropertyID(string.characters8(), length) : unresolvedCSSPropertyID(string.characters16(), length);
 }
 
 CSSPropertyID unresolvedCSSPropertyID(const CSSParserString& string)
 {
     unsigned length = string.length();
 
     if (!length)
         return CSSPropertyInvalid;
-    if (length > maxCSSPropertyNameLength)
+    if (length > maxCSSPropertyNameLength) {
+        if (string.is8Bit() ? isVariableDefinition(string.characters8(), length) : isVariableDefinition(string.characters16(), length))
+            return CSSPropertyVariable;
         return CSSPropertyInvalid;
+    }
 
     return string.is8Bit() ? unresolvedCSSPropertyID(string.characters8(), length) : unresolvedCSSPropertyID(string.characters16(), length);
 }
 
 template <typename CharacterType>
 static CSSValueID cssValueKeywordID(const CharacterType* valueKeyword, unsigned length)
 {
     char buffer[maxCSSValueKeywordLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
@@ skipping 612 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink