CSS Custom Properties (Variables)

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/css/CSSPrimitiveValue.h"
 
 #include "core/css/CSSBasicShapes.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSHelper.h"
 #include "core/css/CSSMarkup.h"
 #include "core/css/CSSToLengthConversionData.h"
+#include "core/css/CSSVariableData.h"
 #include "core/css/Counter.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Node.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
 #include "platform/fonts/FontMetrics.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/ThreadSpecific.h"
@@ skipping 145 matching lines @@
     case CalcPercent:
         return CSS_PERCENTAGE;
     case CalcLength:
         return CSS_PX;
     case CalcPercentNumber:
         return CSS_CALC_PERCENTAGE_WITH_NUMBER;
     case CalcPercentLength:
         return CSS_CALC_PERCENTAGE_WITH_LENGTH;
     case CalcTime:
         return CSS_MS;
+    case CalcVariable: // The type of a calculation containing a variable cannot be known until the value of the variable is determined.
     case CalcOther:
         return CSS_UNKNOWN;
     }
     return CSS_UNKNOWN;
 }
 
 static const AtomicString& propertyName(CSSPropertyID propertyID)
 {
     return getPropertyNameAtomicString(propertyID);
 }
@@ skipping 37 matching lines @@
 
 CSSPrimitiveValue::CSSPrimitiveValue(const String& str, UnitType type)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = type;
     m_value.string = str.impl();
     if (m_value.string)
         m_value.string->ref();
 }
 
+CSSPrimitiveValue::CSSPrimitiveValue(CSSVariableData* variableData)
+    : CSSValue(PrimitiveClass)
+{
+    m_primitiveUnitType = CSSPrimitiveValue::CSS_VARIABLE_REFERENCE;
+    m_value.variableData = variableData;
+    if (m_value.variableData)
+        m_value.variableData->ref();
+}
+
 CSSPrimitiveValue::CSSPrimitiveValue(const LengthSize& lengthSize, const ComputedStyle& style)
     : CSSValue(PrimitiveClass)
 {
     init(lengthSize, style);
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(RGBA32 color)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_RGBCOLOR;
@@ skipping 129 matching lines @@
 void CSSPrimitiveValue::cleanup()
 {
     switch (static_cast<UnitType>(m_primitiveUnitType)) {
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
         if (m_value.string)
             m_value.string->deref();
         break;
+    case CSS_VARIABLE_REFERENCE:
+        if (m_value.variableData)
+            m_value.variableData->deref();
+        break;
     case CSS_COUNTER:
         // We must not call deref() when oilpan is enabled because m_value.counter is traced.
 #if !ENABLE(OILPAN)
         m_value.counter->deref();
 #endif
         break;
     case CSS_RECT:
         // We must not call deref() when oilpan is enabled because m_value.rect is traced.
 #if !ENABLE(OILPAN)
         m_value.rect->deref();
@@ skipping 402 matching lines @@
     switch (m_primitiveUnitType) {
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_ATTR:
     case CSS_URI:
         return m_value.string;
     case CSS_VALUE_ID:
         return valueName(m_value.valueID);
     case CSS_PROPERTY_ID:
         return propertyName(m_value.propertyID);
+    case CSS_VARIABLE_REFERENCE:
+        return m_value.variableData->string();
     default:
         break;
     }
 
     return String();
 }
 
 static String formatNumber(double number, const char* suffix, unsigned suffixLength)
 {
 #if OS(WIN) && _MSC_VER < 1900
@@ skipping 88 matching lines @@
     case CSS_RECT:
     case CSS_QUAD:
     case CSS_RGBCOLOR:
     case CSS_PAIR:
     case CSS_CALC:
     case CSS_SHAPE:
     case CSS_IDENT:
     case CSS_CALC_PERCENTAGE_WITH_NUMBER:
     case CSS_CALC_PERCENTAGE_WITH_LENGTH:
     case CSS_QEM:
+    case CSS_VARIABLE_REFERENCE:
         break;
     };
     ASSERT_NOT_REACHED();
     return "";
 }
 
 String CSSPrimitiveValue::customCSSText() const
 {
     if (m_hasCachedCSSText) {
         ASSERT(cssTextCache().contains(this));
@@ skipping 97 matching lines @@
         }
         case CSS_PAIR:
             text = getPairValue()->cssText();
             break;
         case CSS_CALC:
             text = m_value.calc->cssText();
             break;
         case CSS_SHAPE:
             text = m_value.shape->cssText();
             break;
+        case CSS_VARIABLE_REFERENCE:
+            text = "var(" + String(m_value.string) + ")";
+            break;
     }
 
     ASSERT(!cssTextCache().contains(this));
     cssTextCache().set(this, text);
     m_hasCachedCSSText = true;
     return text;
 }
 
 bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const
 {
@@ skipping 32 matching lines @@
     case CSS_FR:
         return m_value.num == other.m_value.num;
     case CSS_PROPERTY_ID:
         return m_value.propertyID == other.m_value.propertyID;
     case CSS_VALUE_ID:
         return m_value.valueID == other.m_value.valueID;
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
+    case CSS_VARIABLE_REFERENCE:
         return equal(m_value.string, other.m_value.string);
     case CSS_COUNTER:
         return m_value.counter && other.m_value.counter && m_value.counter->equals(*other.m_value.counter);
     case CSS_RECT:
         return m_value.rect && other.m_value.rect && m_value.rect->equals(*other.m_value.rect);
     case CSS_QUAD:
         return m_value.quad && other.m_value.quad && m_value.quad->equals(*other.m_value.quad);
     case CSS_RGBCOLOR:
         return m_value.rgbcolor == other.m_value.rgbcolor;
     case CSS_PAIR:
@@ skipping 29 matching lines @@
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink