CSS Custom Properties (Variables)

Source/core/css/resolver/StyleBuilderCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 26 matching lines @@
  */
 
 #include "config.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/StyleBuilderFunctions.h"
 #include "core/StylePropertyShorthand.h"
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSCursorImageValue.h"
+#include "core/css/CSSCustomVariableValue.h"
 #include "core/css/CSSGradientValue.h"
 #include "core/css/CSSGridTemplateAreasValue.h"
 #include "core/css/CSSHelper.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSPropertyMetadata.h"
+#include "core/css/CSSReflectValue.h"

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

unused include?

 #include "core/css/Counter.h"
 #include "core/css/Pair.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
+#include "core/css/parser/CSSParser.h"
+#include "core/css/parser/CSSParserTokenRange.h"
+#include "core/css/parser/CSSPropertyParser.h"
+#include "core/css/resolver/CSSVariableResolver.h"
 #include "core/css/resolver/ElementStyleResources.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/css/resolver/FontBuilder.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/TransformBuilder.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/style/CounterContent.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/ComputedStyleConstants.h"
@@ skipping 28 matching lines @@
     case CSSPropertyWebkitTextFillColor:
     case CSSPropertyWebkitTextStrokeColor:
         return true;
     default:
         return false;
     }
 }
 
 } // namespace
 
+static bool hasVariableReference(CSSValue* value)
+{
+    return value->isPrimitiveValue() && toCSSPrimitiveValue(value)->primitiveType() == CSSPrimitiveValue::CSS_VARIABLE_REFERENCE;
+}
+
 void StyleBuilder::applyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value)
 {
+    if (RuntimeEnabledFeatures::cssVariablesEnabled() /*&& state.documentUsesCSSVariables()*/ && id != CSSPropertyVariable && hasVariableReference(value)) {
+        CSSVariableResolver::resolveAndApplyVariableReferences(state, id, toCSSPrimitiveValue(value));
+        return;
+    }
+
     ASSERT_WITH_MESSAGE(!isShorthandProperty(id), "Shorthand property id = %d wasn't expanded at parsing time", id);
 
     bool isInherit = state.parentNode() && value->isInheritedValue();
     bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
 
     ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
     ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
 
     if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
         // Limit the properties that can be applied to only the ones honored by :visited.
@@ skipping 672 matching lines @@
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitWritingMode(StyleResolverState& state, CSSValue* value)
 {
     state.setWritingMode(*toCSSPrimitiveValue(value));
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(StyleResolverState& state, CSSValue* value)
 {
     state.setTextOrientation(*toCSSPrimitiveValue(value));
 }
 
+void StyleBuilderFunctions::applyValueCSSPropertyVariable(StyleResolverState& state, CSSValue* value)
+{
+    CSSCustomVariableValue* varVal = toCSSCustomVariableValue(value);
+    if (state.style()->variables()) {

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

It doesn't seem like this'll work correctly with inheritance. We point to the
same StyleVariableData as our parent when the StyleRareInheritedData is copied,
so we'll also update our parents' variables.

Maybe we should have ComputedStyle::removeVariable and
ComputedStyle::setVariable, which will do a null check and a hasOneRef check and
behave appropriately?

+        switch (varVal->id()) {
+        case CSSValueUnset:
+        case CSSValueInitial:
+            state.style()->variables()->removeVariable(varVal->name());
+            break;
+        case CSSValueInherit: {
+            StyleVariableData* parentVariables = state.parentStyle()->variables();
+            if (!parentVariables)
+                return;

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

The two nothing-to-do cases here should call removeVariable, otherwise the
following case probably won't work:

:lessspecific { --foo: var; }
#morespecific { --foo: inherit; }

<div id=morespecific class=lessspecific></div>

+            CSSVariableData* value = parentVariables->getVariable(varVal->name());
+            if (!value)
+                return;
+            state.style()->variables()->setVariable(varVal->name(), value);
+            break;
+        }
+        case CSSValueInternalVariableValue:
+            state.style()->variables()->setVariable(varVal->name(), varVal->value());
+        break;

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

indentation is off

+        default:
+            ASSERT_NOT_REACHED();
+        }
+    } else if (varVal->id() == CSSValueInternalVariableValue) {
+        RefPtr<StyleVariableData> variableData = state.parentStyle()->variables() ? state.parentStyle()->variables()->copy() : StyleVariableData::create();
+        variableData->setVariable(varVal->name(), varVal->value());
+        state.style()->setVariables(variableData.release());
+    }
+}
+
+void StyleBuilderFunctions::applyInheritCSSPropertyVariable(StyleResolverState& state)
+{
+    ASSERT_NOT_REACHED();
+}
+
+void StyleBuilderFunctions::applyInitialCSSPropertyVariable(StyleResolverState& state)
+{
+    ASSERT_NOT_REACHED();
+}
+
 void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(StyleResolverState& state)
 {
     const SVGComputedStyle& parentSvgStyle = state.parentStyle()->svgStyle();
     EBaselineShift baselineShift = parentSvgStyle.baselineShift();
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     svgStyle.setBaselineShift(baselineShift);
     if (baselineShift == BS_LENGTH)
         svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
 }
 
@@ skipping 16 matching lines @@
         return;
     case CSSValueSuper:
         svgStyle.setBaselineShift(BS_SUPER);
         return;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink