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 16 matching lines @@
 #include "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapes.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSCanvasValue.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCursorImageValue.h"
+#include "core/css/CSSCustomVariableValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
@@ skipping 387 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() && value->unit == CSSParserValue::VariableValue) {
+        // We don't expand the shorthand here because crazypants.
+        m_parsedProperties.append(CSSProperty(propId, CSSPrimitiveValue::create(value->variableData), 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 1069 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;
-

[Timothy Loh, 2015/07/23 08:11:47]

change isn't relevant

     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 6010 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))

[Timothy Loh, 2015/07/23 08:11:47]

These don't really do what I'd expect. Any code which parses property names is
probably going to have to explicitly handle variables, so I'd just leave this
function as is but expose the isVariableDefinition (isCustomProperty?)

+                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 523 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink