Rename CSS CalcParser to MathFunctionParser

As CSS comparison function implementation is done, this patch is part of
the cleanup work that finishes the TODOs left behind.

Bug: 825895
Change-Id: Ibd03d10591fdc1923ab34908126521eda27fa444
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1831993
Commit-Queue: Emil A Eklund <eae@chromium.org>
Reviewed-by: Rune Lillesveen <futhark@chromium.org>
Reviewed-by: Emil A Eklund <eae@chromium.org>
Cr-Commit-Position: refs/heads/master@{#701535}

third_party/blink/renderer/core/css/parser/css_property_parser_helpers.cc

@@ -186,14 +186,13 @@ CSSParserTokenRange ConsumeFunction(CSSParserTokenRange& range) {
 }
 
 // TODO(rwlbuis): consider pulling in the parsing logic from
-// CSSCalculationValue.cpp.
-// TODO(xiaochengh): Rename to |MathFunctionParser|.
-class CalcParser {
+// css_math_expression_node.cc.
+class MathFunctionParser {
   STACK_ALLOCATED();
 
  public:
-  explicit CalcParser(CSSParserTokenRange& range,
-                      ValueRange value_range = kValueRangeAll)
+  explicit MathFunctionParser(CSSParserTokenRange& range,
+                              ValueRange value_range = kValueRangeAll)
       : source_range_(range), range_(range) {
     const CSSParserToken& token = range.Peek();
     if (token.FunctionId() == CSSValueID::kCalc ||
@@ -281,20 +280,20 @@ CSSPrimitiveValue* ConsumeInteger(CSSParserTokenRange& range,
         range.ConsumeIncludingWhitespace().NumericValue(),
         CSSPrimitiveValue::UnitType::kInteger);
   }
-  CalcParser calc_parser(range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
-    if (!RuntimeEnabledFeatures::CSSCalcAsIntEnabled() && !calculation->IsInt())
+  MathFunctionParser math_parser(range);
+  if (const CSSMathFunctionValue* math_value = math_parser.Value()) {
+    if (!RuntimeEnabledFeatures::CSSCalcAsIntEnabled() && !math_value->IsInt())
       return nullptr;
-    if (calculation->Category() != kCalcNumber)
+    if (math_value->Category() != kCalcNumber)
       return nullptr;
-    double value = calculation->GetDoubleValue();
-    if (value < minimum_value)
+    double double_value = math_value->GetDoubleValue();
+    if (double_value < minimum_value)
       return nullptr;
     if (!RuntimeEnabledFeatures::CSSCalcAsIntEnabled())
-      return calc_parser.ConsumeNumber();
-    if (calculation->IsInt())
-      return calc_parser.ConsumeNumber();
-    return calc_parser.ConsumeRoundedInt();
+      return math_parser.ConsumeNumber();
+    if (math_value->IsInt())
+      return math_parser.ConsumeNumber();
+    return math_parser.ConsumeRoundedInt();
   }
   return nullptr;
 }
@@ -314,11 +313,11 @@ CSSPrimitiveValue* ConsumeIntegerOrNumberCalc(CSSParserTokenRange& range) {
     range = int_range;
     return value;
   }
-  CalcParser calc_parser(range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     if (calculation->Category() != kCalcNumber)
       return nullptr;
-    return calc_parser.ConsumeValue();
+    return math_parser.ConsumeValue();
   }
   return nullptr;
 }
@@ -332,8 +331,8 @@ bool ConsumeNumberRaw(CSSParserTokenRange& range, double& result) {
     result = range.ConsumeIncludingWhitespace().NumericValue();
     return true;
   }
-  CalcParser calc_parser(range, kValueRangeAll);
-  return calc_parser.ConsumeNumberRaw(result);
+  MathFunctionParser math_parser(range, kValueRangeAll);
+  return math_parser.ConsumeNumberRaw(result);
 }
 
 // TODO(timloh): Work out if this can just call consumeNumberRaw
@@ -346,14 +345,14 @@ CSSPrimitiveValue* ConsumeNumber(CSSParserTokenRange& range,
     return CSSNumericLiteralValue::Create(
         range.ConsumeIncludingWhitespace().NumericValue(), token.GetUnitType());
   }
-  CalcParser calc_parser(range, kValueRangeAll);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, kValueRangeAll);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     // TODO(rwlbuis) Calcs should not be subject to parse time range checks.
     // spec: https://drafts.csswg.org/css-values-3/#calc-range
     if (calculation->Category() != kCalcNumber ||
         (value_range == kValueRangeNonNegative && calculation->IsNegative()))
       return nullptr;
-    return calc_parser.ConsumeNumber();
+    return math_parser.ConsumeNumber();
   }
   return nullptr;
 }
@@ -416,9 +415,9 @@ CSSPrimitiveValue* ConsumeLength(CSSParserTokenRange& range,
   }
   if (css_parser_mode == kSVGAttributeMode)
     return nullptr;
-  CalcParser calc_parser(range, value_range);
-  if (calc_parser.Value() && calc_parser.Value()->Category() == kCalcLength)
-    return calc_parser.ConsumeValue();
+  MathFunctionParser math_parser(range, value_range);
+  if (math_parser.Value() && math_parser.Value()->Category() == kCalcLength)
+    return math_parser.ConsumeValue();
   return nullptr;
 }
 
@@ -432,10 +431,10 @@ CSSPrimitiveValue* ConsumePercent(CSSParserTokenRange& range,
         range.ConsumeIncludingWhitespace().NumericValue(),
         CSSPrimitiveValue::UnitType::kPercentage);
   }
-  CalcParser calc_parser(range, value_range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, value_range);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     if (calculation->Category() == kCalcPercent)
-      return calc_parser.ConsumeValue();
+      return math_parser.ConsumeValue();
   }
   return nullptr;
 }
@@ -476,10 +475,10 @@ CSSPrimitiveValue* ConsumeLengthOrPercent(CSSParserTokenRange& range,
     return ConsumeLength(range, css_parser_mode, value_range, unitless);
   if (token.GetType() == kPercentageToken)
     return ConsumePercent(range, value_range);
-  CalcParser calc_parser(range, value_range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, value_range);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     if (CanConsumeCalcValue(calculation->Category(), css_parser_mode))
-      return calc_parser.ConsumeValue();
+      return math_parser.ConsumeValue();
   }
   return nullptr;
 }
@@ -558,11 +557,11 @@ CSSPrimitiveValue* ConsumeAngle(
     return CSSNumericLiteralValue::Create(
         0, CSSPrimitiveValue::UnitType::kDegrees);
   }
-  CalcParser calc_parser(range, kValueRangeAll);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, kValueRangeAll);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     if (calculation->Category() != kCalcAngle)
       return nullptr;
-    if (CSSMathFunctionValue* result = calc_parser.ConsumeValue()) {
+    if (CSSMathFunctionValue* result = math_parser.ConsumeValue()) {
       if (result->ComputeDegrees() < minimum_value) {
         return CSSNumericLiteralValue::Create(
             minimum_value, CSSPrimitiveValue::UnitType::kDegrees);
@@ -600,10 +599,10 @@ CSSPrimitiveValue* ConsumeTime(CSSParserTokenRange& range,
           token.GetUnitType());
     return nullptr;
   }
-  CalcParser calc_parser(range, value_range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, value_range);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     if (calculation->Category() == kCalcTime)
-      return calc_parser.ConsumeValue();
+      return math_parser.ConsumeValue();
   }
   return nullptr;
 }
@@ -1327,12 +1326,12 @@ static CSSPrimitiveValue* ConsumeGradientAngleOrPercent(
   }
   if (token.GetType() == kPercentageToken)
     return ConsumePercent(range, value_range);
-  CalcParser calc_parser(range, value_range);
-  if (const CSSMathFunctionValue* calculation = calc_parser.Value()) {
+  MathFunctionParser math_parser(range, value_range);
+  if (const CSSMathFunctionValue* calculation = math_parser.Value()) {
     CalculationCategory category = calculation->Category();
     // TODO(fs): Add and support kCalcPercentAngle?
     if (category == kCalcAngle || category == kCalcPercent)
-      return calc_parser.ConsumeValue();
+      return math_parser.ConsumeValue();
   }
   return nullptr;
 }