Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSSizeListInterpolationType.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/CSSSizeListInterpolationType.h"
 
 #include "core/animation/ListInterpolationFunctions.h"
 #include "core/animation/SizeInterpolationFunctions.h"
 #include "core/animation/SizeListPropertyFunctions.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 
 namespace blink {
 
-class UnderlyingSizeListChecker : public InterpolationType::ConversionChecker {
+class UnderlyingSizeListChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~UnderlyingSizeListChecker() final {}
 
   static std::unique_ptr<UnderlyingSizeListChecker> Create(
       const NonInterpolableList& underlying_list) {
     return WTF::WrapUnique(new UnderlyingSizeListChecker(underlying_list));
   }
 
  private:
   UnderlyingSizeListChecker(const NonInterpolableList& underlying_list)
       : underlying_list_(&underlying_list) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     const auto& underlying_list =
         ToNonInterpolableList(*underlying.non_interpolable_value);
     size_t underlying_length = underlying_list.length();
     if (underlying_length != underlying_list_->length())
       return false;
     for (size_t i = 0; i < underlying_length; i++) {
       bool compatible =
           SizeInterpolationFunctions::NonInterpolableValuesAreCompatible(
               underlying_list.Get(i), underlying_list_->Get(i));
       if (!compatible)
         return false;
     }
     return true;
   }
 
   RefPtr<const NonInterpolableList> underlying_list_;
 };
 
-class InheritedSizeListChecker : public InterpolationType::ConversionChecker {
+class InheritedSizeListChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~InheritedSizeListChecker() final {}
 
   static std::unique_ptr<InheritedSizeListChecker> Create(
       CSSPropertyID property,
       const SizeList& inherited_size_list) {
     return WTF::WrapUnique(
         new InheritedSizeListChecker(property, inherited_size_list));
   }
 
  private:
   InheritedSizeListChecker(CSSPropertyID property,
                            const SizeList& inherited_size_list)
       : property_(property), inherited_size_list_(inherited_size_list) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
-    return inherited_size_list_ ==
-           SizeListPropertyFunctions::GetSizeList(
-               property_, *environment.GetState().ParentStyle());
+    return inherited_size_list_ == SizeListPropertyFunctions::GetSizeList(
+                                       property_, *state.ParentStyle());
   }
 
   CSSPropertyID property_;
   SizeList inherited_size_list_;
 };
 
 InterpolationValue ConvertSizeList(const SizeList& size_list, float zoom) {
   // Flatten pairs of width/height into individual items, even for contain and
   // cover keywords.
   return ListInterpolationFunctions::CreateList(
@@ skipping 112 matching lines @@
     size_list[i] = SizeInterpolationFunctions::CreateFillSize(
         *interpolable_list.Get(i * 2), non_interpolable_list.Get(i * 2),
         *interpolable_list.Get(i * 2 + 1), non_interpolable_list.Get(i * 2 + 1),
         state.CssToLengthConversionData());
   }
   SizeListPropertyFunctions::SetSizeList(CssProperty(), *state.Style(),
                                          size_list);
 }
 
 }  // namespace blink