Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSImageSliceInterpolationType.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/CSSImageSliceInterpolationType.h"
 
 #include <memory>
 #include "core/animation/CSSLengthInterpolationType.h"
 #include "core/animation/ImageSlicePropertyFunctions.h"
 #include "core/animation/SideIndex.h"
@@ skipping 60 matching lines @@
 
   const SliceTypes types_;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSImageSliceNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSImageSliceNonInterpolableValue);
 
 namespace {
 
 class UnderlyingSliceTypesChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<UnderlyingSliceTypesChecker> Create(
       const SliceTypes& underlying_types) {
     return WTF::WrapUnique(new UnderlyingSliceTypesChecker(underlying_types));
   }
 
   static SliceTypes GetUnderlyingSliceTypes(
       const InterpolationValue& underlying) {
     return ToCSSImageSliceNonInterpolableValue(
                *underlying.non_interpolable_value)
         .Types();
   }
 
  private:
   UnderlyingSliceTypesChecker(const SliceTypes& underlying_types)
       : underlying_types_(underlying_types) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return underlying_types_ == GetUnderlyingSliceTypes(underlying);
   }
 
   const SliceTypes underlying_types_;
 };
 
-class InheritedSliceTypesChecker : public InterpolationType::ConversionChecker {
+class InheritedSliceTypesChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedSliceTypesChecker> Create(
       CSSPropertyID property,
       const SliceTypes& inherited_types) {
     return WTF::WrapUnique(
         new InheritedSliceTypesChecker(property, inherited_types));
   }
 
  private:
   InheritedSliceTypesChecker(CSSPropertyID property,
                              const SliceTypes& inherited_types)
       : property_(property), inherited_types_(inherited_types) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     return inherited_types_ ==
            SliceTypes(ImageSlicePropertyFunctions::GetImageSlice(
-               property_, *environment.GetState().ParentStyle()));
+               property_, *state.ParentStyle()));
   }
 
   const CSSPropertyID property_;
   const SliceTypes inherited_types_;
 };
 
 InterpolationValue ConvertImageSlice(const ImageSlice& slice, double zoom) {
   std::unique_ptr<InterpolableList> list =
       InterpolableList::Create(kSideIndexCount);
   const Length* sides[kSideIndexCount] = {};
@@ skipping 136 matching lines @@
                ? Length(value * style.EffectiveZoom(), kFixed)
                : Length(value, kPercent);
   };
   LengthBox box(convert_side(kSideTop), convert_side(kSideRight),
                 convert_side(kSideBottom), convert_side(kSideLeft));
   ImageSlicePropertyFunctions::SetImageSlice(CssProperty(), style,
                                              ImageSlice(box, types.fill));
 }
 
 }  // namespace blink