Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSImageInterpolationType.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/CSSImageInterpolationType.h"
 
 #include <memory>
 #include "core/animation/ImagePropertyFunctions.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSPrimitiveValue.h"
@@ skipping 111 matching lines @@
   return state.GetStyleImage(property, *image);
 }
 
 bool CSSImageInterpolationType::EqualNonInterpolableValues(
     const NonInterpolableValue* a,
     const NonInterpolableValue* b) {
   return ToCSSImageNonInterpolableValue(*a).Equals(
       ToCSSImageNonInterpolableValue(*b));
 }
 
-class UnderlyingImageChecker : public InterpolationType::ConversionChecker {
+class UnderlyingImageChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~UnderlyingImageChecker() final {}
 
   static std::unique_ptr<UnderlyingImageChecker> Create(
       const InterpolationValue& underlying) {
     return WTF::WrapUnique(new UnderlyingImageChecker(underlying));
   }
 
  private:
   UnderlyingImageChecker(const InterpolationValue& underlying)
       : underlying_(underlying.Clone()) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     if (!underlying && !underlying_)
       return true;
     if (!underlying || !underlying_)
       return false;
     return underlying_.interpolable_value->Equals(
                *underlying.interpolable_value) &&
            CSSImageInterpolationType::EqualNonInterpolableValues(
                underlying_.non_interpolable_value.Get(),
                underlying.non_interpolable_value.Get());
   }
 
   const InterpolationValue underlying_;
 };
 
 InterpolationValue CSSImageInterpolationType::MaybeConvertNeutral(
     const InterpolationValue& underlying,
     ConversionCheckers& conversion_checkers) const {
   conversion_checkers.push_back(UnderlyingImageChecker::Create(underlying));
   return InterpolationValue(underlying.Clone());
 }
 
 InterpolationValue CSSImageInterpolationType::MaybeConvertInitial(
     const StyleResolverState&,
     ConversionCheckers& conversion_checkers) const {
   return MaybeConvertStyleImage(
       ImagePropertyFunctions::GetInitialStyleImage(CssProperty()), true);
 }
 
-class InheritedImageChecker : public InterpolationType::ConversionChecker {
+class InheritedImageChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~InheritedImageChecker() final {}
 
   static std::unique_ptr<InheritedImageChecker> Create(
       CSSPropertyID property,
       StyleImage* inherited_image) {
     return WTF::WrapUnique(
         new InheritedImageChecker(property, inherited_image));
   }
 
  private:
   InheritedImageChecker(CSSPropertyID property, StyleImage* inherited_image)
       : property_(property), inherited_image_(inherited_image) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
-    const StyleImage* inherited_image = ImagePropertyFunctions::GetStyleImage(
-        property_, *environment.GetState().ParentStyle());
+    const StyleImage* inherited_image =
+        ImagePropertyFunctions::GetStyleImage(property_, *state.ParentStyle());
     if (!inherited_image_ && !inherited_image)
       return true;
     if (!inherited_image_ || !inherited_image)
       return false;
     return *inherited_image_ == *inherited_image;
   }
 
   CSSPropertyID property_;
   Persistent<StyleImage> inherited_image_;
 };
@@ skipping 38 matching lines @@
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   ImagePropertyFunctions::SetStyleImage(
       CssProperty(), *state.Style(),
       ResolveStyleImage(CssProperty(), interpolable_value,
                         non_interpolable_value, state));
 }
 
 }  // namespace blink