CSS Custom Properties (Variables)

third_party/WebKit/Source/core/css/parser/CSSVariableParser.cpp

+// 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/CSSCustomPropertyDeclaration.h"
+#include "core/css/parser/CSSParserTokenRange.h"
+#include "core/css/parser/CSSParserValues.h"
+
+namespace blink {
+
+static bool isValidVariableName(const CSSParserToken& token)
+{
+    if (token.type() != IdentToken)
+        return false;
+
+    CSSParserString value = token.value();
+    return value.length() >= 2 && value[0] == '-' && value[1] == '-';
+}
+
+static bool isValidVariableReference(CSSParserTokenRange range)
+{
+    range.consumeWhitespace();
+    if (!isValidVariableName(range.consumeIncludingWhitespace()))
+        return false;
+    if (range.atEnd())
+        return true;
+
+    range.consumeWhitespace();

[Timothy Loh, 2015/09/30 02:09:28]

This is a no-op because we used consumeIncludingWhitespace above.

+    if (range.consume().type() != CommaToken)
+        return false;
+    if (range.atEnd())
+        return false;
+
+    int blockNestingLevel = 0;

[Timothy Loh, 2015/09/30 02:09:28]

Can we just call classifyBlock recursively here?

+    while (!range.atEnd()) {
+        const CSSParserToken& token = range.consume();
+
+        if (token.blockType() == CSSParserToken::BlockStart) {
+            blockNestingLevel++;
+        } else if (token.blockType() == CSSParserToken::BlockEnd) {
+            blockNestingLevel--;
+            if (blockNestingLevel < 0)
+                return false;
+        }
+
+        switch (token.type()) {
+        case DelimiterToken:
+            if (token.delimiter() == '!' && !blockNestingLevel)
+                return false;
+            break;
+        case BadStringToken:
+        case BadUrlToken:
+            return false;
+        case CommentToken:
+        case EOFToken:
+            ASSERT_NOT_REACHED();
+        case SemicolonToken:
+            if (!blockNestingLevel)
+                return false;
+            break;
+        default:
+            break;
+        }
+    }
+    return true;
+}
+
+bool classifyBlock(CSSParserTokenRange range, bool& hasReferences, bool isTopLevelBlock = true)
+{
+    int parenthesisCount = 0;
+    int braceCount = 0;
+    int bracketCount = 0;
+
+    // TODO(leviw): Use consumeBlock to keep track of nesting instead of doing it directly here.
+    while (!range.atEnd()) {
+        if (range.peek().blockType() == CSSParserToken::BlockStart) {
+            const CSSParserToken& token = range.peek();
+            CSSParserTokenRange block = range.consumeBlock();
+            if (token.type() == FunctionToken && token.valueEqualsIgnoringCase("var")) {
+                if (!isValidVariableReference(block))
+                    return false; // Bail if any references are invalid
+                hasReferences = true;
+                continue;
+            }
+            if (!classifyBlock(block, hasReferences, false))
+                return false;
+            continue;
+        }
+
+        const CSSParserToken& token = range.consume();
+        switch (token.type()) {
+        case FunctionToken:
+            ASSERT_NOT_REACHED();
+            break;
+        case CommentToken:

[Timothy Loh, 2015/09/30 02:09:28]

I would probably leave out the ASSERT_NOT_REACHED cases to keep this short, and
instead of keeping track of bracket counts just check if the blockType isn't
BlockEnd.

+        case EOFToken:
+            ASSERT_NOT_REACHED();
+        case DelimiterToken: {
+            if (token.delimiter() == '!' && isTopLevelBlock)
+                return false;
+            break;
+        }
+        case RightParenthesisToken:
+            if (!parenthesisCount)
+                return false;
+            parenthesisCount--;
+            break;
+        case LeftParenthesisToken:
+            parenthesisCount++;
+            break;
+        case RightBraceToken:
+            if (!braceCount)
+                return false;
+            braceCount--;
+            break;
+        case LeftBraceToken:
+            braceCount++;
+            break;
+        case RightBracketToken:
+            if (!bracketCount)
+                return false;
+            bracketCount--;
+            break;
+        case LeftBracketToken:
+            bracketCount++;
+            break;
+        case BadStringToken:
+        case BadUrlToken:
+            return false;
+        case WhitespaceToken:
+            break;
+        case SemicolonToken:
+            if (isTopLevelBlock)
+                return false;
+            break;
+        default:
+            break;
+        }
+    }
+    return true;
+}
+
+static CSSValueID classifyVariableRange(CSSParserTokenRange range, bool& hasReferences)
+{
+    hasReferences = false;
+
+    range.consumeWhitespace();
+    if (range.peek().type() == IdentToken) {
+        const CSSParserToken& ident = range.consumeIncludingWhitespace();

[Timothy Loh, 2015/09/30 02:09:28]

We have a helper function now so we can write

CSSValueID id = range.consumeIncludingWhitespace().id();
if (range.atEnd()) {
    if (id == CSSValueInherit || ...)
        return id;
}

+        if (range.atEnd()) {
+            if (ident.valueEqualsIgnoringCase("inherit"))
+                return CSSValueInherit;
+            if (ident.valueEqualsIgnoringCase("initial"))
+                return CSSValueInitial;
+            if (ident.valueEqualsIgnoringCase("unset"))
+                return CSSValueUnset;
+        }
+    }
+
+    if (classifyBlock(range, hasReferences))
+        return CSSValueInternalVariableValue;
+    return CSSValueInvalid;
+}
+
+bool CSSVariableParser::containsValidVariableReferences(CSSParserTokenRange range)
+{
+    bool hasReferences;
+    CSSValueID type = classifyVariableRange(range, hasReferences);
+    return type == CSSValueInternalVariableValue && hasReferences;
+}
+
+PassRefPtrWillBeRawPtr<CSSCustomPropertyDeclaration> CSSVariableParser::parseDeclarationValue(const AtomicString& variableName, CSSParserTokenRange range)
+{
+    if (range.atEnd())
+        return nullptr;
+
+    bool hasReferences;
+    CSSValueID type = classifyVariableRange(range, hasReferences);
+
+    if (type == CSSValueInvalid)
+        return nullptr;
+    if (type == CSSValueInternalVariableValue)
+        return CSSCustomPropertyDeclaration::create(variableName, CSSVariableData::create(range, hasReferences));
+    return CSSCustomPropertyDeclaration::create(variableName, type);
+}
+
+} // namespace blink