Add smooth interpolation support for <length> custom properties

third_party/WebKit/Source/core/animation/LengthInterpolationFunctions.cpp

 // Copyright 2016 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 "core/animation/LengthInterpolationFunctions.h"
 
+#include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "platform/CalculationValue.h"
 
 namespace blink {
 
 // This class is implemented as a singleton whose instance represents the
 // presence of percentages being used in a Length value while nullptr represents
 // the absence of any percentages.
 class CSSLengthNonInterpolableValue : public NonInterpolableValue {
@@ skipping 135 matching lines @@
       value += 100;
     toInterpolableNumber(*list.getMutable(i)).set(value);
   }
   result.nonInterpolableValue = CSSLengthNonInterpolableValue::create(true);
 }
 
 static double clampToRange(double x, ValueRange range) {
   return (range == ValueRangeNonNegative && x < 0) ? 0 : x;
 }
 
+CSSPrimitiveValue::UnitType indexToUnitType(size_t index) {
+  return CSSPrimitiveValue::lengthUnitTypeToUnitType(
+      static_cast<CSSPrimitiveValue::LengthUnitType>(index));
+}
+
 Length LengthInterpolationFunctions::createLength(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue* nonInterpolableValue,
     const CSSToLengthConversionData& conversionData,
     ValueRange range) {
   const InterpolableList& interpolableList =
       toInterpolableList(interpolableValue);
   bool hasPercentage =
       CSSLengthNonInterpolableValue::hasPercentage(nonInterpolableValue);
   double pixels = 0;
   double percentage = 0;
   for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; i++) {
     double value = toInterpolableNumber(*interpolableList.get(i)).value();
     if (value == 0)
       continue;
     if (i == CSSPrimitiveValue::UnitTypePercentage) {
       percentage = value;
     } else {
-      CSSPrimitiveValue::UnitType type =
-          CSSPrimitiveValue::lengthUnitTypeToUnitType(
-              static_cast<CSSPrimitiveValue::LengthUnitType>(i));
-      pixels += conversionData.zoomedComputedPixels(value, type);
+      pixels += conversionData.zoomedComputedPixels(value, indexToUnitType(i));
     }
   }
 
   if (percentage != 0)
     hasPercentage = true;
   if (pixels != 0 && hasPercentage)
     return Length(
         CalculationValue::create(PixelsAndPercent(pixels, percentage), range));
   if (hasPercentage)
     return Length(clampToRange(percentage, range), Percent);
   return Length(
       CSSPrimitiveValue::clampToCSSLengthRange(clampToRange(pixels, range)),
       Fixed);
 }
 
+const CSSValue* LengthInterpolationFunctions::createCSSValue(
+    const InterpolableValue& interpolableValue,
+    const NonInterpolableValue* nonInterpolableValue,
+    ValueRange range) {
+  const InterpolableList& interpolableList =
+      toInterpolableList(interpolableValue);
+  bool hasPercentage =
+      CSSLengthNonInterpolableValue::hasPercentage(nonInterpolableValue);
+
+  CSSCalcExpressionNode* rootNode = nullptr;
+  CSSPrimitiveValue* firstValue = nullptr;
+
+  for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; i++) {
+    double value = toInterpolableNumber(*interpolableList.get(i)).value();
+    if (value == 0 ||
+        (i == CSSPrimitiveValue::UnitTypePercentage && !hasPercentage)) {
+      continue;
+    }
+    CSSPrimitiveValue* currentValue =
+        CSSPrimitiveValue::create(value, indexToUnitType(i));
+
+    if (!firstValue) {
+      DCHECK(!rootNode);
+      firstValue = currentValue;
+      continue;
+    }
+    CSSCalcExpressionNode* currentNode =
+        CSSCalcValue::createExpressionNode(currentValue);
+    if (!rootNode) {
+      rootNode = CSSCalcValue::createExpressionNode(firstValue);
+    }
+    rootNode =
+        CSSCalcValue::createExpressionNode(rootNode, currentNode, CalcAdd);
+  }
+
+  if (rootNode) {
+    return CSSPrimitiveValue::create(CSSCalcValue::create(rootNode));
+  }
+  if (firstValue) {
+    return firstValue;
+  }
+  return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels);
+}
+
 }  // namespace blink