Make CSSCalcValue work with CSSParserTokenRange

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,
@@ skipping 14 matching lines @@
 #include "core/css/CSSSelectorList.h"
 #include "core/css/parser/CSSParserToken.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 
 namespace blink {
 
 using namespace WTF;
 
+void consumeUntilBlockEnd(CSSParserTokenRange& range, Vector<CSSParserToken> &args, bool& usesRemUnits)
+{
+    unsigned nestingLevel = 1;
+    do {
+        const CSSParserToken& token = range.consume();
+        if (token.blockType() == CSSParserToken::BlockStart)
+            nestingLevel++;
+        else if (token.blockType() == CSSParserToken::BlockEnd)
+            nestingLevel--;
+        if (nestingLevel) {
+            args.append(token);
+            if (token.unitType() == CSSPrimitiveValue::CSS_REMS)
+                usesRemUnits = true;
+        }
+    } while (nestingLevel && !range.atEnd());
+
+    while (nestingLevel-- > 1) {
+        static CSSParserToken rightBracket(DelimiterToken, ')');
+        args.append(rightBracket);
+    }
+}
+
 CSSParserValueList::CSSParserValueList(CSSParserTokenRange range, bool& usesRemUnits)
 : m_current(0)
 {
     usesRemUnits = false;
     Vector<CSSParserValueList*> stack;
     Vector<int> bracketCounts;
     stack.append(this);
     bracketCounts.append(0);
     unsigned calcDepth = 0;

[Timothy Loh, 2015/07/21 07:33:17]

don't need this anymore

[rwlbuis, 2015/07/22 02:19:06]

Done.

     while (!range.atEnd()) {
         ASSERT(stack.size() == bracketCounts.size());
         ASSERT(!stack.isEmpty());
         const CSSParserToken& token = range.consume();
         CSSParserValue value;
         switch (token.type()) {
         case FunctionToken: {
             if (token.valueEqualsIgnoringCase("url")) {
                 const CSSParserToken& next = range.consumeIncludingWhitespace();
                 if (next.type() == BadStringToken || range.consume().type() != RightParenthesisToken) {
                     destroyAndClear();
                     return;
                 }
                 ASSERT(next.type() == StringToken);
                 value.id = CSSValueInvalid;
                 value.isInt = false;
                 value.unit = CSSPrimitiveValue::CSS_URI;
                 value.string = next.value();
                 break;
             }
 
+            value.id = CSSValueInvalid;
+            value.isInt = false;
+
+            CSSValueID id = cssValueKeywordID(token.value());
+            if (id == CSSValueCalc || id == CSSValueWebkitCalc) {
+                value.unit = CSSParserValue::CalcFunction;
+                value.calcFunction = new CSSParserCalcFunction;
+                consumeUntilBlockEnd(range, value.calcFunction->args, usesRemUnits);
+
+                calcDepth++;
+                break;
+            }
+            value.unit = CSSParserValue::Function;
             CSSParserFunction* function = new CSSParserFunction;
-            function->id = cssValueKeywordID(token.value());
+            function->id = id;
             CSSParserValueList* list = new CSSParserValueList;
             function->args = adoptPtr(list);
 
-            value.id = CSSValueInvalid;
-            value.isInt = false;
-            value.unit = CSSParserValue::Function;
             value.function = function;
 
             stack.last()->addValue(value);
             stack.append(list);
             bracketCounts.append(0);
-            calcDepth += (function->id == CSSValueCalc || function->id == CSSValueWebkitCalc);
             continue;
         }
         case LeftParenthesisToken: {
             if (calcDepth == 0) {
                 CSSParserValueList* list = new CSSParserValueList;
                 value.setFromValueList(adoptPtr(list));
                 stack.last()->addValue(value);
                 stack.append(list);
                 bracketCounts.append(0);
                 continue;
             }
             bracketCounts.last()++;
             value.setFromOperator('(');
             break;
         }
         case RightParenthesisToken: {
             if (bracketCounts.last() == 0) {
                 stack.removeLast();
                 bracketCounts.removeLast();
                 if (bracketCounts.isEmpty()) {
                     destroyAndClear();
                     return;
                 }
                 CSSParserValueList* currentList = stack.last();
                 CSSParserValue* current = currentList->valueAt(currentList->size()-1);
-                if (current->unit == CSSParserValue::Function) {
+                if (current->unit == CSSParserValue::CalcFunction) {
                     CSSValueID id = current->function->id;
                     calcDepth -= (id == CSSValueCalc || id == CSSValueWebkitCalc);
                 }
                 continue;
             }
             ASSERT(calcDepth > 0);
             bracketCounts.last()--;
             value.setFromOperator(')');
             break;
         }
@@ skipping 57 matching lines @@
                 value.unit = CSSParserValue::HexColor;
             else if (token.type() == StringToken)
                 value.unit = CSSPrimitiveValue::CSS_STRING;
             else
                 value.unit = CSSPrimitiveValue::CSS_URI;
             value.string = token.value();
             break;
         }
         case DelimiterToken:
             value.setFromOperator(token.delimiter());
-            if (calcDepth && token.delimiter() == '+' && (&token - 1)->type() != WhitespaceToken) {
-                // calc(1px+ 2px) is invalid
-                destroyAndClear();
-                return;
-            }
             break;
         case CommaToken:
             value.setFromOperator(',');
             break;
         case LeftBracketToken:
             value.setFromOperator('[');
             break;
         case RightBracketToken:
             value.setFromOperator(']');
             break;
@@ skipping 32 matching lines @@
     while (!stack.isEmpty()) {
         while (bracketCounts.last() > 0) {
             bracketCounts.last()--;
             stack.last()->addValue(rightParenthesis);
         }
         stack.removeLast();
         bracketCounts.removeLast();
     }
 }
 
 static void destroy(Vector<CSSParserValue, 4>& values)

[Timothy Loh, 2015/07/21 07:33:17]

need to update this

[rwlbuis, 2015/07/22 02:19:06]

Ouch I thought it was not needed after I introduced CSSParserTokenRange for args
somehow, but it is still needed. Will fix tomorrow.

[rwlbuis, 2015/07/22 20:53:02]

Ok, fixed now :)
PTAL.

 {
     size_t numValues = values.size();
     for (size_t i = 0; i < numValues; i++) {
         if (values[i].unit == CSSParserValue::Function)
             delete values[i].function;
         else if (values[i].unit == CSSParserValue::ValueList
             || values[i].unit == CSSParserValue::DimensionList)
             delete values[i].valueList;
     }
 }
@@ skipping 101 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