Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSClipInterpolationType.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/CSSClipInterpolationType.h"
 
 #include <memory>
 #include "core/animation/LengthInterpolationFunctions.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSQuadValue.h"
@@ skipping 40 matching lines @@
   bool is_left_auto;
 };
 
 static ClipAutos GetClipAutos(const ComputedStyle& style) {
   if (style.HasAutoClip())
     return ClipAutos();
   return ClipAutos(style.ClipTop().IsAuto(), style.ClipRight().IsAuto(),
                    style.ClipBottom().IsAuto(), style.ClipLeft().IsAuto());
 }
 
-class InheritedAutosChecker : public InterpolationType::ConversionChecker {
+class InheritedAutosChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedAutosChecker> Create(
       const ClipAutos& inherited_autos) {
     return WTF::WrapUnique(new InheritedAutosChecker(inherited_autos));
   }
 
  private:
   InheritedAutosChecker(const ClipAutos& inherited_autos)
       : inherited_autos_(inherited_autos) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
-    return inherited_autos_ ==
-           GetClipAutos(*environment.GetState().ParentStyle());
+    return inherited_autos_ == GetClipAutos(*state.ParentStyle());
   }
 
   const ClipAutos inherited_autos_;
 };
 
 class CSSClipNonInterpolableValue : public NonInterpolableValue {
  public:
   ~CSSClipNonInterpolableValue() final {}
 
   static PassRefPtr<CSSClipNonInterpolableValue> Create(
@@ skipping 10 matching lines @@
       : clip_autos_(clip_autos) {
     DCHECK(!clip_autos_.is_auto);
   }
 
   const ClipAutos clip_autos_;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSClipNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSClipNonInterpolableValue);
 
-class UnderlyingAutosChecker : public InterpolationType::ConversionChecker {
+class UnderlyingAutosChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~UnderlyingAutosChecker() final {}
 
   static std::unique_ptr<UnderlyingAutosChecker> Create(
       const ClipAutos& underlying_autos) {
     return WTF::WrapUnique(new UnderlyingAutosChecker(underlying_autos));
   }
 
   static ClipAutos GetUnderlyingAutos(const InterpolationValue& underlying) {
     if (!underlying)
       return ClipAutos();
     return ToCSSClipNonInterpolableValue(*underlying.non_interpolable_value)
         .GetClipAutos();
   }
 
  private:
   UnderlyingAutosChecker(const ClipAutos& underlying_autos)
       : underlying_autos_(underlying_autos) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return underlying_autos_ == GetUnderlyingAutos(underlying);
   }
 
   const ClipAutos underlying_autos_;
 };
 
 enum ClipComponentIndex : unsigned {
   kClipTop,
   kClipRight,
@@ skipping 145 matching lines @@
         kValueRangeAll);
   };
   state.Style()->SetClip(
       LengthBox(convert_index(autos.is_top_auto, kClipTop),
                 convert_index(autos.is_right_auto, kClipRight),
                 convert_index(autos.is_bottom_auto, kClipBottom),
                 convert_index(autos.is_left_auto, kClipLeft)));
 }
 
 }  // namespace blink