Don't recurse in LengthStyleInterpolation helper constructCalcExpression

Source/core/animation/LengthStyleInterpolation.cpp

 // Copyright 2014 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/animation/LengthStyleInterpolation.h"
 
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/resolver/StyleBuilder.h"
@@ skipping 184 matching lines @@
     }
 }
 
 namespace {
 
 static CSSPrimitiveValue::UnitType toUnitType(int lengthUnitType)
 {
     return static_cast<CSSPrimitiveValue::UnitType>(CSSPrimitiveValue::lengthUnitTypeToUnitType(static_cast<CSSPrimitiveValue::LengthUnitType>(lengthUnitType)));
 }
 
-static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> constructCalcExpression(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> previous, const InterpolableList* list, size_t position)
+static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> constructCalcExpression(const InterpolableList* list)
 {
     const InterpolableList* listOfValues = toInterpolableList(list->get(0));
     const InterpolableList* listOfTypes = toInterpolableList(list->get(1));
-    while (position != CSSPrimitiveValue::LengthUnitTypeCount) {
+    RefPtrWillBeRawPtr<CSSCalcExpressionNode> expression;
+    for (size_t position = 0; position < CSSPrimitiveValue::LengthUnitTypeCount; position++) {
         const InterpolableNumber *subValueType = toInterpolableNumber(listOfTypes->get(position));
-        if (subValueType->value()) {
-            RefPtrWillBeRawPtr<CSSCalcExpressionNode> next;
-            double value = toInterpolableNumber(listOfValues->get(position))->value();
-            if (previous)
-                next = CSSCalcValue::createExpressionNode(previous, CSSCalcValue::createExpressionNode(CSSPrimitiveValue::create(value, toUnitType(position))), CalcAdd);
-            else
-                next = CSSCalcValue::createExpressionNode(CSSPrimitiveValue::create(value, toUnitType(position)));
-            return constructCalcExpression(next, list, position + 1);
-        }
-        position++;
+        if (!subValueType->value())
+            continue;
+        double value = toInterpolableNumber(listOfValues->get(position))->value();
+        RefPtrWillBeRawPtr<CSSCalcExpressionNode> currentTerm = CSSCalcValue::createExpressionNode(CSSPrimitiveValue::create(value, toUnitType(position)));
+        if (expression)
+            expression = CSSCalcValue::createExpressionNode(expression.release(), currentTerm.release(), CalcAdd);
+        else
+            expression = currentTerm.release();
     }
-    return previous;
+    return expression.release();
 }
 
 static double clampToRange(double x, ValueRange range)
 {
     return (range == ValueRangeNonNegative && x < 0) ? 0 : x;
 }
 
 static Length lengthFromInterpolableValue(const InterpolableValue& value, InterpolationRange interpolationRange, float zoom)
 {
     const InterpolableList& values = *toInterpolableList(toInterpolableList(value).get(0));
@@ skipping 43 matching lines @@
             if (subValueType->value()) {
                 double value = toInterpolableNumber(listOfValues->get(i))->value();
                 if (range == RangeNonNegative && value < 0)
                     value = 0;
                 return CSSPrimitiveValue::create(value, toUnitType(i));
             }
         }
         ASSERT_NOT_REACHED();
     default:
         ValueRange valueRange = (range == RangeNonNegative) ? ValueRangeNonNegative : ValueRangeAll;
-        return CSSPrimitiveValue::create(CSSCalcValue::create(constructCalcExpression(nullptr, listOfValuesAndTypes, 0), valueRange));
+        return CSSPrimitiveValue::create(CSSCalcValue::create(constructCalcExpression(listOfValuesAndTypes), valueRange));
     }
 }
 
 void LengthStyleInterpolation::apply(StyleResolverState& state) const
 {
     if (m_lengthSetter) {
         (state.style()->*m_lengthSetter)(lengthFromInterpolableValue(*m_cachedValue, m_range, state.style()->effectiveZoom()));
 #if ENABLE(ASSERT)
         RefPtrWillBeRawPtr<AnimatableValue> before = CSSAnimatableValueFactory::create(m_id, *state.style());
         StyleBuilder::applyProperty(m_id, state, fromInterpolableValue(*m_cachedValue, m_range).get());
         RefPtrWillBeRawPtr<AnimatableValue> after = CSSAnimatableValueFactory::create(m_id, *state.style());
         ASSERT(before->equals(*after));
 #endif
     } else {
         StyleBuilder::applyProperty(m_id, state, fromInterpolableValue(*m_cachedValue, m_range).get());
     }
 }
 
 DEFINE_TRACE(LengthStyleInterpolation)
 {
     StyleInterpolation::trace(visitor);
 }
 
 }