Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSBorderImageLengthBoxInterpolationType.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/CSSBorderImageLengthBoxInterpolationType.h"
 
 #include <memory>
 #include "core/animation/BorderImageLengthBoxPropertyFunctions.h"
 #include "core/animation/LengthInterpolationFunctions.h"
 #include "core/animation/SideIndex.h"
@@ skipping 101 matching lines @@
   const SideTypes side_types_;
   Vector<RefPtr<NonInterpolableValue>> side_non_interpolable_values_;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSBorderImageLengthBoxNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(
     CSSBorderImageLengthBoxNonInterpolableValue);
 
 namespace {
 
-class UnderlyingSideTypesChecker : public InterpolationType::ConversionChecker {
+class UnderlyingSideTypesChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<UnderlyingSideTypesChecker> Create(
       const SideTypes& underlying_side_types) {
     return WTF::WrapUnique(
         new UnderlyingSideTypesChecker(underlying_side_types));
   }
 
   static SideTypes GetUnderlyingSideTypes(
       const InterpolationValue& underlying) {
     return ToCSSBorderImageLengthBoxNonInterpolableValue(
                *underlying.non_interpolable_value)
         .GetSideTypes();
   }
 
  private:
   UnderlyingSideTypesChecker(const SideTypes& underlying_side_types)
       : underlying_side_types_(underlying_side_types) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return underlying_side_types_ == GetUnderlyingSideTypes(underlying);
   }
 
   const SideTypes underlying_side_types_;
 };
 
-class InheritedSideTypesChecker : public InterpolationType::ConversionChecker {
+class InheritedSideTypesChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedSideTypesChecker> Create(
       CSSPropertyID property,
       const SideTypes& inherited_side_types) {
     return WTF::WrapUnique(
         new InheritedSideTypesChecker(property, inherited_side_types));
   }
 
  private:
   InheritedSideTypesChecker(CSSPropertyID property,
                             const SideTypes& inherited_side_types)
       : property_(property), inherited_side_types_(inherited_side_types) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     return inherited_side_types_ ==
            SideTypes(
                BorderImageLengthBoxPropertyFunctions::GetBorderImageLengthBox(
-                   property_, *environment.GetState().ParentStyle()));
+                   property_, *state.ParentStyle()));
   }
 
   const CSSPropertyID property_;
   const SideTypes inherited_side_types_;
 };
 
 InterpolationValue ConvertBorderImageLengthBox(const BorderImageLengthBox& box,
                                                double zoom) {
   std::unique_ptr<InterpolableList> list =
       InterpolableList::Create(kSideIndexCount);
@@ skipping 216 matching lines @@
         return Length(kAuto);
     }
   };
   BorderImageLengthBox box(convert_side(kSideTop), convert_side(kSideRight),
                            convert_side(kSideBottom), convert_side(kSideLeft));
   BorderImageLengthBoxPropertyFunctions::SetBorderImageLengthBox(
       CssProperty(), *state.Style(), box);
 }
 
 }  // namespace blink