Remove InterpolateLists::Create() in core/animation

As advised in [1], this CL removes unnecessary InterpolateLists::Create()
in //third_party/blink/renderer/core/animation and make their constructors
public, then make the callers use std::make_unique<InterpolateLists>
instead of it's Create() factory function.

[1] https://groups.google.com/a/chromium.org/forum/#!msg/blink-dev/iJ1bawbxbWs/vEdfT5QtBgAJ

Bug: 939691
Change-Id: Ic3544f8ded2a05f5f5e00a4570317f3e5bad4f48
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1531889Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#642428}

third_party/blink/renderer/core/animation/basic_shape_interpolation_functions.cc

@@ -175,8 +175,7 @@ enum CircleComponentIndex : unsigned {
 
 InterpolationValue ConvertCSSValue(
     const cssvalue::CSSBasicShapeCircleValue& circle) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kCircleComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kCircleComponentIndexCount);
   list->Set(kCircleCenterXIndex, ConvertCSSCoordinate(circle.CenterX()));
   list->Set(kCircleCenterYIndex, ConvertCSSCoordinate(circle.CenterY()));
 
@@ -192,8 +191,7 @@ InterpolationValue ConvertCSSValue(
 
 InterpolationValue ConvertBasicShape(const BasicShapeCircle& circle,
                                      double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kCircleComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kCircleComponentIndexCount);
   list->Set(kCircleCenterXIndex, ConvertCoordinate(circle.CenterX(), zoom));
   list->Set(kCircleCenterYIndex, ConvertCoordinate(circle.CenterY(), zoom));
 
@@ -208,8 +206,7 @@ InterpolationValue ConvertBasicShape(const BasicShapeCircle& circle,
 }
 
 std::unique_ptr<InterpolableValue> CreateNeutralValue() {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kCircleComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kCircleComponentIndexCount);
   list->Set(kCircleCenterXIndex, CreateNeutralInterpolableCoordinate());
   list->Set(kCircleCenterYIndex, CreateNeutralInterpolableCoordinate());
   list->Set(kCircleRadiusIndex, CreateNeutralInterpolableRadius());
@@ -244,8 +241,7 @@ enum EllipseComponentIndex : unsigned {
 
 InterpolationValue ConvertCSSValue(
     const cssvalue::CSSBasicShapeEllipseValue& ellipse) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kEllipseComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kEllipseComponentIndexCount);
   list->Set(kEllipseCenterXIndex, ConvertCSSCoordinate(ellipse.CenterX()));
   list->Set(kEllipseCenterYIndex, ConvertCSSCoordinate(ellipse.CenterY()));
 
@@ -264,8 +260,7 @@ InterpolationValue ConvertCSSValue(
 
 InterpolationValue ConvertBasicShape(const BasicShapeEllipse& ellipse,
                                      double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kEllipseComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kEllipseComponentIndexCount);
   list->Set(kEllipseCenterXIndex, ConvertCoordinate(ellipse.CenterX(), zoom));
   list->Set(kEllipseCenterYIndex, ConvertCoordinate(ellipse.CenterY(), zoom));
 
@@ -283,8 +278,7 @@ InterpolationValue ConvertBasicShape(const BasicShapeEllipse& ellipse,
 }
 
 std::unique_ptr<InterpolableValue> CreateNeutralValue() {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kEllipseComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kEllipseComponentIndexCount);
   list->Set(kEllipseCenterXIndex, CreateNeutralInterpolableCoordinate());
   list->Set(kEllipseCenterYIndex, CreateNeutralInterpolableCoordinate());
   list->Set(kEllipseRadiusXIndex, CreateNeutralInterpolableRadius());
@@ -330,8 +324,7 @@ enum InsetComponentIndex : unsigned {
 
 InterpolationValue ConvertCSSValue(
     const cssvalue::CSSBasicShapeInsetValue& inset) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kInsetComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kInsetComponentIndexCount);
   list->Set(kInsetTopIndex, ConvertCSSLength(inset.Top()));
   list->Set(kInsetRightIndex, ConvertCSSLength(inset.Right()));
   list->Set(kInsetBottomIndex, ConvertCSSLength(inset.Bottom()));
@@ -360,8 +353,7 @@ InterpolationValue ConvertCSSValue(
 
 InterpolationValue ConvertBasicShape(const BasicShapeInset& inset,
                                      double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kInsetComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kInsetComponentIndexCount);
   list->Set(kInsetTopIndex, ConvertLength(inset.Top(), zoom));
   list->Set(kInsetRightIndex, ConvertLength(inset.Right(), zoom));
   list->Set(kInsetBottomIndex, ConvertLength(inset.Bottom(), zoom));
@@ -389,8 +381,7 @@ InterpolationValue ConvertBasicShape(const BasicShapeInset& inset,
 }
 
 std::unique_ptr<InterpolableValue> CreateNeutralValue() {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kInsetComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kInsetComponentIndexCount);
   list->Set(kInsetTopIndex,
             LengthInterpolationFunctions::CreateNeutralInterpolableValue());
   list->Set(kInsetRightIndex,
@@ -455,7 +446,7 @@ namespace polygon_functions {
 InterpolationValue ConvertCSSValue(
     const cssvalue::CSSBasicShapePolygonValue& polygon) {
   wtf_size_t size = polygon.Values().size();
-  std::unique_ptr<InterpolableList> list = InterpolableList::Create(size);
+  auto list = std::make_unique<InterpolableList>(size);
   for (wtf_size_t i = 0; i < size; i++)
     list->Set(i, ConvertCSSLength(polygon.Values()[i].Get()));
   return InterpolationValue(std::move(list),
@@ -466,7 +457,7 @@ InterpolationValue ConvertCSSValue(
 InterpolationValue ConvertBasicShape(const BasicShapePolygon& polygon,
                                      double zoom) {
   wtf_size_t size = polygon.Values().size();
-  std::unique_ptr<InterpolableList> list = InterpolableList::Create(size);
+  auto list = std::make_unique<InterpolableList>(size);
   for (wtf_size_t i = 0; i < size; i++)
     list->Set(i, ConvertLength(polygon.Values()[i], zoom));
   return InterpolationValue(std::move(list),
@@ -476,8 +467,7 @@ InterpolationValue ConvertBasicShape(const BasicShapePolygon& polygon,
 
 std::unique_ptr<InterpolableValue> CreateNeutralValue(
     const BasicShapeNonInterpolableValue& non_interpolable_value) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(non_interpolable_value.size());
+  auto list = std::make_unique<InterpolableList>(non_interpolable_value.size());
   for (wtf_size_t i = 0; i < non_interpolable_value.size(); i++)
     list->Set(i,
               LengthInterpolationFunctions::CreateNeutralInterpolableValue());

third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc

@@ -210,8 +210,7 @@ class InheritedSideTypesChecker
 
 InterpolationValue ConvertBorderImageLengthBox(const BorderImageLengthBox& box,
                                                double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kSideIndexCount);
+  auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(
       kSideIndexCount);
   const BorderImageLength* sides[kSideIndexCount] = {};
@@ -225,7 +224,7 @@ InterpolationValue ConvertBorderImageLengthBox(const BorderImageLengthBox& box,
     if (side.IsNumber()) {
       list->Set(i, std::make_unique<InterpolableNumber>(side.Number()));
     } else if (side.length().IsAuto()) {
-      list->Set(i, InterpolableList::Create(0));
+      list->Set(i, std::make_unique<InterpolableList>(0));
     } else {
       InterpolationValue converted_side =
           LengthInterpolationFunctions::MaybeConvertLength(side.length(), zoom);
@@ -286,8 +285,7 @@ InterpolationValue CSSBorderImageLengthBoxInterpolationType::MaybeConvertValue(
   if (!quad)
     return nullptr;
 
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kSideIndexCount);
+  auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(
       kSideIndexCount);
   const CSSValue* sides[kSideIndexCount] = {};
@@ -308,7 +306,7 @@ InterpolationValue CSSBorderImageLengthBoxInterpolationType::MaybeConvertValue(
     auto* side_identifier_value = DynamicTo<CSSIdentifierValue>(side);
     if (side_identifier_value &&
         side_identifier_value->GetValueID() == CSSValueAuto) {
-      list->Set(i, InterpolableList::Create(0));
+      list->Set(i, std::make_unique<InterpolableList>(0));
       continue;
     }
 

third_party/blink/renderer/core/animation/css_clip_interpolation_type.cc

@@ -148,14 +148,13 @@ static std::unique_ptr<InterpolableValue> ConvertClipComponent(
     const Length& length,
     double zoom) {
   if (length.IsAuto())
-    return InterpolableList::Create(0);
+    return std::make_unique<InterpolableList>(0);
   return LengthInterpolationFunctions::MaybeConvertLength(length, zoom)
       .interpolable_value;
 }
 
 static InterpolationValue CreateClipValue(const LengthBox& clip, double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kClipComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kClipComponentIndexCount);
   list->Set(kClipTop, ConvertClipComponent(clip.Top(), zoom));
   list->Set(kClipRight, ConvertClipComponent(clip.Right(), zoom));
   list->Set(kClipBottom, ConvertClipComponent(clip.Bottom(), zoom));
@@ -206,7 +205,7 @@ static bool IsCSSAuto(const CSSValue& value) {
 static std::unique_ptr<InterpolableValue> ConvertClipComponent(
     const CSSValue& length) {
   if (IsCSSAuto(length))
-    return InterpolableList::Create(0);
+    return std::make_unique<InterpolableList>(0);
   return LengthInterpolationFunctions::MaybeConvertCSSValue(length)
       .interpolable_value;
 }
@@ -218,8 +217,7 @@ InterpolationValue CSSClipInterpolationType::MaybeConvertValue(
   const auto* quad = DynamicTo<CSSQuadValue>(value);
   if (!quad)
     return nullptr;
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kClipComponentIndexCount);
+  auto list = std::make_unique<InterpolableList>(kClipComponentIndexCount);
   list->Set(kClipTop, ConvertClipComponent(*quad->Top()));
   list->Set(kClipRight, ConvertClipComponent(*quad->Right()));
   list->Set(kClipBottom, ConvertClipComponent(*quad->Bottom()));

third_party/blink/renderer/core/animation/css_color_interpolation_type.cc

@@ -33,8 +33,7 @@ enum InterpolableColorIndex : unsigned {
 static std::unique_ptr<InterpolableValue> CreateInterpolableColorForIndex(
     InterpolableColorIndex index) {
   DCHECK_LT(index, kInterpolableColorIndexCount);
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kInterpolableColorIndexCount);
+  auto list = std::make_unique<InterpolableList>(kInterpolableColorIndexCount);
   for (unsigned i = 0; i < kInterpolableColorIndexCount; i++)
     list->Set(i, std::make_unique<InterpolableNumber>(i == index));
   return std::move(list);
@@ -42,8 +41,7 @@ static std::unique_ptr<InterpolableValue> CreateInterpolableColorForIndex(
 
 std::unique_ptr<InterpolableValue>
 CSSColorInterpolationType::CreateInterpolableColor(const Color& color) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kInterpolableColorIndexCount);
+  auto list = std::make_unique<InterpolableList>(kInterpolableColorIndexCount);
   list->Set(kRed,
             std::make_unique<InterpolableNumber>(color.Red() * color.Alpha()));
   list->Set(kGreen, std::make_unique<InterpolableNumber>(color.Green() *
@@ -240,8 +238,8 @@ InterpolationValue CSSColorInterpolationType::MaybeConvertValue(
       MaybeCreateInterpolableColor(value);
   if (!interpolable_color)
     return nullptr;
-  std::unique_ptr<InterpolableList> color_pair =
-      InterpolableList::Create(kInterpolableColorPairIndexCount);
+  auto color_pair =
+      std::make_unique<InterpolableList>(kInterpolableColorPairIndexCount);
   color_pair->Set(kUnvisited, interpolable_color->Clone());
   color_pair->Set(kVisited, std::move(interpolable_color));
   return InterpolationValue(std::move(color_pair));
@@ -253,8 +251,8 @@ InterpolationValue CSSColorInterpolationType::ConvertStyleColorPair(
   if (unvisited_color.IsNull() || visited_color.IsNull()) {
     return nullptr;
   }
-  std::unique_ptr<InterpolableList> color_pair =
-      InterpolableList::Create(kInterpolableColorPairIndexCount);
+  auto color_pair =
+      std::make_unique<InterpolableList>(kInterpolableColorPairIndexCount);
   color_pair->Set(kUnvisited,
                   CreateInterpolableColor(unvisited_color.Access()));
   color_pair->Set(kVisited, CreateInterpolableColor(visited_color.Access()));

third_party/blink/renderer/core/animation/css_default_interpolation_type.cc

@@ -28,7 +28,7 @@ InterpolationValue CSSDefaultInterpolationType::MaybeConvertSingle(
     return nullptr;
   }
   return InterpolationValue(
-      InterpolableList::Create(0),
+      std::make_unique<InterpolableList>(0),
       CSSDefaultNonInterpolableValue::Create(
           ToCSSPropertySpecificKeyframe(keyframe).Value()));
 }

third_party/blink/renderer/core/animation/css_filter_list_interpolation_type.cc

@@ -100,8 +100,7 @@ class InheritedFilterListChecker
 InterpolationValue ConvertFilterList(const FilterOperations& filter_operations,
                                      double zoom) {
   wtf_size_t length = filter_operations.size();
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(length);
+  auto interpolable_list = std::make_unique<InterpolableList>(length);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(length);
   for (wtf_size_t i = 0; i < length; i++) {
     InterpolationValue filter_result =
@@ -156,7 +155,7 @@ InterpolationValue CSSFilterListInterpolationType::MaybeConvertValue(
     ConversionCheckers&) const {
   auto* identifier_value = DynamicTo<CSSIdentifierValue>(value);
   if (identifier_value && identifier_value->GetValueID() == CSSValueNone)
-    return InterpolationValue(InterpolableList::Create(0),
+    return InterpolationValue(std::make_unique<InterpolableList>(0),
                               NonInterpolableList::Create());
 
   if (!value.IsBaseValueList())
@@ -164,8 +163,7 @@ InterpolationValue CSSFilterListInterpolationType::MaybeConvertValue(
 
   const auto& list = To<CSSValueList>(value);
   wtf_size_t length = list.length();
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(length);
+  auto interpolable_list = std::make_unique<InterpolableList>(length);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(length);
   for (wtf_size_t i = 0; i < length; i++) {
     InterpolationValue item_result =
@@ -222,8 +220,8 @@ PairwiseInterpolationValue CSSFilterListInterpolationType::MaybeMergeSingles(
       ToInterpolableList(*shorter.interpolable_value);
   const NonInterpolableList& longer_non_interpolable_list =
       ToNonInterpolableList(*longer.non_interpolable_value);
-  std::unique_ptr<InterpolableList> extended_interpolable_list =
-      InterpolableList::Create(longer_length);
+  auto extended_interpolable_list =
+      std::make_unique<InterpolableList>(longer_length);
   for (wtf_size_t i = 0; i < longer_length; i++) {
     if (i < shorter_length)
       extended_interpolable_list->Set(
@@ -276,8 +274,7 @@ void CSSFilterListInterpolationType::Composite(
   if (length <= underlying_length)
     return;
 
-  std::unique_ptr<InterpolableList> extended_interpolable_list =
-      InterpolableList::Create(length);
+  auto extended_interpolable_list = std::make_unique<InterpolableList>(length);
   for (wtf_size_t i = 0; i < length; i++) {
     if (i < underlying_length)
       extended_interpolable_list->Set(

third_party/blink/renderer/core/animation/css_font_variation_settings_interpolation_type.cc

@@ -96,7 +96,7 @@ static InterpolationValue ConvertFontVariationSettings(
     return nullptr;
   }
   wtf_size_t length = settings->size();
-  std::unique_ptr<InterpolableList> numbers = InterpolableList::Create(length);
+  auto numbers = std::make_unique<InterpolableList>(length);
   Vector<AtomicString> tags;
   for (wtf_size_t i = 0; i < length; ++i) {
     numbers->Set(i,
@@ -145,7 +145,7 @@ InterpolationValue CSSFontVariationSettingsInterpolationType::MaybeConvertValue(
     return nullptr;
   }
   wtf_size_t length = list->length();
-  std::unique_ptr<InterpolableList> numbers = InterpolableList::Create(length);
+  auto numbers = std::make_unique<InterpolableList>(length);
   Vector<AtomicString> tags;
   for (wtf_size_t i = 0; i < length; ++i) {
     const auto& item = To<cssvalue::CSSFontVariationValue>(list->Item(i));

third_party/blink/renderer/core/animation/css_image_list_interpolation_type.cc

@@ -118,8 +118,7 @@ InterpolationValue CSSImageListInterpolationType::MaybeConvertValue(
   const auto& value_list = temp_list ? *temp_list : To<CSSValueList>(value);
 
   const wtf_size_t length = value_list.length();
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(length);
+  auto interpolable_list = std::make_unique<InterpolableList>(length);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(length);
   for (wtf_size_t i = 0; i < length; i++) {
     InterpolationValue component =

third_party/blink/renderer/core/animation/css_image_slice_interpolation_type.cc

@@ -130,8 +130,7 @@ class InheritedSliceTypesChecker
 };
 
 InterpolationValue ConvertImageSlice(const ImageSlice& slice, double zoom) {
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kSideIndexCount);
+  auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   const Length* sides[kSideIndexCount] = {};
   sides[kSideTop] = &slice.slices.Top();
   sides[kSideRight] = &slice.slices.Right();
@@ -198,8 +197,7 @@ InterpolationValue CSSImageSliceInterpolationType::MaybeConvertValue(
 
   const cssvalue::CSSBorderImageSliceValue& slice =
       To<cssvalue::CSSBorderImageSliceValue>(value);
-  std::unique_ptr<InterpolableList> list =
-      InterpolableList::Create(kSideIndexCount);
+  auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   const CSSValue* sides[kSideIndexCount];
   sides[kSideTop] = slice.Slices().Top();
   sides[kSideRight] = slice.Slices().Right();

third_party/blink/renderer/core/animation/css_scale_interpolation_type.cc

@@ -59,7 +59,7 @@ struct Scale {
 };
 
 std::unique_ptr<InterpolableValue> CreateScaleIdentity() {
-  std::unique_ptr<InterpolableList> list = InterpolableList::Create(3);
+  auto list = std::make_unique<InterpolableList>(3);
   for (wtf_size_t i = 0; i < 3; i++)
     list->Set(i, std::make_unique<InterpolableNumber>(1));
   return std::move(list);
@@ -132,11 +132,11 @@ DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSScaleNonInterpolableValue);
 
 InterpolationValue Scale::CreateInterpolationValue() const {
   if (is_none) {
-    return InterpolationValue(InterpolableList::Create(0),
+    return InterpolationValue(std::make_unique<InterpolableList>(0),
                               CSSScaleNonInterpolableValue::Create(*this));
   }
 
-  std::unique_ptr<InterpolableList> list = InterpolableList::Create(3);
+  auto list = std::make_unique<InterpolableList>(3);
   for (wtf_size_t i = 0; i < 3; i++)
     list->Set(i, std::make_unique<InterpolableNumber>(array[i]));
   return InterpolationValue(std::move(list),

third_party/blink/renderer/core/animation/css_translate_interpolation_type.cc

@@ -19,7 +19,7 @@ namespace blink {
 namespace {
 
 InterpolationValue CreateNoneValue() {
-  return InterpolationValue(InterpolableList::Create(0));
+  return InterpolationValue(std::make_unique<InterpolableList>(0));
 }
 
 bool IsNoneValue(const InterpolationValue& value) {
@@ -58,8 +58,8 @@ enum TranslateComponentIndex : unsigned {
 };
 
 std::unique_ptr<InterpolableValue> CreateTranslateIdentity() {
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kTranslateComponentIndexCount);
+  auto result =
+      std::make_unique<InterpolableList>(kTranslateComponentIndexCount);
   result->Set(kTranslateX,
               LengthInterpolationFunctions::CreateNeutralInterpolableValue());
   result->Set(kTranslateY,
@@ -75,8 +75,8 @@ InterpolationValue ConvertTranslateOperation(
   if (!translate)
     return CreateNoneValue();
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kTranslateComponentIndexCount);
+  auto result =
+      std::make_unique<InterpolableList>(kTranslateComponentIndexCount);
   result->Set(kTranslateX, LengthInterpolationFunctions::MaybeConvertLength(
                                translate->X(), zoom)
                                .interpolable_value);
@@ -126,8 +126,8 @@ InterpolationValue CSSTranslateInterpolationType::MaybeConvertValue(
   if (list.length() < 1 || list.length() > 3)
     return nullptr;
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kTranslateComponentIndexCount);
+  auto result =
+      std::make_unique<InterpolableList>(kTranslateComponentIndexCount);
   for (wtf_size_t i = 0; i < kTranslateComponentIndexCount; i++) {
     InterpolationValue component = nullptr;
     if (i < list.length()) {

third_party/blink/renderer/core/animation/css_var_cycle_interpolation_type.cc

@@ -48,7 +48,7 @@ CSSVarCycleInterpolationType::CSSVarCycleInterpolationType(
 }
 
 static InterpolationValue CreateCycleDetectedValue() {
-  return InterpolationValue(InterpolableList::Create(0));
+  return InterpolationValue(std::make_unique<InterpolableList>(0));
 }
 
 InterpolationValue CSSVarCycleInterpolationType::MaybeConvertSingle(

third_party/blink/renderer/core/animation/interpolable_value.cc

@@ -56,7 +56,7 @@ void InterpolableList::Interpolate(const InterpolableValue& to,
 }
 
 std::unique_ptr<InterpolableValue> InterpolableList::CloneAndZero() const {
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(length());
+  auto result = std::make_unique<InterpolableList>(length());
   for (wtf_size_t i = 0; i < length(); i++)
     result->Set(i, values_[i]->CloneAndZero());
   return std::move(result);

third_party/blink/renderer/core/animation/interpolable_value.h

@@ -85,13 +85,11 @@ class CORE_EXPORT InterpolableList : public InterpolableValue {
   // has its own copy constructor. So just delete operator= here.
   InterpolableList& operator=(const InterpolableList&) = delete;
 
-  static std::unique_ptr<InterpolableList> Create(
-      const InterpolableList& other) {
-    return base::WrapUnique(new InterpolableList(other));
-  }
+  explicit InterpolableList(wtf_size_t size) : values_(size) {}
 
-  static std::unique_ptr<InterpolableList> Create(wtf_size_t size) {
-    return base::WrapUnique(new InterpolableList(size));
+  InterpolableList(const InterpolableList& other) : values_(other.length()) {
+    for (wtf_size_t i = 0; i < length(); i++)
+      Set(i, other.values_[i]->Clone());
   }
 
   bool IsList() const final { return true; }
@@ -107,7 +105,7 @@ class CORE_EXPORT InterpolableList : public InterpolableValue {
   wtf_size_t length() const { return values_.size(); }
   bool Equals(const InterpolableValue& other) const final;
   std::unique_ptr<InterpolableValue> Clone() const final {
-    return Create(*this);
+    return std::make_unique<InterpolableList>(*this);
   }
   std::unique_ptr<InterpolableValue> CloneAndZero() const final;
   void Scale(double scale) final;
@@ -117,12 +115,6 @@ class CORE_EXPORT InterpolableList : public InterpolableValue {
   void Interpolate(const InterpolableValue& to,
                    const double progress,
                    InterpolableValue& result) const final;
-  explicit InterpolableList(wtf_size_t size) : values_(size) {}
-
-  InterpolableList(const InterpolableList& other) : values_(other.length()) {
-    for (wtf_size_t i = 0; i < length(); i++)
-      Set(i, other.values_[i]->Clone());
-  }
 
   Vector<std::unique_ptr<InterpolableValue>> values_;
 };

third_party/blink/renderer/core/animation/interpolable_value_test.cc

@@ -71,12 +71,12 @@ TEST_F(AnimationInterpolableValueTest, InterpolateNumbers) {
 }
 
 TEST_F(AnimationInterpolableValueTest, SimpleList) {
-  std::unique_ptr<InterpolableList> list_a = InterpolableList::Create(3);
+  auto list_a = std::make_unique<InterpolableList>(3);
   list_a->Set(0, std::make_unique<InterpolableNumber>(0));
   list_a->Set(1, std::make_unique<InterpolableNumber>(42));
   list_a->Set(2, std::make_unique<InterpolableNumber>(20.5));
 
-  std::unique_ptr<InterpolableList> list_b = InterpolableList::Create(3);
+  auto list_b = std::make_unique<InterpolableList>(3);
   list_b->Set(0, std::make_unique<InterpolableNumber>(100));
   list_b->Set(1, std::make_unique<InterpolableNumber>(-200));
   list_b->Set(2, std::make_unique<InterpolableNumber>(300));
@@ -92,16 +92,16 @@ TEST_F(AnimationInterpolableValueTest, SimpleList) {
 }
 
 TEST_F(AnimationInterpolableValueTest, NestedList) {
-  std::unique_ptr<InterpolableList> list_a = InterpolableList::Create(3);
+  auto list_a = std::make_unique<InterpolableList>(3);
   list_a->Set(0, std::make_unique<InterpolableNumber>(0));
-  std::unique_ptr<InterpolableList> sub_list_a = InterpolableList::Create(1);
+  auto sub_list_a = std::make_unique<InterpolableList>(1);
   sub_list_a->Set(0, std::make_unique<InterpolableNumber>(100));
   list_a->Set(1, std::move(sub_list_a));
   list_a->Set(2, std::make_unique<InterpolableNumber>(0));
 
-  std::unique_ptr<InterpolableList> list_b = InterpolableList::Create(3);
+  auto list_b = std::make_unique<InterpolableList>(3);
   list_b->Set(0, std::make_unique<InterpolableNumber>(100));
-  std::unique_ptr<InterpolableList> sub_list_b = InterpolableList::Create(1);
+  auto sub_list_b = std::make_unique<InterpolableList>(1);
   sub_list_b->Set(0, std::make_unique<InterpolableNumber>(50));
   list_b->Set(1, std::move(sub_list_b));
   list_b->Set(2, std::make_unique<InterpolableNumber>(1));
@@ -134,11 +134,11 @@ TEST_F(AnimationInterpolableValueTest, ScaleAndAddNumbers) {
 }
 
 TEST_F(AnimationInterpolableValueTest, ScaleAndAddLists) {
-  std::unique_ptr<InterpolableList> base_list = InterpolableList::Create(3);
+  auto base_list = std::make_unique<InterpolableList>(3);
   base_list->Set(0, std::make_unique<InterpolableNumber>(5));
   base_list->Set(1, std::make_unique<InterpolableNumber>(10));
   base_list->Set(2, std::make_unique<InterpolableNumber>(15));
-  std::unique_ptr<InterpolableList> add_list = InterpolableList::Create(3);
+  auto add_list = std::make_unique<InterpolableList>(3);
   add_list->Set(0, std::make_unique<InterpolableNumber>(1));
   add_list->Set(1, std::make_unique<InterpolableNumber>(2));
   add_list->Set(2, std::make_unique<InterpolableNumber>(3));

third_party/blink/renderer/core/animation/length_interpolation_functions.cc

@@ -48,8 +48,7 @@ bool CSSLengthNonInterpolableValue::HasPercentage(
 
 std::unique_ptr<InterpolableValue>
 LengthInterpolationFunctions::CreateInterpolablePixels(double pixels) {
-  std::unique_ptr<InterpolableList> interpolable_list =
-      CreateNeutralInterpolableValue();
+  auto interpolable_list = CreateNeutralInterpolableValue();
   interpolable_list->Set(CSSPrimitiveValue::kUnitTypePixels,
                          std::make_unique<InterpolableNumber>(pixels));
   return std::move(interpolable_list);
@@ -57,8 +56,7 @@ LengthInterpolationFunctions::CreateInterpolablePixels(double pixels) {
 
 InterpolationValue LengthInterpolationFunctions::CreateInterpolablePercent(
     double percent) {
-  std::unique_ptr<InterpolableList> interpolable_list =
-      CreateNeutralInterpolableValue();
+  auto interpolable_list = CreateNeutralInterpolableValue();
   interpolable_list->Set(CSSPrimitiveValue::kUnitTypePercentage,
                          std::make_unique<InterpolableNumber>(percent));
   return InterpolationValue(std::move(interpolable_list),
@@ -68,7 +66,7 @@ InterpolationValue LengthInterpolationFunctions::CreateInterpolablePercent(
 std::unique_ptr<InterpolableList>
 LengthInterpolationFunctions::CreateNeutralInterpolableValue() {
   const size_t kLength = CSSPrimitiveValue::kLengthUnitTypeCount;
-  std::unique_ptr<InterpolableList> values = InterpolableList::Create(kLength);
+  auto values = std::make_unique<InterpolableList>(kLength);
   for (wtf_size_t i = 0; i < kLength; i++)
     values->Set(i, std::make_unique<InterpolableNumber>(0));
   return values;
@@ -87,8 +85,8 @@ InterpolationValue LengthInterpolationFunctions::MaybeConvertCSSValue(
   CSSLengthArray length_array;
   primitive_value->AccumulateLengthArray(length_array);
 
-  std::unique_ptr<InterpolableList> values =
-      InterpolableList::Create(CSSPrimitiveValue::kLengthUnitTypeCount);
+  auto values = std::make_unique<InterpolableList>(
+      CSSPrimitiveValue::kLengthUnitTypeCount);
   for (wtf_size_t i = 0; i < CSSPrimitiveValue::kLengthUnitTypeCount; i++) {
     values->Set(i,
                 std::make_unique<InterpolableNumber>(length_array.values[i]));
@@ -107,7 +105,7 @@ InterpolationValue LengthInterpolationFunctions::MaybeConvertLength(
     return nullptr;
 
   PixelsAndPercent pixels_and_percent = length.GetPixelsAndPercent();
-  std::unique_ptr<InterpolableList> values = CreateNeutralInterpolableValue();
+  auto values = CreateNeutralInterpolableValue();
   values->Set(
       CSSPrimitiveValue::kUnitTypePixels,
       std::make_unique<InterpolableNumber>(pixels_and_percent.pixels / zoom));

third_party/blink/renderer/core/animation/list_interpolation_functions.cc

@@ -118,10 +118,10 @@ PairwiseInterpolationValue ListInterpolationFunctions::MaybeMergeSingles(
 
   const wtf_size_t final_length =
       MatchLengths(start_length, end_length, length_matching_strategy);
-  std::unique_ptr<InterpolableList> result_start_interpolable_list =
-      InterpolableList::Create(final_length);
-  std::unique_ptr<InterpolableList> result_end_interpolable_list =
-      InterpolableList::Create(final_length);
+  auto result_start_interpolable_list =
+      std::make_unique<InterpolableList>(final_length);
+  auto result_end_interpolable_list =
+      std::make_unique<InterpolableList>(final_length);
   Vector<scoped_refptr<NonInterpolableValue>> result_non_interpolable_values(
       final_length);
 
@@ -190,8 +190,7 @@ static void RepeatToLength(InterpolationValue& value, wtf_size_t length) {
   if (current_length == length)
     return;
   DCHECK_LT(current_length, length);
-  std::unique_ptr<InterpolableList> new_interpolable_list =
-      InterpolableList::Create(length);
+  auto new_interpolable_list = std::make_unique<InterpolableList>(length);
   Vector<scoped_refptr<NonInterpolableValue>> new_non_interpolable_values(
       length);
   for (wtf_size_t i = length; i-- > 0;) {
@@ -222,8 +221,8 @@ static void PadToSameLength(InterpolationValue& value,
       ToNonInterpolableList(*length_value.non_interpolable_value);
   const wtf_size_t target_length = target_interpolable_list.length();
   DCHECK_LT(current_length, target_length);
-  std::unique_ptr<InterpolableList> new_interpolable_list =
-      InterpolableList::Create(target_length);
+  auto new_interpolable_list =
+      std::make_unique<InterpolableList>(target_length);
   Vector<scoped_refptr<NonInterpolableValue>> new_non_interpolable_values(
       target_length);
   wtf_size_t index = 0;

third_party/blink/renderer/core/animation/list_interpolation_functions.h

@@ -23,7 +23,7 @@ class CORE_EXPORT ListInterpolationFunctions {
   template <typename CreateItemCallback>
   static InterpolationValue CreateList(wtf_size_t length, CreateItemCallback);
   static InterpolationValue CreateEmptyList() {
-    return InterpolationValue(InterpolableList::Create(0));
+    return InterpolationValue(std::make_unique<InterpolableList>(0));
   }
 
   enum class LengthMatchingStrategy {
@@ -105,8 +105,7 @@ InterpolationValue ListInterpolationFunctions::CreateList(
     CreateItemCallback create_item) {
   if (length == 0)
     return CreateEmptyList();
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(length);
+  auto interpolable_list = std::make_unique<InterpolableList>(length);
   Vector<scoped_refptr<NonInterpolableValue>> non_interpolable_values(length);
   for (wtf_size_t i = 0; i < length; i++) {
     InterpolationValue item = create_item(i);

third_party/blink/renderer/core/animation/path_interpolation_functions.cc

@@ -70,13 +70,11 @@ InterpolationValue PathInterpolationFunctions::ConvertValue(
     length++;
   }
 
-  std::unique_ptr<InterpolableList> path_args =
-      InterpolableList::Create(length);
+  auto path_args = std::make_unique<InterpolableList>(length);
   for (wtf_size_t i = 0; i < interpolable_path_segs.size(); i++)
     path_args->Set(i, std::move(interpolable_path_segs[i]));
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kPathComponentIndexCount);
+  auto result = std::make_unique<InterpolableList>(kPathComponentIndexCount);
   result->Set(kPathArgsIndex, std::move(path_args));
   result->Set(kPathNeutralIndex, std::make_unique<InterpolableNumber>(0));
 
@@ -129,8 +127,7 @@ InterpolationValue PathInterpolationFunctions::MaybeConvertNeutral(
     InterpolationType::ConversionCheckers& conversion_checkers) {
   conversion_checkers.push_back(
       UnderlyingPathSegTypesChecker::Create(underlying));
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kPathComponentIndexCount);
+  auto result = std::make_unique<InterpolableList>(kPathComponentIndexCount);
   result->Set(kPathArgsIndex, ToInterpolableList(*underlying.interpolable_value)
                                   .Get(kPathArgsIndex)
                                   ->CloneAndZero());

third_party/blink/renderer/core/animation/shadow_interpolation_functions.cc

@@ -69,8 +69,8 @@ PairwiseInterpolationValue ShadowInterpolationFunctions::MaybeMergeSingles(
 InterpolationValue ShadowInterpolationFunctions::ConvertShadowData(
     const ShadowData& shadow_data,
     double zoom) {
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(kShadowComponentIndexCount);
+  auto interpolable_list =
+      std::make_unique<InterpolableList>(kShadowComponentIndexCount);
   interpolable_list->Set(kShadowX,
                          LengthInterpolationFunctions::CreateInterpolablePixels(
                              shadow_data.X() / zoom));
@@ -105,8 +105,8 @@ InterpolationValue ShadowInterpolationFunctions::MaybeConvertCSSValue(
       return nullptr;
   }
 
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(kShadowComponentIndexCount);
+  auto interpolable_list =
+      std::make_unique<InterpolableList>(kShadowComponentIndexCount);
   static_assert(kShadowX == 0, "Enum ordering check.");
   static_assert(kShadowY == 1, "Enum ordering check.");
   static_assert(kShadowBlur == 2, "Enum ordering check.");

third_party/blink/renderer/core/animation/size_interpolation_functions.cc

@@ -61,7 +61,7 @@ DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSSizeNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSSizeNonInterpolableValue);
 
 static InterpolationValue ConvertKeyword(CSSValueID keyword) {
-  return InterpolationValue(InterpolableList::Create(0),
+  return InterpolationValue(std::make_unique<InterpolableList>(0),
                             CSSSizeNonInterpolableValue::Create(keyword));
 }
 

third_party/blink/renderer/core/animation/svg_integer_optional_integer_interpolation_type.cc

@@ -14,7 +14,7 @@ InterpolationValue
 SVGIntegerOptionalIntegerInterpolationType::MaybeConvertNeutral(
     const InterpolationValue&,
     ConversionCheckers&) const {
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(0));
   result->Set(1, std::make_unique<InterpolableNumber>(0));
   return InterpolationValue(std::move(result));
@@ -28,7 +28,7 @@ SVGIntegerOptionalIntegerInterpolationType::MaybeConvertSVGValue(
 
   const SVGIntegerOptionalInteger& integer_optional_integer =
       ToSVGIntegerOptionalInteger(svg_value);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(
                      integer_optional_integer.FirstInteger()->Value()));
   result->Set(1, std::make_unique<InterpolableNumber>(

third_party/blink/renderer/core/animation/svg_length_interpolation_type.cc

@@ -16,8 +16,8 @@ namespace blink {
 
 std::unique_ptr<InterpolableValue>
 SVGLengthInterpolationType::NeutralInterpolableValue() {
-  std::unique_ptr<InterpolableList> list_of_values =
-      InterpolableList::Create(CSSPrimitiveValue::kLengthUnitTypeCount);
+  auto list_of_values = std::make_unique<InterpolableList>(
+      CSSPrimitiveValue::kLengthUnitTypeCount);
   for (wtf_size_t i = 0; i < CSSPrimitiveValue::kLengthUnitTypeCount; ++i)
     list_of_values->Set(i, std::make_unique<InterpolableNumber>(0));
 
@@ -31,8 +31,8 @@ InterpolationValue SVGLengthInterpolationType::ConvertSVGLength(
   CSSLengthArray length_array;
   primitive_value.AccumulateLengthArray(length_array);
 
-  std::unique_ptr<InterpolableList> list_of_values =
-      InterpolableList::Create(CSSPrimitiveValue::kLengthUnitTypeCount);
+  auto list_of_values = std::make_unique<InterpolableList>(
+      CSSPrimitiveValue::kLengthUnitTypeCount);
   for (wtf_size_t i = 0; i < CSSPrimitiveValue::kLengthUnitTypeCount; ++i) {
     list_of_values->Set(
         i, std::make_unique<InterpolableNumber>(length_array.values[i]));

third_party/blink/renderer/core/animation/svg_length_list_interpolation_type.cc

@@ -23,8 +23,7 @@ InterpolationValue SVGLengthListInterpolationType::MaybeConvertNeutral(
   if (underlying_length == 0)
     return nullptr;
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(underlying_length);
+  auto result = std::make_unique<InterpolableList>(underlying_length);
   for (wtf_size_t i = 0; i < underlying_length; i++)
     result->Set(i, SVGLengthInterpolationType::NeutralInterpolableValue());
   return InterpolationValue(std::move(result));
@@ -36,8 +35,7 @@ InterpolationValue SVGLengthListInterpolationType::MaybeConvertSVGValue(
     return nullptr;
 
   const SVGLengthList& length_list = ToSVGLengthList(svg_value);
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(length_list.length());
+  auto result = std::make_unique<InterpolableList>(length_list.length());
   for (wtf_size_t i = 0; i < length_list.length(); i++) {
     InterpolationValue component =
         SVGLengthInterpolationType::ConvertSVGLength(*length_list.at(i));

third_party/blink/renderer/core/animation/svg_number_list_interpolation_type.cc

@@ -22,8 +22,7 @@ InterpolationValue SVGNumberListInterpolationType::MaybeConvertNeutral(
   if (underlying_length == 0)
     return nullptr;
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(underlying_length);
+  auto result = std::make_unique<InterpolableList>(underlying_length);
   for (wtf_size_t i = 0; i < underlying_length; i++)
     result->Set(i, std::make_unique<InterpolableNumber>(0));
   return InterpolationValue(std::move(result));
@@ -35,8 +34,7 @@ InterpolationValue SVGNumberListInterpolationType::MaybeConvertSVGValue(
     return nullptr;
 
   const SVGNumberList& number_list = ToSVGNumberList(svg_value);
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(number_list.length());
+  auto result = std::make_unique<InterpolableList>(number_list.length());
   for (wtf_size_t i = 0; i < number_list.length(); i++) {
     result->Set(
         i, std::make_unique<InterpolableNumber>(number_list.at(i)->Value()));
@@ -61,8 +59,7 @@ static void PadWithZeroes(std::unique_ptr<InterpolableValue>& list_pointer,
   if (list.length() >= padded_length)
     return;
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(padded_length);
+  auto result = std::make_unique<InterpolableList>(padded_length);
   wtf_size_t i = 0;
   for (; i < list.length(); i++)
     result->Set(i, std::move(list.GetMutable(i)));

third_party/blink/renderer/core/animation/svg_number_optional_number_interpolation_type.cc

@@ -14,7 +14,7 @@ InterpolationValue
 SVGNumberOptionalNumberInterpolationType::MaybeConvertNeutral(
     const InterpolationValue&,
     ConversionCheckers&) const {
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(0));
   result->Set(1, std::make_unique<InterpolableNumber>(0));
   return InterpolationValue(std::move(result));
@@ -28,7 +28,7 @@ SVGNumberOptionalNumberInterpolationType::MaybeConvertSVGValue(
 
   const SVGNumberOptionalNumber& number_optional_number =
       ToSVGNumberOptionalNumber(svg_value);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(
                      number_optional_number.FirstNumber()->Value()));
   result->Set(1, std::make_unique<InterpolableNumber>(

third_party/blink/renderer/core/animation/svg_path_seg_interpolation_functions.cc

@@ -44,7 +44,7 @@ std::unique_ptr<InterpolableValue> ConsumeClosePath(
     PathCoordinates& coordinates) {
   coordinates.current_x = coordinates.initial_x;
   coordinates.current_y = coordinates.initial_y;
-  return InterpolableList::Create(0);
+  return std::make_unique<InterpolableList>(0);
 }
 
 PathSegmentData ConsumeInterpolableClosePath(const InterpolableValue&,
@@ -62,7 +62,7 @@ std::unique_ptr<InterpolableValue> ConsumeSingleCoordinate(
     const PathSegmentData& segment,
     PathCoordinates& coordinates) {
   bool is_absolute = IsAbsolutePathSegType(segment.command);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, ConsumeCoordinateAxis(segment.X(), is_absolute,
                                        coordinates.current_x));
   result->Set(1, ConsumeCoordinateAxis(segment.Y(), is_absolute,
@@ -105,7 +105,7 @@ std::unique_ptr<InterpolableValue> ConsumeCurvetoCubic(
     const PathSegmentData& segment,
     PathCoordinates& coordinates) {
   bool is_absolute = IsAbsolutePathSegType(segment.command);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(6);
+  auto result = std::make_unique<InterpolableList>(6);
   result->Set(
       0, ConsumeControlAxis(segment.X1(), is_absolute, coordinates.current_x));
   result->Set(
@@ -147,7 +147,7 @@ std::unique_ptr<InterpolableValue> ConsumeCurvetoQuadratic(
     const PathSegmentData& segment,
     PathCoordinates& coordinates) {
   bool is_absolute = IsAbsolutePathSegType(segment.command);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(4);
+  auto result = std::make_unique<InterpolableList>(4);
   result->Set(
       0, ConsumeControlAxis(segment.X1(), is_absolute, coordinates.current_x));
   result->Set(
@@ -181,7 +181,7 @@ PathSegmentData ConsumeInterpolableCurvetoQuadratic(
 std::unique_ptr<InterpolableValue> ConsumeArc(const PathSegmentData& segment,
                                               PathCoordinates& coordinates) {
   bool is_absolute = IsAbsolutePathSegType(segment.command);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(7);
+  auto result = std::make_unique<InterpolableList>(7);
   result->Set(0, ConsumeCoordinateAxis(segment.X(), is_absolute,
                                        coordinates.current_x));
   result->Set(1, ConsumeCoordinateAxis(segment.Y(), is_absolute,
@@ -256,7 +256,7 @@ std::unique_ptr<InterpolableValue> ConsumeCurvetoCubicSmooth(
     const PathSegmentData& segment,
     PathCoordinates& coordinates) {
   bool is_absolute = IsAbsolutePathSegType(segment.command);
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(4);
+  auto result = std::make_unique<InterpolableList>(4);
   result->Set(
       0, ConsumeControlAxis(segment.X2(), is_absolute, coordinates.current_x));
   result->Set(

third_party/blink/renderer/core/animation/svg_point_list_interpolation_type.cc

@@ -23,8 +23,7 @@ InterpolationValue SVGPointListInterpolationType::MaybeConvertNeutral(
   if (underlying_length == 0)
     return nullptr;
 
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(underlying_length);
+  auto result = std::make_unique<InterpolableList>(underlying_length);
   for (wtf_size_t i = 0; i < underlying_length; i++)
     result->Set(i, std::make_unique<InterpolableNumber>(0));
   return InterpolationValue(std::move(result));
@@ -36,8 +35,7 @@ InterpolationValue SVGPointListInterpolationType::MaybeConvertSVGValue(
     return nullptr;
 
   const SVGPointList& point_list = ToSVGPointList(svg_value);
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(point_list.length() * 2);
+  auto result = std::make_unique<InterpolableList>(point_list.length() * 2);
   for (wtf_size_t i = 0; i < point_list.length(); i++) {
     const SVGPoint& point = *point_list.at(i);
     result->Set(2 * i, std::make_unique<InterpolableNumber>(point.X()));

third_party/blink/renderer/core/animation/svg_rect_interpolation_type.cc

@@ -22,8 +22,7 @@ enum RectComponentIndex : unsigned {
 InterpolationValue SVGRectInterpolationType::MaybeConvertNeutral(
     const InterpolationValue&,
     ConversionCheckers&) const {
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kRectComponentIndexCount);
+  auto result = std::make_unique<InterpolableList>(kRectComponentIndexCount);
   for (wtf_size_t i = 0; i < kRectComponentIndexCount; i++)
     result->Set(i, std::make_unique<InterpolableNumber>(0));
   return InterpolationValue(std::move(result));
@@ -35,8 +34,7 @@ InterpolationValue SVGRectInterpolationType::MaybeConvertSVGValue(
     return nullptr;
 
   const SVGRect& rect = ToSVGRect(svg_value);
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(kRectComponentIndexCount);
+  auto result = std::make_unique<InterpolableList>(kRectComponentIndexCount);
   result->Set(kRectX, std::make_unique<InterpolableNumber>(rect.X()));
   result->Set(kRectY, std::make_unique<InterpolableNumber>(rect.Y()));
   result->Set(kRectWidth, std::make_unique<InterpolableNumber>(rect.Width()));

third_party/blink/renderer/core/animation/svg_transform_list_interpolation_type.cc

@@ -49,7 +49,7 @@ namespace {
 std::unique_ptr<InterpolableValue> TranslateToInterpolableValue(
     SVGTransform* transform) {
   FloatPoint translate = transform->Translate();
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(translate.X()));
   result->Set(1, std::make_unique<InterpolableNumber>(translate.Y()));
   return std::move(result);
@@ -67,7 +67,7 @@ SVGTransform* TranslateFromInterpolableValue(const InterpolableValue& value) {
 std::unique_ptr<InterpolableValue> ScaleToInterpolableValue(
     SVGTransform* transform) {
   FloatSize scale = transform->Scale();
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(2);
+  auto result = std::make_unique<InterpolableList>(2);
   result->Set(0, std::make_unique<InterpolableNumber>(scale.Width()));
   result->Set(1, std::make_unique<InterpolableNumber>(scale.Height()));
   return std::move(result);
@@ -85,7 +85,7 @@ SVGTransform* ScaleFromInterpolableValue(const InterpolableValue& value) {
 std::unique_ptr<InterpolableValue> RotateToInterpolableValue(
     SVGTransform* transform) {
   FloatPoint rotation_center = transform->RotationCenter();
-  std::unique_ptr<InterpolableList> result = InterpolableList::Create(3);
+  auto result = std::make_unique<InterpolableList>(3);
   result->Set(0, std::make_unique<InterpolableNumber>(transform->Angle()));
   result->Set(1, std::make_unique<InterpolableNumber>(rotation_center.X()));
   result->Set(2, std::make_unique<InterpolableNumber>(rotation_center.Y()));
@@ -212,8 +212,7 @@ InterpolationValue SVGTransformListInterpolationType::MaybeConvertSVGValue(
     return nullptr;
 
   const SVGTransformList& svg_list = ToSVGTransformList(svg_value);
-  std::unique_ptr<InterpolableList> result =
-      InterpolableList::Create(svg_list.length());
+  auto result = std::make_unique<InterpolableList>(svg_list.length());
 
   Vector<SVGTransformType> transform_types;
   for (wtf_size_t i = 0; i < svg_list.length(); i++) {
@@ -262,8 +261,7 @@ InterpolationValue SVGTransformListInterpolationType::MaybeConvertSingle(
     interpolable_parts.push_back(std::move(value.interpolable_value));
   }
 
-  std::unique_ptr<InterpolableList> interpolable_list =
-      InterpolableList::Create(types.size());
+  auto interpolable_list = std::make_unique<InterpolableList>(types.size());
   wtf_size_t interpolable_list_index = 0;
   for (auto& part : interpolable_parts) {
     InterpolableList& list = ToInterpolableList(*part);

third_party/blink/renderer/core/animation/svg_value_interpolation_type.cc

@@ -38,7 +38,7 @@ InterpolationValue SVGValueInterpolationType::MaybeConvertSVGValue(
   SVGPropertyBase* referenced_value =
       const_cast<SVGPropertyBase*>(&value);  // Take ref.
   return InterpolationValue(
-      InterpolableList::Create(0),
+      std::make_unique<InterpolableList>(0),
       SVGValueNonInterpolableValue::Create(referenced_value));
 }