CSS Custom Properties (Variables)

Source/core/css/parser/CSSVariableParser.cpp

Index: Source/core/css/parser/CSSVariableParser.cpp
diff --git a/Source/core/css/parser/CSSVariableParser.cpp b/Source/core/css/parser/CSSVariableParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..45323fb1672fab7f7bd5b8be91e18878cf15e7c3
--- /dev/null
+++ b/Source/core/css/parser/CSSVariableParser.cpp
@@ -0,0 +1,143 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/css/parser/CSSVariableParser.h"
+
+#include "core/css/parser/CSSParserTokenRange.h"
+#include "core/css/parser/CSSParserValues.h"
+
+namespace blink {
+
+static bool isValidVariableName(const CSSParserToken& token)
+{
+    CSSParserString value = token.value();
+    return value.length() >= 2 && value[0] == '-' && value[0] == value[1];
+}
+
+static bool isValidVariableReference(CSSParserTokenRange& range)
+{
+    bool foundVariableIdentToken = false;
+    bool foundComma = false;
+    bool contentAfterComma = false;
+    unsigned bracketCount = 0;
+    while (!range.atEnd()) {
+        const CSSParserToken& token = range.consume();
+        switch (token.type()) {
+        case WhitespaceToken:
+            if (foundComma)
+                contentAfterComma = true;
+            break;
+        case IdentToken:
+            if (foundComma) {
+                contentAfterComma = true;
+            } else if (!foundVariableIdentToken) {
+                if (!isValidVariableName(token))
+                    return false;
+                foundVariableIdentToken = true;
+            } else {
+                return false;
+            }
+            break;
+        case LeftParenthesisToken:
+            if (!foundComma)
+                return false;
+            bracketCount++;
+            break;
+        case RightParenthesisToken:
+            if (!foundVariableIdentToken)
+                return false;
+            if (!bracketCount)
+                return foundVariableIdentToken && (!foundComma || contentAfterComma);
+            bracketCount--;
+            break;
+        case CommaToken:
+            if (!foundVariableIdentToken)
+                return false;
+            foundComma = true;
+            break;
+        case CommentToken:
+        case EOFToken:
+            ASSERT_NOT_REACHED();
+        case CDOToken:
+        case CDCToken:
+        case AtKeywordToken:
+        case IncludeMatchToken:
+        case DashMatchToken:
+        case PrefixMatchToken:
+        case SuffixMatchToken:
+        case SubstringMatchToken:
+        case ColumnToken:
+        case BadStringToken:
+        case BadUrlToken:
+        case ColonToken:
+        case SemicolonToken:
+            return false;
+        default:
+            if (!foundComma)
+                return false;
+            break;
+        }
+    }
+    return false;
+}
+
+static CSSVariableParser::DefinitionType hasValidReferences(const CSSParserTokenRange& originalRange)
+{
+    CSSParserTokenRange range = originalRange;
+    CSSVariableParser::DefinitionType type = CSSVariableParser::Variable;
+    while (!range.atEnd()) {
+        const CSSParserToken& token = range.consume();
+        switch (token.type()) {
+        case FunctionToken:
+            if (token.valueEqualsIgnoringCase("var")) {
+                if (!isValidVariableReference(range))
+                    return CSSVariableParser::Invalid; // Bail if any references are invalid
+                type = CSSVariableParser::VariableWithReferences;
+            }
+            break;
+        case CommentToken:
+        case EOFToken:
+            ASSERT_NOT_REACHED();
+        case IdentToken:
+            // TODO(leviw): This isn't correct.
+            if (token.valueEqualsIgnoringCase("inherit") || token.valueEqualsIgnoringCase("unset"))
+                type = CSSVariableParser::Inherit;
+            else if (token.valueEqualsIgnoringCase("initial"))
+                type = CSSVariableParser::Initial;
+            break;
+        case CDOToken:
+        case CDCToken:
+        case AtKeywordToken:
+        case IncludeMatchToken:
+        case DashMatchToken:
+        case PrefixMatchToken:
+        case SuffixMatchToken:
+        case SubstringMatchToken:
+        case ColumnToken:
+        case BadStringToken:
+        case BadUrlToken:
+        case ColonToken:
+        case SemicolonToken:
+            return CSSVariableParser::Invalid;
+        default:
+            break;
+        }
+    }
+    return type;
+}
+
+bool CSSVariableParser::containsValidVariableReferences(const CSSParserTokenRange& originalRange)
+{
+    return VariableWithReferences == hasValidReferences(originalRange);
+}
+
+CSSVariableParser::DefinitionType CSSVariableParser::parseVariableDefinition(const CSSParserTokenRange& originalRange)
+{
+    if (originalRange.atEnd())
+        return CSSVariableParser::Invalid;
+    return hasValidReferences(originalRange);
+}
+
+} // namespace blink