Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSBasicShapeInterpolationType.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/CSSBasicShapeInterpolationType.h"
 
 #include <memory>
 #include "core/animation/BasicShapeInterpolationFunctions.h"
 #include "core/animation/BasicShapePropertyFunctions.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/BasicShapes.h"
 #include "core/style/DataEquivalency.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
 class UnderlyingCompatibilityChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<UnderlyingCompatibilityChecker> Create(
       PassRefPtr<NonInterpolableValue> underlying_non_interpolable_value) {
     return WTF::WrapUnique(new UnderlyingCompatibilityChecker(
         std::move(underlying_non_interpolable_value)));
   }
 
  private:
   UnderlyingCompatibilityChecker(
       PassRefPtr<NonInterpolableValue> underlying_non_interpolable_value)
       : underlying_non_interpolable_value_(
             std::move(underlying_non_interpolable_value)) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return BasicShapeInterpolationFunctions::ShapesAreCompatible(
         *underlying_non_interpolable_value_,
         *underlying.non_interpolable_value);
   }
 
   RefPtr<NonInterpolableValue> underlying_non_interpolable_value_;
 };
 
-class InheritedShapeChecker : public InterpolationType::ConversionChecker {
+class InheritedShapeChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedShapeChecker> Create(
       CSSPropertyID property,
       PassRefPtr<BasicShape> inherited_shape) {
     return WTF::WrapUnique(
         new InheritedShapeChecker(property, std::move(inherited_shape)));
   }
 
  private:
   InheritedShapeChecker(CSSPropertyID property,
                         PassRefPtr<BasicShape> inherited_shape)
       : property_(property), inherited_shape_(std::move(inherited_shape)) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
-    return DataEquivalent(
-        inherited_shape_.Get(),
-        BasicShapePropertyFunctions::GetBasicShape(
-            property_, *environment.GetState().ParentStyle()));
+    return DataEquivalent(inherited_shape_.Get(),
+                          BasicShapePropertyFunctions::GetBasicShape(
+                              property_, *state.ParentStyle()));
   }
 
   const CSSPropertyID property_;
   RefPtr<BasicShape> inherited_shape_;
 };
 
 }  // namespace
 
 InterpolationValue CSSBasicShapeInterpolationType::MaybeConvertNeutral(
     const InterpolationValue& underlying,
@@ skipping 82 matching lines @@
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   BasicShapePropertyFunctions::SetBasicShape(
       CssProperty(), *state.Style(),
       BasicShapeInterpolationFunctions::CreateBasicShape(
           interpolable_value, *non_interpolable_value,
           state.CssToLengthConversionData()));
 }
 
 }  // namespace blink