Fix behaviour of shadow interpolation with mismatched list lengths

third_party/WebKit/Source/core/animation/ListInterpolationFunctions.h

 // Copyright 2015 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.
 
 #ifndef ListInterpolationFunctions_h
 #define ListInterpolationFunctions_h
 
 #include <memory>
 #include "core/animation/InterpolationValue.h"
 #include "core/animation/PairwiseInterpolationValue.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
 class UnderlyingValueOwner;
 class InterpolationType;
 
 class ListInterpolationFunctions {
  public:
   template <typename CreateItemCallback>
   static InterpolationValue CreateList(size_t length, CreateItemCallback);
   static InterpolationValue CreateEmptyList() {
     return InterpolationValue(InterpolableList::Create(0));
   }
 
+  enum LengthMatchingStrategy { kLowestCommonMultiple, kPadToLargest };

[shend, 2017/04/27 06:07:49]

Should the enum value name indicate that it's a strategy? e.g.
kMatchingStrategyLowestCommonMultiple?

[alancutter (OOO until 2018), 2017/04/27 07:09:22]

Made it an enum class.

+
   using MergeSingleItemConversionsCallback =
       PairwiseInterpolationValue (*)(InterpolationValue&& start,
                                      InterpolationValue&& end);
   static PairwiseInterpolationValue MaybeMergeSingles(
       InterpolationValue&& start,
       InterpolationValue&& end,
+      LengthMatchingStrategy,
       MergeSingleItemConversionsCallback);
 
   using EqualNonInterpolableValuesCallback =
       bool (*)(const NonInterpolableValue*, const NonInterpolableValue*);
   static bool EqualValues(const InterpolationValue&,
                           const InterpolationValue&,
                           EqualNonInterpolableValuesCallback);
 
   using NonInterpolableValuesAreCompatibleCallback =
       bool (*)(const NonInterpolableValue*, const NonInterpolableValue*);
   using CompositeItemCallback = void (*)(std::unique_ptr<InterpolableValue>&,
                                          RefPtr<NonInterpolableValue>&,
                                          double underlying_fraction,
                                          const InterpolableValue&,
                                          const NonInterpolableValue*);
   static void Composite(UnderlyingValueOwner&,
                         double underlying_fraction,
                         const InterpolationType&,
                         const InterpolationValue&,
+                        LengthMatchingStrategy,
                         NonInterpolableValuesAreCompatibleCallback,
                         CompositeItemCallback);
 };
 
 class NonInterpolableList : public NonInterpolableValue {
  public:
   ~NonInterpolableList() final {}
 
   static PassRefPtr<NonInterpolableList> Create() {
     return AdoptRef(new NonInterpolableList());
@@ skipping 41 matching lines @@
     non_interpolable_values[i] = std::move(item.non_interpolable_value);
   }
   return InterpolationValue(
       std::move(interpolable_list),
       NonInterpolableList::Create(std::move(non_interpolable_values)));
 }
 
 }  // namespace blink
 
 #endif  // ListInterpolationFunctions_h