Make CSSCalcValue work with CSSParserTokenRange

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 166 matching lines @@
         if (!b && (unitflags & (FInteger | FPositiveInteger)) && m_parsedCalculation->isInt())
             b = true;
         if (b && mustBeNonNegative && m_parsedCalculation->isNegative())
             b = false;
         // Always resolve calc() to a UnitType::Number in the CSSParserValue if there are no non-numbers specified in the unitflags.
         if (b && !(unitflags & ~(FInteger | FNumber | FPositiveInteger | FNonNeg))) {
             double number = m_parsedCalculation->doubleValue();
             if ((unitflags & FPositiveInteger) && number <= 0) {
                 b = false;
             } else {
-                delete value->function;
+                delete value->calcFunction;
                 value->setUnit(CSSPrimitiveValue::UnitType::Number);
                 value->fValue = number;
                 value->isInt = m_parsedCalculation->isInt();
             }
             m_parsedCalculation.release();
             return b;
         }
         break;
     case CalcPercent:
         b = (unitflags & FPercent);
@@ skipping 25 matching lines @@
 
 inline bool CSSPropertyParser::shouldAcceptUnitLessValues(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode)
 {
     // Quirks mode for certain properties and presentation attributes accept unit-less values for certain units.
     return (unitflags & (FLength | FAngle))
         && (!value->fValue // 0 can always be unitless.
             || isUnitLessLengthParsingEnabledForMode(cssParserMode) // HTML and SVG attribute values can always be unitless.
             || (cssParserMode == HTMLQuirksMode && (unitflags & FUnitlessQuirk)));
 }
 
+inline bool isCalculation(CSSParserValue* value)
+{
+    return value->m_unit == CSSParserValue::CalcFunction;
+}
+
 bool CSSPropertyParser::validUnit(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode, ReleaseParsedCalcValueCondition releaseCalc)
 {
     if (isCalculation(value))
         return validCalculationUnit(value, unitflags, releaseCalc);
 
     if (unitflags & FNonNeg && value->fValue < 0)
         return false;
     switch (value->unit()) {
     case CSSPrimitiveValue::UnitType::Number:
         if (unitflags & FNumber)
@@ skipping 4711 matching lines @@
         UChar32 end = current->m_unicodeRange.end;
         if (start > end)
             return nullptr;
         values->append(CSSUnicodeRangeValue::create(start, end));
         m_valueList->next();
     } while (consumeComma(m_valueList));
 
     return values.release();
 }
 
-
-bool CSSPropertyParser::isCalculation(CSSParserValue* value)
-{
-    return (value->m_unit == CSSParserValue::Function)
-        && (value->function->id == CSSValueCalc
-            || value->function->id == CSSValueWebkitCalc);
-}
-
 inline int CSSPropertyParser::colorIntFromValue(CSSParserValue* v)
 {
     bool isPercent;
     double value;
 
     if (m_parsedCalculation) {
         isPercent = m_parsedCalculation->category() == CalcPercent;
         value = m_parsedCalculation->doubleValue();
         m_parsedCalculation.release();
     } else {
@@ skipping 2453 matching lines @@
         return false;
 
     addProperty(CSSPropertyFontVariantLigatures, ligatureValues.release(), important);
     return true;
 }
 
 bool CSSPropertyParser::parseCalculation(CSSParserValue* value, ValueRange range)
 {
     ASSERT(isCalculation(value));
 
-    CSSParserValueList* args = value->function->args.get();
-    if (!args || !args->size())
-        return false;
+    CSSParserTokenRange args = value->calcFunction->args;
 
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
@@ skipping 707 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink