Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSImageListInterpolationType.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/CSSImageListInterpolationType.h"
 
 #include <memory>
 #include "core/animation/CSSImageInterpolationType.h"
 #include "core/animation/ImageListPropertyFunctions.h"
 #include "core/animation/ListInterpolationFunctions.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
-class UnderlyingImageListChecker : public InterpolationType::ConversionChecker {
+class UnderlyingImageListChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~UnderlyingImageListChecker() final {}
 
   static std::unique_ptr<UnderlyingImageListChecker> Create(
       const InterpolationValue& underlying) {
     return WTF::WrapUnique(new UnderlyingImageListChecker(underlying));
   }
 
  private:
   UnderlyingImageListChecker(const InterpolationValue& underlying)
       : underlying_(underlying.Clone()) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return ListInterpolationFunctions::EqualValues(
         underlying_, underlying,
         CSSImageInterpolationType::EqualNonInterpolableValues);
   }
 
   const InterpolationValue underlying_;
 };
 
 InterpolationValue CSSImageListInterpolationType::MaybeConvertNeutral(
@@ skipping 17 matching lines @@
   if (image_list.size() == 0)
     return nullptr;
 
   return ListInterpolationFunctions::CreateList(
       image_list.size(), [&image_list](size_t index) {
         return CSSImageInterpolationType::MaybeConvertStyleImage(
             image_list[index].Get(), false);
       });
 }
 
-class InheritedImageListChecker : public InterpolationType::ConversionChecker {
+class InheritedImageListChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~InheritedImageListChecker() final {}
 
   static std::unique_ptr<InheritedImageListChecker> Create(
       CSSPropertyID property,
       const StyleImageList& inherited_image_list) {
     return WTF::WrapUnique(
         new InheritedImageListChecker(property, inherited_image_list));
   }
 
  private:
   InheritedImageListChecker(CSSPropertyID property,
                             const StyleImageList& inherited_image_list)
       : property_(property), inherited_image_list_(inherited_image_list) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     StyleImageList inherited_image_list;
-    ImageListPropertyFunctions::GetImageList(
-        property_, *environment.GetState().ParentStyle(), inherited_image_list);
+    ImageListPropertyFunctions::GetImageList(property_, *state.ParentStyle(),
+                                             inherited_image_list);
     return inherited_image_list_ == inherited_image_list;
   }
 
   CSSPropertyID property_;
   StyleImageList inherited_image_list_;
 };
 
 InterpolationValue CSSImageListInterpolationType::MaybeConvertInherit(
     const StyleResolverState& state,
     ConversionCheckers& conversion_checkers) const {
@@ skipping 83 matching lines @@
   for (size_t i = 0; i < length; i++) {
     image_list[i] = CSSImageInterpolationType::ResolveStyleImage(
         CssProperty(), *interpolable_list.Get(i), non_interpolable_list.Get(i),
         state);
   }
   ImageListPropertyFunctions::SetImageList(CssProperty(), *state.Style(),
                                            image_list);
 }
 
 }  // namespace blink