Fix behaviour of shadow interpolation with mismatched list lengths

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

 // 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.
 
 #include "core/animation/CSSLengthListInterpolationType.h"
 
 #include <memory>
 #include "core/animation/LengthInterpolationFunctions.h"
 #include "core/animation/LengthListPropertyFunctions.h"
 #include "core/animation/ListInterpolationFunctions.h"
@@ skipping 106 matching lines @@
         return LengthInterpolationFunctions::MaybeConvertCSSValue(
             list.Item(index));
       });
 }
 
 PairwiseInterpolationValue CSSLengthListInterpolationType::MaybeMergeSingles(
     InterpolationValue&& start,
     InterpolationValue&& end) const {
   return ListInterpolationFunctions::MaybeMergeSingles(
       std::move(start), std::move(end),
+      ListInterpolationFunctions::LengthMatchingStrategy::kLowestCommonMultiple,
       LengthInterpolationFunctions::MergeSingles);
 }
 
 InterpolationValue
 CSSLengthListInterpolationType::MaybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   Vector<Length> underlying_length_list;
   if (!LengthListPropertyFunctions::GetLengthList(CssProperty(), style,
                                                   underlying_length_list))
     return nullptr;
   return MaybeConvertLengthList(underlying_length_list, style.EffectiveZoom());
 }
 
 void CSSLengthListInterpolationType::Composite(
     UnderlyingValueOwner& underlying_value_owner,
     double underlying_fraction,
     const InterpolationValue& value,
     double interpolation_fraction) const {
   ListInterpolationFunctions::Composite(
       underlying_value_owner, underlying_fraction, *this, value,
+      ListInterpolationFunctions::LengthMatchingStrategy::kLowestCommonMultiple,
       LengthInterpolationFunctions::NonInterpolableValuesAreCompatible,
       LengthInterpolationFunctions::Composite);
 }
 
 void CSSLengthListInterpolationType::ApplyStandardPropertyValue(
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   const InterpolableList& interpolable_list =
       ToInterpolableList(interpolable_value);
   const size_t length = interpolable_list.length();
   DCHECK_GT(length, 0U);
   const NonInterpolableList& non_interpolable_list =
       ToNonInterpolableList(*non_interpolable_value);
   DCHECK_EQ(non_interpolable_list.length(), length);
   Vector<Length> result(length);
   for (size_t i = 0; i < length; i++) {
     result[i] = LengthInterpolationFunctions::CreateLength(
         *interpolable_list.Get(i), non_interpolable_list.Get(i),
         state.CssToLengthConversionData(), value_range_);
   }
   LengthListPropertyFunctions::SetLengthList(CssProperty(), *state.Style(),
                                              std::move(result));
 }
 
 }  // namespace blink