/*
 * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "third_party/blink/renderer/core/css/css_math_expression_node.h"

#include "third_party/blink/renderer/core/css/css_numeric_literal_value.h"
#include "third_party/blink/renderer/core/css/css_primitive_value_mappings.h"
#include "third_party/blink/renderer/core/css/css_value_clamping_utils.h"
#include "third_party/blink/renderer/core/css/properties/css_parsing_utils.h"
#include "third_party/blink/renderer/core/css/resolver/style_resolver.h"
#include "third_party/blink/renderer/platform/geometry/calculation_expression_node.h"
#include "third_party/blink/renderer/platform/wtf/math_extras.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"

static const int maxExpressionDepth = 100;

enum ParseState { OK, TooDeep, NoMoreTokens };

namespace blink {

static CalculationCategory UnitCategory(CSSPrimitiveValue::UnitType type) {
  switch (type) {
    case CSSPrimitiveValue::UnitType::kNumber:
    case CSSPrimitiveValue::UnitType::kInteger:
      return kCalcNumber;
    case CSSPrimitiveValue::UnitType::kPercentage:
      return kCalcPercent;
    case CSSPrimitiveValue::UnitType::kEms:
    case CSSPrimitiveValue::UnitType::kExs:
    case CSSPrimitiveValue::UnitType::kPixels:
    case CSSPrimitiveValue::UnitType::kCentimeters:
    case CSSPrimitiveValue::UnitType::kMillimeters:
    case CSSPrimitiveValue::UnitType::kQuarterMillimeters:
    case CSSPrimitiveValue::UnitType::kInches:
    case CSSPrimitiveValue::UnitType::kPoints:
    case CSSPrimitiveValue::UnitType::kPicas:
    case CSSPrimitiveValue::UnitType::kUserUnits:
    case CSSPrimitiveValue::UnitType::kRems:
    case CSSPrimitiveValue::UnitType::kChs:
    case CSSPrimitiveValue::UnitType::kViewportWidth:
    case CSSPrimitiveValue::UnitType::kViewportHeight:
    case CSSPrimitiveValue::UnitType::kViewportMin:
    case CSSPrimitiveValue::UnitType::kViewportMax:
      return kCalcLength;
    case CSSPrimitiveValue::UnitType::kDegrees:
    case CSSPrimitiveValue::UnitType::kGradians:
    case CSSPrimitiveValue::UnitType::kRadians:
    case CSSPrimitiveValue::UnitType::kTurns:
      return kCalcAngle;
    case CSSPrimitiveValue::UnitType::kMilliseconds:
    case CSSPrimitiveValue::UnitType::kSeconds:
      return kCalcTime;
    case CSSPrimitiveValue::UnitType::kHertz:
    case CSSPrimitiveValue::UnitType::kKilohertz:
      return kCalcFrequency;
    default:
      return kCalcOther;
  }
}

static bool HasDoubleValue(CSSPrimitiveValue::UnitType type) {
  switch (type) {
    case CSSPrimitiveValue::UnitType::kNumber:
    case CSSPrimitiveValue::UnitType::kPercentage:
    case CSSPrimitiveValue::UnitType::kEms:
    case CSSPrimitiveValue::UnitType::kExs:
    case CSSPrimitiveValue::UnitType::kChs:
    case CSSPrimitiveValue::UnitType::kRems:
    case CSSPrimitiveValue::UnitType::kPixels:
    case CSSPrimitiveValue::UnitType::kCentimeters:
    case CSSPrimitiveValue::UnitType::kMillimeters:
    case CSSPrimitiveValue::UnitType::kQuarterMillimeters:
    case CSSPrimitiveValue::UnitType::kInches:
    case CSSPrimitiveValue::UnitType::kPoints:
    case CSSPrimitiveValue::UnitType::kPicas:
    case CSSPrimitiveValue::UnitType::kUserUnits:
    case CSSPrimitiveValue::UnitType::kDegrees:
    case CSSPrimitiveValue::UnitType::kRadians:
    case CSSPrimitiveValue::UnitType::kGradians:
    case CSSPrimitiveValue::UnitType::kTurns:
    case CSSPrimitiveValue::UnitType::kMilliseconds:
    case CSSPrimitiveValue::UnitType::kSeconds:
    case CSSPrimitiveValue::UnitType::kHertz:
    case CSSPrimitiveValue::UnitType::kKilohertz:
    case CSSPrimitiveValue::UnitType::kViewportWidth:
    case CSSPrimitiveValue::UnitType::kViewportHeight:
    case CSSPrimitiveValue::UnitType::kViewportMin:
    case CSSPrimitiveValue::UnitType::kViewportMax:
    case CSSPrimitiveValue::UnitType::kDotsPerPixel:
    case CSSPrimitiveValue::UnitType::kDotsPerInch:
    case CSSPrimitiveValue::UnitType::kDotsPerCentimeter:
    case CSSPrimitiveValue::UnitType::kFraction:
    case CSSPrimitiveValue::UnitType::kInteger:
      return true;
    default:
      return false;
  }
}

namespace {

const PixelsAndPercent CreateClampedSamePixelsAndPercent(float value) {
  return PixelsAndPercent(CSSValueClampingUtils::ClampLength(value),
                          CSSValueClampingUtils::ClampLength(value));
}

bool IsNaN(PixelsAndPercent value, bool allows_negative_percentage_reference) {
  if (std::isnan(value.pixels + value.percent) ||
      (allows_negative_percentage_reference && std::isinf(value.percent))) {
    return true;
  }
  return false;
}

base::Optional<PixelsAndPercent> EvaluateValueIfNaNorInfinity(
    scoped_refptr<const blink::CalculationExpressionNode> value,
    bool allows_negative_percentage_reference) {
  float evaluated_value = value->Evaluate(1);
  if (std::isnan(evaluated_value) || std::isinf(evaluated_value)) {
    return CreateClampedSamePixelsAndPercent(evaluated_value);
  }
  if (allows_negative_percentage_reference) {
    evaluated_value = value->Evaluate(-1);
    if (std::isnan(evaluated_value) || std::isinf(evaluated_value)) {
      return CreateClampedSamePixelsAndPercent(evaluated_value);
    }
  }
  return base::nullopt;
}

}  // namespace

// ------ Start of CSSMathExpressionNumericLiteral member functions ------

// static
CSSMathExpressionNumericLiteral* CSSMathExpressionNumericLiteral::Create(
    const CSSNumericLiteralValue* value,
    bool is_integer) {
  return MakeGarbageCollected<CSSMathExpressionNumericLiteral>(value,
                                                               is_integer);
}

// static
CSSMathExpressionNumericLiteral* CSSMathExpressionNumericLiteral::Create(
    double value,
    CSSPrimitiveValue::UnitType type,
    bool is_integer) {
  if (!RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled() &&
      (std::isnan(value) || std::isinf(value)))
    return nullptr;
  return MakeGarbageCollected<CSSMathExpressionNumericLiteral>(
      CSSNumericLiteralValue::Create(value, type), is_integer);
}

CSSMathExpressionNumericLiteral::CSSMathExpressionNumericLiteral(
    const CSSNumericLiteralValue* value,
    bool is_integer)
    : CSSMathExpressionNode(UnitCategory(value->GetType()),
                            is_integer,
                            false /* has_comparisons*/),
      value_(value) {}

bool CSSMathExpressionNumericLiteral::IsZero() const {
  return !value_->GetDoubleValue();
}

String CSSMathExpressionNumericLiteral::CustomCSSText() const {
  return value_->CssText();
}

base::Optional<PixelsAndPercent>
CSSMathExpressionNumericLiteral::ToPixelsAndPercent(
    const CSSToLengthConversionData& conversion_data) const {
  PixelsAndPercent value(0, 0);
  switch (category_) {
    case kCalcLength:
      // When CSSCalcInfinityAndNaN is enabled, we allow infinity and NaN in
      // PixelsAndPercent. Therefore, we need to use a function that doesn't
      // internally clamp the result to the float range.
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        value.pixels = value_->ComputeLengthPx(conversion_data);
      else
        value.pixels = value_->ComputeLength<float>(conversion_data);
      break;
    case kCalcPercent:
      DCHECK(value_->IsPercentage());
      // When CSSCalcInfinityAndNaN is enabled, we allow infinity and NaN in
      // PixelsAndPercent. Therefore, we need to use a function that doesn't
      // internally clamp the result to the float range.
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        value.percent = value_->GetDoubleValue();
      else
        value.percent = value_->GetFloatValue();
      break;
    case kCalcNumber:
      // TODO(alancutter): Stop treating numbers like pixels unconditionally
      // in calcs to be able to accomodate border-image-width
      // https://drafts.csswg.org/css-backgrounds-3/#the-border-image-width
      value.pixels = value_->GetFloatValue() * conversion_data.Zoom();
      break;
    default:
      NOTREACHED();
  }
  return value;
}

scoped_refptr<const CalculationExpressionNode>
CSSMathExpressionNumericLiteral::ToCalculationExpression(
    const CSSToLengthConversionData& conversion_data) const {
  return base::MakeRefCounted<CalculationExpressionLeafNode>(
      *ToPixelsAndPercent(conversion_data));
}

double CSSMathExpressionNumericLiteral::DoubleValue() const {
  if (HasDoubleValue(ResolvedUnitType()))
    return value_->GetDoubleValue();
  NOTREACHED();
  return 0;
}

base::Optional<double>
CSSMathExpressionNumericLiteral::ComputeValueInCanonicalUnit() const {
  switch (category_) {
    case kCalcNumber:
    case kCalcPercent:
      return value_->DoubleValue();
    case kCalcLength:
      if (CSSPrimitiveValue::IsRelativeUnit(value_->GetType()))
        return base::nullopt;
      U_FALLTHROUGH;
    case kCalcAngle:
    case kCalcTime:
    case kCalcFrequency:
      return value_->DoubleValue() *
             CSSPrimitiveValue::ConversionToCanonicalUnitsScaleFactor(
                 value_->GetType());
    default:
      return base::nullopt;
  }
}

double CSSMathExpressionNumericLiteral::ComputeLengthPx(
    const CSSToLengthConversionData& conversion_data) const {
  switch (category_) {
    case kCalcLength:
      // When CSSCalcInfinityAndNaN is enabled, we allow infinity and NaN in
      // PixelsAndPercent. Therefore, we need to use a function that doesn't
      // internally clamp the result to the float range.
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        return value_->ComputeLengthPx(conversion_data);
      return value_->ComputeLength<double>(conversion_data);
    case kCalcNumber:
    case kCalcPercent:
    case kCalcAngle:
    case kCalcFrequency:
    case kCalcPercentLength:
    case kCalcTime:
    case kCalcOther:
      NOTREACHED();
      break;
  }
  NOTREACHED();
  return 0;
}

bool CSSMathExpressionNumericLiteral::AccumulateLengthArray(
    CSSLengthArray& length_array,
    double multiplier) const {
  DCHECK_NE(Category(), kCalcNumber);
  return value_->AccumulateLengthArray(length_array, multiplier);
}

void CSSMathExpressionNumericLiteral::AccumulateLengthUnitTypes(
    CSSPrimitiveValue::LengthTypeFlags& types) const {
  value_->AccumulateLengthUnitTypes(types);
}

bool CSSMathExpressionNumericLiteral::operator==(
    const CSSMathExpressionNode& other) const {
  if (!other.IsNumericLiteral())
    return false;

  return DataEquivalent(value_,
                        To<CSSMathExpressionNumericLiteral>(other).value_);
}

CSSPrimitiveValue::UnitType CSSMathExpressionNumericLiteral::ResolvedUnitType()
    const {
  return value_->GetType();
}

bool CSSMathExpressionNumericLiteral::IsComputationallyIndependent() const {
  return value_->IsComputationallyIndependent();
}

void CSSMathExpressionNumericLiteral::Trace(Visitor* visitor) const {
  visitor->Trace(value_);
  CSSMathExpressionNode::Trace(visitor);
}

#if DCHECK_IS_ON()
bool CSSMathExpressionNumericLiteral::InvolvesPercentageComparisons() const {
  return false;
}
#endif

// ------ End of CSSMathExpressionNumericLiteral member functions

static const CalculationCategory kAddSubtractResult[kCalcOther][kCalcOther] = {
    /* CalcNumber */ {kCalcNumber, kCalcOther, kCalcOther, kCalcOther,
                      kCalcOther, kCalcOther, kCalcOther},
    /* CalcLength */
    {kCalcOther, kCalcLength, kCalcPercentLength, kCalcPercentLength,
     kCalcOther, kCalcOther, kCalcOther},
    /* CalcPercent */
    {kCalcOther, kCalcPercentLength, kCalcPercent, kCalcPercentLength,
     kCalcOther, kCalcOther, kCalcOther},
    /* CalcPercentLength */
    {kCalcOther, kCalcPercentLength, kCalcPercentLength, kCalcPercentLength,
     kCalcOther, kCalcOther, kCalcOther},
    /* CalcAngle  */
    {kCalcOther, kCalcOther, kCalcOther, kCalcOther, kCalcAngle, kCalcOther,
     kCalcOther},
    /* CalcTime */
    {kCalcOther, kCalcOther, kCalcOther, kCalcOther, kCalcOther, kCalcTime,
     kCalcOther},
    /* CalcFrequency */
    {kCalcOther, kCalcOther, kCalcOther, kCalcOther, kCalcOther, kCalcOther,
     kCalcFrequency}};

static CalculationCategory DetermineCategory(
    const CSSMathExpressionNode& left_side,
    const CSSMathExpressionNode& right_side,
    CSSMathOperator op) {
  CalculationCategory left_category = left_side.Category();
  CalculationCategory right_category = right_side.Category();

  if (left_category == kCalcOther || right_category == kCalcOther)
    return kCalcOther;

  switch (op) {
    case CSSMathOperator::kAdd:
    case CSSMathOperator::kSubtract:
      return kAddSubtractResult[left_category][right_category];
    case CSSMathOperator::kMultiply:
      if (left_category != kCalcNumber && right_category != kCalcNumber)
        return kCalcOther;
      return left_category == kCalcNumber ? right_category : left_category;
    case CSSMathOperator::kDivide:
      if (right_category != kCalcNumber || right_side.IsZero())
        return kCalcOther;
      return left_category;
    default:
      break;
  }

  NOTREACHED();
  return kCalcOther;
}

static bool IsIntegerResult(const CSSMathExpressionNode* left_side,
                            const CSSMathExpressionNode* right_side,
                            CSSMathOperator op) {
  // Not testing for actual integer values.
  // Performs W3C spec's type checking for calc integers.
  // http://www.w3.org/TR/css3-values/#calc-type-checking
  return op != CSSMathOperator::kDivide && left_side->IsInteger() &&
         right_side->IsInteger();
}

// ------ Start of CSSMathExpressionBinaryOperation member functions ------

// static
CSSMathExpressionNode* CSSMathExpressionBinaryOperation::Create(
    const CSSMathExpressionNode* left_side,
    const CSSMathExpressionNode* right_side,
    CSSMathOperator op) {
  DCHECK_NE(left_side->Category(), kCalcOther);
  DCHECK_NE(right_side->Category(), kCalcOther);

  CalculationCategory new_category =
      DetermineCategory(*left_side, *right_side, op);
  if (new_category == kCalcOther)
    return nullptr;

  return MakeGarbageCollected<CSSMathExpressionBinaryOperation>(
      left_side, right_side, op, new_category);
}

// static
CSSMathExpressionNode* CSSMathExpressionBinaryOperation::CreateSimplified(
    const CSSMathExpressionNode* left_side,
    const CSSMathExpressionNode* right_side,
    CSSMathOperator op) {
  if (left_side->IsMathFunction() || right_side->IsMathFunction())
    return Create(left_side, right_side, op);

  CalculationCategory left_category = left_side->Category();
  CalculationCategory right_category = right_side->Category();
  DCHECK_NE(left_category, kCalcOther);
  DCHECK_NE(right_category, kCalcOther);

  bool is_integer = IsIntegerResult(left_side, right_side, op);

  // Simplify numbers.
  if (left_category == kCalcNumber && right_category == kCalcNumber) {
    return CSSMathExpressionNumericLiteral::Create(
        EvaluateOperator(left_side->DoubleValue(), right_side->DoubleValue(),
                         op),
        CSSPrimitiveValue::UnitType::kNumber, is_integer);
  }

  // Simplify addition and subtraction between same types.
  if (op == CSSMathOperator::kAdd || op == CSSMathOperator::kSubtract) {
    if (left_category == right_side->Category()) {
      CSSPrimitiveValue::UnitType left_type = left_side->ResolvedUnitType();
      if (HasDoubleValue(left_type)) {
        CSSPrimitiveValue::UnitType right_type = right_side->ResolvedUnitType();
        if (left_type == right_type) {
          return CSSMathExpressionNumericLiteral::Create(
              EvaluateOperator(left_side->DoubleValue(),
                               right_side->DoubleValue(), op),
              left_type, is_integer);
        }
        CSSPrimitiveValue::UnitCategory left_unit_category =
            CSSPrimitiveValue::UnitTypeToUnitCategory(left_type);
        if (left_unit_category != CSSPrimitiveValue::kUOther &&
            left_unit_category ==
                CSSPrimitiveValue::UnitTypeToUnitCategory(right_type)) {
          CSSPrimitiveValue::UnitType canonical_type =
              CSSPrimitiveValue::CanonicalUnitTypeForCategory(
                  left_unit_category);
          if (canonical_type != CSSPrimitiveValue::UnitType::kUnknown) {
            double left_value = clampTo<double>(
                left_side->DoubleValue() *
                CSSPrimitiveValue::ConversionToCanonicalUnitsScaleFactor(
                    left_type));
            double right_value = clampTo<double>(
                right_side->DoubleValue() *
                CSSPrimitiveValue::ConversionToCanonicalUnitsScaleFactor(
                    right_type));
            return CSSMathExpressionNumericLiteral::Create(
                EvaluateOperator(left_value, right_value, op), canonical_type,
                is_integer);
          }
        }
      }
    }
  } else {
    // Simplify multiplying or dividing by a number for simplifiable types.
    DCHECK(op == CSSMathOperator::kMultiply || op == CSSMathOperator::kDivide);
    const CSSMathExpressionNode* number_side =
        GetNumberSide(left_side, right_side);
    if (!number_side)
      return Create(left_side, right_side, op);
    if (number_side == left_side && op == CSSMathOperator::kDivide)
      return nullptr;
    const CSSMathExpressionNode* other_side =
        left_side == number_side ? right_side : left_side;

    double number = number_side->DoubleValue();

    if (!RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled()) {
      if (std::isnan(number) || std::isinf(number))
        return nullptr;
      if (op == CSSMathOperator::kDivide && !number)
        return nullptr;
    }

    CSSPrimitiveValue::UnitType other_type = other_side->ResolvedUnitType();
    if (HasDoubleValue(other_type)) {
      return CSSMathExpressionNumericLiteral::Create(
          EvaluateOperator(other_side->DoubleValue(), number, op), other_type,
          is_integer);
    }
  }

  return Create(left_side, right_side, op);
}

CSSMathExpressionBinaryOperation::CSSMathExpressionBinaryOperation(
    const CSSMathExpressionNode* left_side,
    const CSSMathExpressionNode* right_side,
    CSSMathOperator op,
    CalculationCategory category)
    : CSSMathExpressionNode(
          category,
          IsIntegerResult(left_side, right_side, op),
          left_side->HasComparisons() || right_side->HasComparisons()),
      left_side_(left_side),
      right_side_(right_side),
      operator_(op) {}

bool CSSMathExpressionBinaryOperation::IsZero() const {
  return !DoubleValue();
}

base::Optional<PixelsAndPercent>
CSSMathExpressionBinaryOperation::ToPixelsAndPercent(
    const CSSToLengthConversionData& conversion_data) const {
  base::Optional<PixelsAndPercent> result;
  switch (operator_) {
    case CSSMathOperator::kAdd:
    case CSSMathOperator::kSubtract: {
      result = left_side_->ToPixelsAndPercent(conversion_data);
      if (!result)
        return base::nullopt;

      base::Optional<PixelsAndPercent> other_side =
          right_side_->ToPixelsAndPercent(conversion_data);
      if (!other_side)
        return base::nullopt;
      if (operator_ == CSSMathOperator::kAdd) {
        result->pixels += other_side->pixels;
        result->percent += other_side->percent;
      } else {
        result->pixels -= other_side->pixels;
        result->percent -= other_side->percent;
      }
      break;
    }
    case CSSMathOperator::kMultiply:
    case CSSMathOperator::kDivide: {
      const CSSMathExpressionNode* number_side =
          GetNumberSide(left_side_, right_side_);
      const CSSMathExpressionNode* other_side =
          left_side_ == number_side ? right_side_ : left_side_;
      result = other_side->ToPixelsAndPercent(conversion_data);
      if (!result)
        return base::nullopt;
      float number = number_side->DoubleValue();
      if (operator_ == CSSMathOperator::kDivide)
        number = 1.0 / number;
      result->pixels *= number;
      result->percent *= number;
      break;
    }
    default:
      NOTREACHED();
  }
  return result;
}

scoped_refptr<const CalculationExpressionNode>
CSSMathExpressionBinaryOperation::ToCalculationExpression(
    const CSSToLengthConversionData& conversion_data) const {
  switch (operator_) {
    case CSSMathOperator::kAdd:
      return CalculationExpressionAdditiveNode::CreateSimplified(
          left_side_->ToCalculationExpression(conversion_data),
          right_side_->ToCalculationExpression(conversion_data),
          CalculationExpressionAdditiveNode::Type::kAdd);
    case CSSMathOperator::kSubtract:
      return CalculationExpressionAdditiveNode::CreateSimplified(
          left_side_->ToCalculationExpression(conversion_data),
          right_side_->ToCalculationExpression(conversion_data),
          CalculationExpressionAdditiveNode::Type::kSubtract);
    case CSSMathOperator::kMultiply:
      DCHECK_NE((left_side_->Category() == kCalcNumber),
                (right_side_->Category() == kCalcNumber));
      if (left_side_->Category() == kCalcNumber) {
        return CalculationExpressionMultiplicationNode::CreateSimplified(
            right_side_->ToCalculationExpression(conversion_data),
            left_side_->DoubleValue());
      }
      return CalculationExpressionMultiplicationNode::CreateSimplified(
          left_side_->ToCalculationExpression(conversion_data),
          right_side_->DoubleValue());
    case CSSMathOperator::kDivide:
      DCHECK_EQ(right_side_->Category(), kCalcNumber);
      return CalculationExpressionMultiplicationNode::CreateSimplified(
          left_side_->ToCalculationExpression(conversion_data),
          1.0 / right_side_->DoubleValue());
    default:
      NOTREACHED();
      return nullptr;
  }
}

double CSSMathExpressionBinaryOperation::DoubleValue() const {
  DCHECK(HasDoubleValue(ResolvedUnitType())) << CustomCSSText();
  return Evaluate(left_side_->DoubleValue(), right_side_->DoubleValue());
}

static bool HasCanonicalUnit(CalculationCategory category) {
  return category == kCalcNumber || category == kCalcLength ||
         category == kCalcPercent || category == kCalcAngle ||
         category == kCalcTime || category == kCalcFrequency;
}

base::Optional<double>
CSSMathExpressionBinaryOperation::ComputeValueInCanonicalUnit() const {
  if (!HasCanonicalUnit(category_))
    return base::nullopt;

  base::Optional<double> left_value = left_side_->ComputeValueInCanonicalUnit();
  if (!left_value)
    return base::nullopt;

  base::Optional<double> right_value =
      right_side_->ComputeValueInCanonicalUnit();
  if (!right_value)
    return base::nullopt;

  return Evaluate(*left_value, *right_value);
}

double CSSMathExpressionBinaryOperation::ComputeLengthPx(
    const CSSToLengthConversionData& conversion_data) const {
  DCHECK_EQ(kCalcLength, Category());
  double left_value;
  if (left_side_->Category() == kCalcLength) {
    left_value = left_side_->ComputeLengthPx(conversion_data);
  } else {
    DCHECK_EQ(kCalcNumber, left_side_->Category());
    left_value = left_side_->DoubleValue();
  }
  double right_value;
  if (right_side_->Category() == kCalcLength) {
    right_value = right_side_->ComputeLengthPx(conversion_data);
  } else {
    DCHECK_EQ(kCalcNumber, right_side_->Category());
    right_value = right_side_->DoubleValue();
  }
  return Evaluate(left_value, right_value);
}

bool CSSMathExpressionBinaryOperation::AccumulateLengthArray(
    CSSLengthArray& length_array,
    double multiplier) const {
  switch (operator_) {
    case CSSMathOperator::kAdd:
      if (!left_side_->AccumulateLengthArray(length_array, multiplier))
        return false;
      if (!right_side_->AccumulateLengthArray(length_array, multiplier))
        return false;
      return true;
    case CSSMathOperator::kSubtract:
      if (!left_side_->AccumulateLengthArray(length_array, multiplier))
        return false;
      if (!right_side_->AccumulateLengthArray(length_array, -multiplier))
        return false;
      return true;
    case CSSMathOperator::kMultiply:
      DCHECK_NE((left_side_->Category() == kCalcNumber),
                (right_side_->Category() == kCalcNumber));
      if (left_side_->Category() == kCalcNumber) {
        return right_side_->AccumulateLengthArray(
            length_array, multiplier * left_side_->DoubleValue());
      } else {
        return left_side_->AccumulateLengthArray(
            length_array, multiplier * right_side_->DoubleValue());
      }
    case CSSMathOperator::kDivide:
      DCHECK_EQ(right_side_->Category(), kCalcNumber);
      return left_side_->AccumulateLengthArray(
          length_array, multiplier / right_side_->DoubleValue());
    default:
      NOTREACHED();
      return false;
  }
}

void CSSMathExpressionBinaryOperation::AccumulateLengthUnitTypes(
    CSSPrimitiveValue::LengthTypeFlags& types) const {
  left_side_->AccumulateLengthUnitTypes(types);
  right_side_->AccumulateLengthUnitTypes(types);
}

bool CSSMathExpressionBinaryOperation::IsComputationallyIndependent() const {
  if (Category() != kCalcLength && Category() != kCalcPercentLength)
    return true;
  return left_side_->IsComputationallyIndependent() &&
         right_side_->IsComputationallyIndependent();
}

String CSSMathExpressionBinaryOperation::CustomCSSText() const {
  StringBuilder result;

  const bool left_side_needs_parentheses =
      left_side_->IsBinaryOperation() && operator_ != CSSMathOperator::kAdd;
  if (left_side_needs_parentheses)
    result.Append('(');
  result.Append(left_side_->CustomCSSText());
  if (left_side_needs_parentheses)
    result.Append(')');

  result.Append(' ');
  result.Append(ToString(operator_));
  result.Append(' ');

  const bool right_side_needs_parentheses =
      right_side_->IsBinaryOperation() && operator_ != CSSMathOperator::kAdd;
  if (right_side_needs_parentheses)
    result.Append('(');
  result.Append(right_side_->CustomCSSText());
  if (right_side_needs_parentheses)
    result.Append(')');

  return result.ToString();
}

bool CSSMathExpressionBinaryOperation::operator==(
    const CSSMathExpressionNode& exp) const {
  if (!exp.IsBinaryOperation())
    return false;

  const CSSMathExpressionBinaryOperation& other =
      To<CSSMathExpressionBinaryOperation>(exp);
  return DataEquivalent(left_side_, other.left_side_) &&
         DataEquivalent(right_side_, other.right_side_) &&
         operator_ == other.operator_;
}

CSSPrimitiveValue::UnitType CSSMathExpressionBinaryOperation::ResolvedUnitType()
    const {
  switch (category_) {
    case kCalcNumber:
      DCHECK_EQ(left_side_->Category(), kCalcNumber);
      DCHECK_EQ(right_side_->Category(), kCalcNumber);
      return CSSPrimitiveValue::UnitType::kNumber;
    case kCalcLength:
    case kCalcPercent: {
      if (left_side_->Category() == kCalcNumber)
        return right_side_->ResolvedUnitType();
      if (right_side_->Category() == kCalcNumber)
        return left_side_->ResolvedUnitType();
      CSSPrimitiveValue::UnitType left_type = left_side_->ResolvedUnitType();
      if (left_type == right_side_->ResolvedUnitType())
        return left_type;
      return CSSPrimitiveValue::UnitType::kUnknown;
    }
    case kCalcAngle:
      return CSSPrimitiveValue::UnitType::kDegrees;
    case kCalcTime:
      return CSSPrimitiveValue::UnitType::kMilliseconds;
    case kCalcFrequency:
      return CSSPrimitiveValue::UnitType::kHertz;
    case kCalcPercentLength:
    case kCalcOther:
      return CSSPrimitiveValue::UnitType::kUnknown;
  }
  NOTREACHED();
  return CSSPrimitiveValue::UnitType::kUnknown;
}

void CSSMathExpressionBinaryOperation::Trace(Visitor* visitor) const {
  visitor->Trace(left_side_);
  visitor->Trace(right_side_);
  CSSMathExpressionNode::Trace(visitor);
}

// static
const CSSMathExpressionNode* CSSMathExpressionBinaryOperation::GetNumberSide(
    const CSSMathExpressionNode* left_side,
    const CSSMathExpressionNode* right_side) {
  if (left_side->Category() == kCalcNumber)
    return left_side;
  if (right_side->Category() == kCalcNumber)
    return right_side;
  return nullptr;
}

// static
double CSSMathExpressionBinaryOperation::EvaluateOperator(double left_value,
                                                          double right_value,
                                                          CSSMathOperator op) {
  // Design doc for infinity and NaN: https://bit.ly/349gXjq
  switch (op) {
    case CSSMathOperator::kAdd:
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        return left_value + right_value;
      return clampTo<double>(left_value + right_value);
    case CSSMathOperator::kSubtract:
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        return left_value - right_value;
      return clampTo<double>(left_value - right_value);
    case CSSMathOperator::kMultiply:
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        return left_value * right_value;
      return clampTo<double>(left_value * right_value);
    case CSSMathOperator::kDivide:
      if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled())
        return left_value / right_value;
      if (right_value)
        return clampTo<double>(left_value / right_value);
      return std::numeric_limits<double>::quiet_NaN();
    default:
      NOTREACHED();
      break;
  }
  return 0;
}

#if DCHECK_IS_ON()
bool CSSMathExpressionBinaryOperation::InvolvesPercentageComparisons() const {
  return left_side_->InvolvesPercentageComparisons() ||
         right_side_->InvolvesPercentageComparisons();
}
#endif

// ------ End of CSSMathExpressionBinaryOperation member functions ------

// ------ Start of CSSMathExpressionVariadicOperation member functions ------

// static
CSSMathExpressionVariadicOperation* CSSMathExpressionVariadicOperation::Create(
    Operands&& operands,
    CSSMathOperator op) {
  DCHECK(op == CSSMathOperator::kMin || op == CSSMathOperator::kMax);
  DCHECK(operands.size());
  bool is_first = true;
  CalculationCategory category;
  bool is_integer;
  for (const auto& operand : operands) {
    if (is_first) {
      category = operand->Category();
      is_integer = operand->IsInteger();
    } else {
      category = kAddSubtractResult[category][operand->Category()];
      if (!operand->IsInteger())
        is_integer = false;
    }
    is_first = false;
    if (category == kCalcOther)
      return nullptr;
  }
  return MakeGarbageCollected<CSSMathExpressionVariadicOperation>(
      category, is_integer, std::move(operands), op);
}

CSSMathExpressionVariadicOperation::CSSMathExpressionVariadicOperation(
    CalculationCategory category,
    bool is_integer_result,
    Operands&& operands,
    CSSMathOperator op)
    : CSSMathExpressionNode(category,
                            is_integer_result,
                            true /* has_comparisons */),
      operands_(std::move(operands)),
      operator_(op) {}

void CSSMathExpressionVariadicOperation::Trace(Visitor* visitor) const {
  visitor->Trace(operands_);
  CSSMathExpressionNode::Trace(visitor);
}

bool CSSMathExpressionVariadicOperation::IsZero() const {
  base::Optional<double> maybe_value = ComputeValueInCanonicalUnit();
  return maybe_value && !*maybe_value;
}

double CSSMathExpressionVariadicOperation::EvaluateBinary(double lhs,
                                                          double rhs) const {
  if (std::isnan(lhs) || std::isnan(rhs))
    return std::numeric_limits<double>::quiet_NaN();

  switch (operator_) {
    case CSSMathOperator::kMin:
      return std::min(lhs, rhs);
    case CSSMathOperator::kMax:
      return std::max(lhs, rhs);
    default:
      NOTREACHED();
      return 0;
  }
}

base::Optional<double>
CSSMathExpressionVariadicOperation::ComputeValueInCanonicalUnit() const {
  base::Optional<double> first_value =
      operands_.front()->ComputeValueInCanonicalUnit();
  if (!first_value)
    return base::nullopt;

  double result = *first_value;
  for (const auto& operand : SecondToLastOperands()) {
    base::Optional<double> maybe_value = operand->ComputeValueInCanonicalUnit();
    if (!maybe_value)
      return base::nullopt;
    result = EvaluateBinary(result, *maybe_value);
  }
  return result;
}

double CSSMathExpressionVariadicOperation::DoubleValue() const {
  DCHECK(HasDoubleValue(ResolvedUnitType()));
  double result = operands_.front()->DoubleValue();
  for (const auto& operand : SecondToLastOperands())
    result = EvaluateBinary(result, operand->DoubleValue());
  return result;
}

double CSSMathExpressionVariadicOperation::ComputeLengthPx(
    const CSSToLengthConversionData& data) const {
  DCHECK_EQ(kCalcLength, Category());
  double result = operands_.front()->ComputeLengthPx(data);
  for (const auto& operand : SecondToLastOperands())
    result = EvaluateBinary(result, operand->ComputeLengthPx(data));
  return result;
}

String CSSMathExpressionVariadicOperation::CSSTextAsClamp() const {
  DCHECK(is_clamp_);
  DCHECK_EQ(CSSMathOperator::kMax, operator_);
  DCHECK_EQ(2u, operands_.size());
  DCHECK(operands_[1]->IsVariadicOperation());
  const auto& nested = To<CSSMathExpressionVariadicOperation>(*operands_[1]);
  DCHECK(!nested.is_clamp_);
  DCHECK_EQ(CSSMathOperator::kMin, nested.operator_);
  DCHECK_EQ(2u, nested.operands_.size());

  StringBuilder result;
  result.Append("clamp(");
  result.Append(operands_[0]->CustomCSSText());
  result.Append(", ");
  result.Append(nested.operands_[0]->CustomCSSText());
  result.Append(", ");
  result.Append(nested.operands_[1]->CustomCSSText());
  result.Append(")");
  return result.ToString();
}

String CSSMathExpressionVariadicOperation::CustomCSSText() const {
  if (is_clamp_)
    return CSSTextAsClamp();

  StringBuilder result;
  result.Append(ToString(operator_));
  result.Append('(');
  result.Append(operands_.front()->CustomCSSText());
  for (const auto& operand : SecondToLastOperands()) {
    result.Append(", ");
    result.Append(operand->CustomCSSText());
  }
  result.Append(')');

  return result.ToString();
}

base::Optional<PixelsAndPercent>
CSSMathExpressionVariadicOperation::ToPixelsAndPercent(
    const CSSToLengthConversionData& conversion_data) const {
  return base::nullopt;
}

scoped_refptr<const CalculationExpressionNode>
CSSMathExpressionVariadicOperation::ToCalculationExpression(
    const CSSToLengthConversionData& data) const {
  Vector<scoped_refptr<const CalculationExpressionNode>> operands;
  operands.ReserveCapacity(operands_.size());
  for (const auto& operand : operands_)
    operands.push_back(operand->ToCalculationExpression(data));
  auto expression_type = operator_ == CSSMathOperator::kMin
                             ? CalculationExpressionComparisonNode::Type::kMin
                             : CalculationExpressionComparisonNode::Type::kMax;
  return CalculationExpressionComparisonNode::CreateSimplified(
      std::move(operands), expression_type);
}

bool CSSMathExpressionVariadicOperation::AccumulateLengthArray(CSSLengthArray&,
                                                               double) const {
  // When comparison function are involved, we can't resolve the expression into
  // a length array.
  // TODO(crbug.com/991672): We need a more general length interpolation
  // implemetation that doesn't rely on CSSLengthArray.
  return false;
}

void CSSMathExpressionVariadicOperation::AccumulateLengthUnitTypes(
    CSSPrimitiveValue::LengthTypeFlags& types) const {
  for (const auto& operand : operands_)
    operand->AccumulateLengthUnitTypes(types);
}

bool CSSMathExpressionVariadicOperation::IsComputationallyIndependent() const {
  for (const auto& operand : operands_) {
    if (!operand->IsComputationallyIndependent())
      return false;
  }
  return true;
}

bool CSSMathExpressionVariadicOperation::operator==(
    const CSSMathExpressionNode& exp) const {
  if (!exp.IsVariadicOperation())
    return false;
  const CSSMathExpressionVariadicOperation& other =
      To<CSSMathExpressionVariadicOperation>(exp);
  if (operator_ != other.operator_)
    return false;
  if (operands_.size() != other.operands_.size())
    return false;
  for (wtf_size_t i = 0; i < operands_.size(); ++i) {
    if (!DataEquivalent(operands_[i], other.operands_[i]))
      return false;
  }
  return true;
}

CSSPrimitiveValue::UnitType
CSSMathExpressionVariadicOperation::ResolvedUnitType() const {
  if (Category() == kCalcNumber)
    return CSSPrimitiveValue::UnitType::kNumber;

  CSSPrimitiveValue::UnitType result = operands_.front()->ResolvedUnitType();
  if (result == CSSPrimitiveValue::UnitType::kUnknown)
    return CSSPrimitiveValue::UnitType::kUnknown;
  for (const auto& operand : SecondToLastOperands()) {
    CSSPrimitiveValue::UnitType next = operand->ResolvedUnitType();
    if (next == CSSPrimitiveValue::UnitType::kUnknown || next != result)
      return CSSPrimitiveValue::UnitType::kUnknown;
  }
  return result;
}

#if DCHECK_IS_ON()
bool CSSMathExpressionVariadicOperation::InvolvesPercentageComparisons() const {
  if (Category() == kCalcPercent && operands_.size() > 1u)
    return true;
  for (const auto& operand : operands_) {
    if (operand->InvolvesPercentageComparisons())
      return true;
  }
  return false;
}
#endif

// ------ End of CSSMathExpressionVariadicOperation member functions

static ParseState CheckDepthAndIndex(int* depth, CSSParserTokenRange tokens) {
  (*depth)++;
  if (tokens.AtEnd())
    return NoMoreTokens;
  if (*depth > maxExpressionDepth)
    return TooDeep;
  return OK;
}

class CSSMathExpressionNodeParser {
  STACK_ALLOCATED();

 public:
  CSSMathExpressionNodeParser() {}

  CSSMathExpressionNode* ParseCalc(CSSParserTokenRange tokens) {
    tokens.ConsumeWhitespace();
    CSSMathExpressionNode* result = ParseValueExpression(tokens, 0);
    if (!result || !tokens.AtEnd())
      return nullptr;
    return result;
  }

  CSSMathExpressionNode* ParseMinOrMax(CSSParserTokenRange tokens,
                                       CSSMathOperator op,
                                       int depth) {
    DCHECK(op == CSSMathOperator::kMin || op == CSSMathOperator::kMax);
    if (CheckDepthAndIndex(&depth, tokens) != OK)
      return nullptr;

    CSSMathExpressionVariadicOperation::Operands operands;
    bool last_token_is_comma = false;
    while (!tokens.AtEnd()) {
      tokens.ConsumeWhitespace();
      CSSMathExpressionNode* operand = ParseValueExpression(tokens, depth);
      if (!operand)
        return nullptr;

      last_token_is_comma = false;
      operands.push_back(operand);

      if (!css_parsing_utils::ConsumeCommaIncludingWhitespace(tokens))
        break;
      last_token_is_comma = true;
    }

    if (operands.IsEmpty() || !tokens.AtEnd() || last_token_is_comma)
      return nullptr;

    return CSSMathExpressionVariadicOperation::Create(std::move(operands), op);
  }

  CSSMathExpressionNode* ParseClamp(CSSParserTokenRange tokens, int depth) {
    if (CheckDepthAndIndex(&depth, tokens) != OK)
      return nullptr;

    CSSMathExpressionNode* min_operand = ParseValueExpression(tokens, depth);
    if (!min_operand)
      return nullptr;

    if (!css_parsing_utils::ConsumeCommaIncludingWhitespace(tokens))
      return nullptr;

    CSSMathExpressionNode* val_operand = ParseValueExpression(tokens, depth);
    if (!val_operand)
      return nullptr;

    if (!css_parsing_utils::ConsumeCommaIncludingWhitespace(tokens))
      return nullptr;

    CSSMathExpressionNode* max_operand = ParseValueExpression(tokens, depth);
    if (!max_operand)
      return nullptr;

    if (!tokens.AtEnd())
      return nullptr;

    // clamp(MIN, VAL, MAX) is identical to max(MIN, min(VAL, MAX))

    auto* nested = CSSMathExpressionVariadicOperation::Create(
        {val_operand, max_operand}, CSSMathOperator::kMin);
    if (!nested)
      return nullptr;

    auto* result = CSSMathExpressionVariadicOperation::Create(
        {min_operand, nested}, CSSMathOperator::kMax);
    if (!result)
      return nullptr;

    result->SetIsClamp();
    return result;
  }

 private:
  CSSMathExpressionNode* ParseValue(CSSParserTokenRange& tokens) {
    CSSParserToken token = tokens.ConsumeIncludingWhitespace();
    if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled()) {
      if (token.Id() == CSSValueID::kInfinity) {
        return CSSMathExpressionNumericLiteral::Create(
            std::numeric_limits<double>::infinity(),
            CSSPrimitiveValue::UnitType::kNumber, false);
      }
      if (token.Id() == CSSValueID::kNegativeInfinity) {
        return CSSMathExpressionNumericLiteral::Create(
            -std::numeric_limits<double>::infinity(),
            CSSPrimitiveValue::UnitType::kNumber, false);
      }
      if (token.Id() == CSSValueID::kNan) {
        return CSSMathExpressionNumericLiteral::Create(
            std::numeric_limits<double>::quiet_NaN(),
            CSSPrimitiveValue::UnitType::kNumber, false);
      }
    }
    if (!(token.GetType() == kNumberToken ||
          token.GetType() == kPercentageToken ||
          token.GetType() == kDimensionToken))
      return nullptr;

    CSSPrimitiveValue::UnitType type = token.GetUnitType();
    if (UnitCategory(type) == kCalcOther)
      return nullptr;

    return CSSMathExpressionNumericLiteral::Create(
        CSSNumericLiteralValue::Create(token.NumericValue(), type),
        token.GetNumericValueType() == kIntegerValueType);
  }

  CSSMathExpressionNode* ParseValueTerm(CSSParserTokenRange& tokens,
                                        int depth) {
    if (CheckDepthAndIndex(&depth, tokens) != OK)
      return nullptr;

    if (tokens.Peek().GetType() == kLeftParenthesisToken ||
        tokens.Peek().FunctionId() == CSSValueID::kCalc) {
      CSSParserTokenRange inner_range = tokens.ConsumeBlock();
      tokens.ConsumeWhitespace();
      inner_range.ConsumeWhitespace();
      CSSMathExpressionNode* result = ParseValueExpression(inner_range, depth);
      if (!result)
        return nullptr;
      result->SetIsNestedCalc();
      return result;
    }

    if (tokens.Peek().GetType() == kFunctionToken) {
      CSSValueID function_id = tokens.Peek().FunctionId();
      CSSParserTokenRange inner_range = tokens.ConsumeBlock();
      tokens.ConsumeWhitespace();
      inner_range.ConsumeWhitespace();
      switch (function_id) {
        case CSSValueID::kMin:
          return ParseMinOrMax(inner_range, CSSMathOperator::kMin, depth);
        case CSSValueID::kMax:
          return ParseMinOrMax(inner_range, CSSMathOperator::kMax, depth);
        case CSSValueID::kClamp:
          return ParseClamp(inner_range, depth);
        default:
          break;
      }
    }

    return ParseValue(tokens);
  }

  CSSMathExpressionNode* ParseValueMultiplicativeExpression(
      CSSParserTokenRange& tokens,
      int depth) {
    if (CheckDepthAndIndex(&depth, tokens) != OK)
      return nullptr;

    CSSMathExpressionNode* result = ParseValueTerm(tokens, depth);
    if (!result)
      return nullptr;

    while (!tokens.AtEnd()) {
      CSSMathOperator math_operator = ParseCSSArithmeticOperator(tokens.Peek());
      if (math_operator != CSSMathOperator::kMultiply &&
          math_operator != CSSMathOperator::kDivide)
        break;
      tokens.ConsumeIncludingWhitespace();

      CSSMathExpressionNode* rhs = ParseValueTerm(tokens, depth);
      if (!rhs)
        return nullptr;

      result = CSSMathExpressionBinaryOperation::CreateSimplified(
          result, rhs, math_operator);

      if (!result)
        return nullptr;
    }

    return result;
  }

  CSSMathExpressionNode* ParseAdditiveValueExpression(
      CSSParserTokenRange& tokens,
      int depth) {
    if (CheckDepthAndIndex(&depth, tokens) != OK)
      return nullptr;

    CSSMathExpressionNode* result =
        ParseValueMultiplicativeExpression(tokens, depth);
    if (!result)
      return nullptr;

    while (!tokens.AtEnd()) {
      CSSMathOperator math_operator = ParseCSSArithmeticOperator(tokens.Peek());
      if (math_operator != CSSMathOperator::kAdd &&
          math_operator != CSSMathOperator::kSubtract)
        break;
      if ((&tokens.Peek() - 1)->GetType() != kWhitespaceToken)
        return nullptr;  // calc(1px+ 2px) is invalid
      tokens.Consume();
      if (tokens.Peek().GetType() != kWhitespaceToken)
        return nullptr;  // calc(1px +2px) is invalid
      tokens.ConsumeIncludingWhitespace();

      CSSMathExpressionNode* rhs =
          ParseValueMultiplicativeExpression(tokens, depth);
      if (!rhs)
        return nullptr;

      result = CSSMathExpressionBinaryOperation::CreateSimplified(
          result, rhs, math_operator);

      if (!result)
        return nullptr;
    }

    return result;
  }

  CSSMathExpressionNode* ParseValueExpression(CSSParserTokenRange& tokens,
                                              int depth) {
    return ParseAdditiveValueExpression(tokens, depth);
  }
};

scoped_refptr<CalculationValue> CSSMathExpressionNode::ToCalcValue(
    const CSSToLengthConversionData& conversion_data,
    ValueRange range,
    bool allows_negative_percentage_reference) const {
  if (auto maybe_pixels_and_percent = ToPixelsAndPercent(conversion_data)) {
    // Clamping if pixels + percent could result in NaN. In special case,
    // inf px + inf % could evaluate to nan when
    // allows_negative_percentage_reference is true.
    if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled()) {
      if (IsNaN(*maybe_pixels_and_percent,
                allows_negative_percentage_reference)) {
        maybe_pixels_and_percent = CreateClampedSamePixelsAndPercent(
            std::numeric_limits<float>::quiet_NaN());
      } else {
        maybe_pixels_and_percent->pixels = CSSValueClampingUtils::ClampLength(
            maybe_pixels_and_percent->pixels);
        maybe_pixels_and_percent->percent = CSSValueClampingUtils::ClampLength(
            maybe_pixels_and_percent->percent);
      }
    }
    return CalculationValue::Create(*maybe_pixels_and_percent, range);
  }

  auto value = ToCalculationExpression(conversion_data);
  if (RuntimeEnabledFeatures::CSSCalcInfinityAndNaNEnabled()) {
    base::Optional<PixelsAndPercent> evaluated_value =
        EvaluateValueIfNaNorInfinity(value,
                                     allows_negative_percentage_reference);
    if (evaluated_value.has_value()) {
      return CalculationValue::Create(evaluated_value.value(), range);
    }
  }
  return CalculationValue::CreateSimplified(value, range);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::Create(
    const CalculationValue& calc) {
  if (calc.IsExpression())
    return Create(*calc.GetOrCreateExpression());
  return Create(calc.GetPixelsAndPercent());
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::Create(PixelsAndPercent value) {
  double percent = value.percent;
  double pixels = value.pixels;
  CSSMathOperator op = CSSMathOperator::kAdd;
  if (pixels < 0) {
    pixels = -pixels;
    op = CSSMathOperator::kSubtract;
  }
  return CSSMathExpressionBinaryOperation::Create(
      CSSMathExpressionNumericLiteral::Create(
          CSSNumericLiteralValue::Create(
              percent, CSSPrimitiveValue::UnitType::kPercentage),
          percent == trunc(percent)),
      CSSMathExpressionNumericLiteral::Create(
          CSSNumericLiteralValue::Create(pixels,
                                         CSSPrimitiveValue::UnitType::kPixels),
          pixels == trunc(pixels)),
      op);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::Create(
    const CalculationExpressionNode& node) {
  if (node.IsLeaf()) {
    const auto& leaf = To<CalculationExpressionLeafNode>(node);
    return Create(leaf.GetPixelsAndPercent());
  }

  if (node.IsMultiplication()) {
    const auto& multiplication =
        To<CalculationExpressionMultiplicationNode>(node);
    double factor = multiplication.GetFactor();
    return CSSMathExpressionBinaryOperation::Create(
        Create(multiplication.GetChild()),
        CSSMathExpressionNumericLiteral::Create(
            CSSNumericLiteralValue::Create(
                factor, CSSPrimitiveValue::UnitType::kNumber),
            factor == trunc(factor)),
        CSSMathOperator::kMultiply);
  }

  if (node.IsAdditive()) {
    const auto& add_or_subtract = To<CalculationExpressionAdditiveNode>(node);
    auto* lhs = Create(add_or_subtract.GetLeftSide());
    auto* rhs = Create(add_or_subtract.GetRightSide());
    CSSMathOperator op = add_or_subtract.IsAdd() ? CSSMathOperator::kAdd
                                                 : CSSMathOperator::kSubtract;
    return CSSMathExpressionBinaryOperation::Create(lhs, rhs, op);
  }

  DCHECK(node.IsComparison());
  const auto& comparison = To<CalculationExpressionComparisonNode>(node);
  CSSMathExpressionVariadicOperation::Operands operands;
  for (const auto& operand : comparison.GetOperands())
    operands.push_back(Create(*operand));
  CSSMathOperator op =
      comparison.IsMin() ? CSSMathOperator::kMin : CSSMathOperator::kMax;
  return CSSMathExpressionVariadicOperation::Create(std::move(operands), op);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::ParseCalc(
    const CSSParserTokenRange& tokens) {
  CSSMathExpressionNodeParser parser;
  return parser.ParseCalc(tokens);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::ParseMin(
    const CSSParserTokenRange& tokens) {
  CSSMathExpressionNodeParser parser;
  return parser.ParseMinOrMax(tokens, CSSMathOperator::kMin, 0);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::ParseMax(
    const CSSParserTokenRange& tokens) {
  CSSMathExpressionNodeParser parser;
  return parser.ParseMinOrMax(tokens, CSSMathOperator::kMax, 0);
}

// static
CSSMathExpressionNode* CSSMathExpressionNode::ParseClamp(
    const CSSParserTokenRange& tokens) {
  CSSMathExpressionNodeParser parser;
  return parser.ParseClamp(tokens, 0);
}

}  // namespace blink