CSS Custom Properties (Variables)

Source/core/css/parser/CSSParserValues.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008 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/parser/CSSParserValues.h"
 
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSSelectorList.h"
+#include "core/css/CSSVariableData.h"
 #include "core/css/parser/CSSParserToken.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSPropertyParser.h"
+#include "core/css/parser/CSSTokenizer.h"

[Timothy Loh, 2015/08/25 09:21:10]

not used?

+#include "core/css/parser/CSSVariableParser.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "wtf/text/StringBuilder.h"

[Timothy Loh, 2015/08/25 09:21:10]

not used?

 
 namespace blink {
 
 using namespace WTF;
 
 CSSParserValueList::CSSParserValueList(CSSParserTokenRange range)
 : m_current(0)
 {
+    CSSParserTokenRange originalRangeForVariables = range;

[Timothy Loh, 2015/08/25 09:21:10]

Maybe better to check for variables in the CSSPropertyParser if parsing normally
fails instead of extending CSSParserValueList.

+
     Vector<CSSParserValueList*> stack;
     Vector<int> bracketCounts;
     stack.append(this);
     bracketCounts.append(0);
     while (!range.atEnd()) {
         ASSERT(stack.size() == bracketCounts.size());
         ASSERT(!stack.isEmpty());
         const CSSParserToken& token = range.peek();
         if (token.type() != FunctionToken)
             range.consume();
         CSSParserValue value;
         switch (token.type()) {
         case FunctionToken: {
             if (token.valueEqualsIgnoringCase("url")) {
                 range.consume();
                 const CSSParserToken& next = range.consumeIncludingWhitespace();
                 if (next.type() == BadStringToken || range.consume().type() != RightParenthesisToken) {
-                    destroyAndClear();
+                    checkForVariableReferencesOrDestroyAndClear(originalRangeForVariables);
                     return;
                 }
                 ASSERT(next.type() == StringToken);
                 value.id = CSSValueInvalid;
                 value.isInt = false;
                 value.setUnit(CSSPrimitiveValue::UnitType::URI);
                 value.string = next.value();
                 break;
+            } else if (token.valueEqualsIgnoringCase("var")) {
+                checkForVariableReferencesOrDestroyAndClear(originalRangeForVariables);
+                return;
             }
 
             value.id = CSSValueInvalid;
             value.isInt = false;
 
             CSSValueID id = cssValueKeywordID(token.value());
             if (id == CSSValueCalc || id == CSSValueWebkitCalc) {
                 value.m_unit = CSSParserValue::CalcFunction;
                 value.calcFunction = new CSSParserCalcFunction(range.consumeBlock());
                 break;
@@ skipping 18 matching lines @@
             stack.last()->addValue(value);
             stack.append(list);
             bracketCounts.append(0);
             continue;
         }
         case RightParenthesisToken: {
             if (bracketCounts.last() == 0) {
                 stack.removeLast();
                 bracketCounts.removeLast();
                 if (bracketCounts.isEmpty()) {
-                    destroyAndClear();
+                    checkForVariableReferencesOrDestroyAndClear(originalRangeForVariables);
                     return;
                 }
                 continue;
             }
             bracketCounts.last()--;
             value.setFromOperator(')');
             break;
         }
         case IdentToken: {
             value.id = cssValueKeywordID(token.value());
@@ skipping 83 matching lines @@
             ASSERT_NOT_REACHED();
         case CDOToken:
         case CDCToken:
         case AtKeywordToken:
         case IncludeMatchToken:
         case DashMatchToken:
         case PrefixMatchToken:
         case SuffixMatchToken:
         case SubstringMatchToken:
         case ColumnToken:
+        case ColonToken:
+        case SemicolonToken:
+            checkForVariableReferencesOrDestroyAndClear(originalRangeForVariables);
+            return;
         case BadStringToken:
         case BadUrlToken:
-        case ColonToken:
-        case SemicolonToken:
             destroyAndClear();
             return;
         }
         stack.last()->addValue(value);
     }
 
     CSSParserValue rightParenthesis;
     rightParenthesis.setFromOperator(')');
     while (!stack.isEmpty()) {
         while (bracketCounts.last() > 0) {
             bracketCounts.last()--;
             stack.last()->addValue(rightParenthesis);
         }
         stack.removeLast();
         bracketCounts.removeLast();
     }
 }
 
 static void destroy(Vector<CSSParserValue, 4>& values)
 {
     size_t numValues = values.size();
     for (size_t i = 0; i < numValues; i++) {
         if (values[i].m_unit == CSSParserValue::Function)
             delete values[i].function;
         else if (values[i].m_unit == CSSParserValue::CalcFunction)
             delete values[i].calcFunction;
         else if (values[i].m_unit == CSSParserValue::ValueList
             || values[i].m_unit == CSSParserValue::DimensionList)
             delete values[i].valueList;
+        else if (values[i].unit() == CSSPrimitiveValue::UnitType::VariableReference)
+            values[i].variableData->deref();
     }
 }
 
+void CSSParserValueList::checkForVariableReferencesOrDestroyAndClear(const CSSParserTokenRange& originalRange)
+{
+    // We have to clear any state that may have been previously loaded
+    destroyAndClear();
+    if (RuntimeEnabledFeatures::cssVariablesEnabled() && CSSVariableParser::containsValidVariableReferences(originalRange))
+        consumeVariableValue(originalRange);
+}
+
+void CSSParserValueList::consumeVariableValue(const CSSParserTokenRange& originalRange)
+{
+    ASSERT(m_values.isEmpty());
+    CSSParserValue variableValue;
+    variableValue.id = CSSValueInternalVariableValue;
+    variableValue.isInt = false;
+    variableValue.setUnit(CSSPrimitiveValue::UnitType::VariableReference);
+    variableValue.variableData = CSSVariableData::create(originalRange).leakRef();
+    addValue(variableValue);
+}
+
+
 void CSSParserValueList::destroyAndClear()
 {
     destroy(m_values);
     clearAndLeakValues();
 }
 
 CSSParserValueList::~CSSParserValueList()
 {
     destroy(m_values);
 }
@@ skipping 90 matching lines @@
 bool CSSParserSelector::hasHostPseudoSelector() const
 {
     for (CSSParserSelector* selector = const_cast<CSSParserSelector*>(this); selector; selector = selector->tagHistory()) {
         if (selector->pseudoType() == CSSSelector::PseudoHost || selector->pseudoType() == CSSSelector::PseudoHostContext)
             return true;
     }
     return false;
 }
 
 } // namespace blink