Use CSSPrimitiveValue::create in CSSLengthInterpolationType

third_party/WebKit/Source/core/animation/BasicShapeInterpolationFunctions.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/BasicShapeInterpolationFunctions.h"
 
 #include "core/animation/CSSLengthInterpolationType.h"
 #include "core/animation/CSSPositionAxisListInterpolationType.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 82 matching lines @@
 
 std::unique_ptr<InterpolableValue> createNeutralInterpolableCoordinate()
 {
     return CSSLengthInterpolationType::createNeutralInterpolableValue();
 }
 
 BasicShapeCenterCoordinate createCoordinate(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     return BasicShapeCenterCoordinate(
         BasicShapeCenterCoordinate::TopLeft,
-        CSSLengthInterpolationType::resolveInterpolableLength(interpolableValue, nullptr, conversionData));
+        CSSLengthInterpolationType::createLength(interpolableValue, nullptr, conversionData));
 }
 
 std::unique_ptr<InterpolableValue> convertCSSRadius(const CSSPrimitiveValue* radius)
 {
     if (!radius || radius->isValueID())
         return nullptr;
     return unwrap(CSSLengthInterpolationType::maybeConvertCSSValue(*radius));
 }
 
 std::unique_ptr<InterpolableValue> convertRadius(const BasicShapeRadius& radius, double zoom)
 {
     if (radius.type() != BasicShapeRadius::Value)
         return nullptr;
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(radius.value(), zoom));
 }
 
 std::unique_ptr<InterpolableValue> createNeutralInterpolableRadius()
 {
     return CSSLengthInterpolationType::createNeutralInterpolableValue();
 }
 
 BasicShapeRadius createRadius(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
-    return BasicShapeRadius(CSSLengthInterpolationType::resolveInterpolableLength(interpolableValue, nullptr, conversionData, ValueRangeNonNegative));
+    return BasicShapeRadius(CSSLengthInterpolationType::createLength(interpolableValue, nullptr, conversionData, ValueRangeNonNegative));
 }
 
 std::unique_ptr<InterpolableValue> convertCSSLength(const CSSValue* length)
 {
     if (!length)
         return CSSLengthInterpolationType::createNeutralInterpolableValue();
     return unwrap(CSSLengthInterpolationType::maybeConvertCSSValue(*length));
 }
 
 std::unique_ptr<InterpolableValue> convertLength(const Length& length, double zoom)
 {
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(length, zoom));
 }
 
 std::unique_ptr<InterpolableValue> convertCSSBorderRadiusWidth(const CSSValuePair* pair)
 {
     return convertCSSLength(pair ? &pair->first() : nullptr);
 }
 
 std::unique_ptr<InterpolableValue> convertCSSBorderRadiusHeight(const CSSValuePair* pair)
 {
     return convertCSSLength(pair ? &pair->second() : nullptr);
 }
 
 LengthSize createBorderRadius(const InterpolableValue& width, const InterpolableValue& height, const CSSToLengthConversionData& conversionData)
 {
     return LengthSize(
-        CSSLengthInterpolationType::resolveInterpolableLength(width, nullptr, conversionData, ValueRangeNonNegative),
-        CSSLengthInterpolationType::resolveInterpolableLength(height, nullptr, conversionData, ValueRangeNonNegative));
+        CSSLengthInterpolationType::createLength(width, nullptr, conversionData, ValueRangeNonNegative),
+        CSSLengthInterpolationType::createLength(height, nullptr, conversionData, ValueRangeNonNegative));
 }
 
 namespace CircleFunctions {
 
 enum CircleComponentIndex : unsigned {
     CircleCenterXIndex,
     CircleCenterYIndex,
     CircleRadiusIndex,
     CircleComponentIndexCount,
 };
@@ skipping 186 matching lines @@
     list->set(InsetBorderBottomRightHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderBottomLeftWidthIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderBottomLeftHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     return std::move(list);
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeInset> inset = BasicShapeInset::create();
     const InterpolableList& list = toInterpolableList(interpolableValue);
-    inset->setTop(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetTopIndex), nullptr, conversionData));
-    inset->setRight(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetRightIndex), nullptr, conversionData));
-    inset->setBottom(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetBottomIndex), nullptr, conversionData));
-    inset->setLeft(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetLeftIndex), nullptr, conversionData));
+    inset->setTop(CSSLengthInterpolationType::createLength(*list.get(InsetTopIndex), nullptr, conversionData));
+    inset->setRight(CSSLengthInterpolationType::createLength(*list.get(InsetRightIndex), nullptr, conversionData));
+    inset->setBottom(CSSLengthInterpolationType::createLength(*list.get(InsetBottomIndex), nullptr, conversionData));
+    inset->setLeft(CSSLengthInterpolationType::createLength(*list.get(InsetLeftIndex), nullptr, conversionData));
 
     inset->setTopLeftRadius(createBorderRadius(*list.get(InsetBorderTopLeftWidthIndex), *list.get(InsetBorderTopLeftHeightIndex), conversionData));
     inset->setTopRightRadius(createBorderRadius(*list.get(InsetBorderTopRightWidthIndex), *list.get(InsetBorderTopRightHeightIndex), conversionData));
     inset->setBottomRightRadius(createBorderRadius(*list.get(InsetBorderBottomRightWidthIndex), *list.get(InsetBorderBottomRightHeightIndex), conversionData));
     inset->setBottomLeftRadius(createBorderRadius(*list.get(InsetBorderBottomLeftWidthIndex), *list.get(InsetBorderBottomLeftHeightIndex), conversionData));
     return inset.release();
 }
 
 } // namespace InsetFunctions
 
@@ skipping 28 matching lines @@
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const BasicShapeNonInterpolableValue& nonInterpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
     polygon->setWindRule(nonInterpolableValue.windRule());
     const InterpolableList& list = toInterpolableList(interpolableValue);
     size_t size = nonInterpolableValue.size();
     DCHECK_EQ(list.length(), size);
     DCHECK_EQ(size % 2, 0U);
     for (size_t i = 0; i < size; i += 2) {
         polygon->appendPoint(
-            CSSLengthInterpolationType::resolveInterpolableLength(*list.get(i), nullptr, conversionData),
-            CSSLengthInterpolationType::resolveInterpolableLength(*list.get(i + 1), nullptr, conversionData));
+            CSSLengthInterpolationType::createLength(*list.get(i), nullptr, conversionData),
+            CSSLengthInterpolationType::createLength(*list.get(i + 1), nullptr, conversionData));
     }
     return polygon.release();
 }
 
 } // namespace PolygonFunctions
 
 } // namespace
 
 InterpolationValue BasicShapeInterpolationFunctions::maybeConvertCSSValue(const CSSValue& value)
 {
@@ skipping 62 matching lines @@
         return InsetFunctions::createBasicShape(interpolableValue, conversionData);
     case BasicShape::BasicShapePolygonType:
         return PolygonFunctions::createBasicShape(interpolableValue, nonInterpolableValue, conversionData);
     default:
         NOTREACHED();
         return nullptr;
     }
 }
 
 } // namespace blink