Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSOffsetRotateInterpolationType.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/CSSOffsetRotateInterpolationType.h"
 
 #include <memory>
 #include "core/css/resolver/StyleBuilderConverter.h"
 #include "core/style/StyleOffsetRotation.h"
 #include "platform/wtf/PtrUtil.h"
@@ skipping 19 matching lines @@
 
   OffsetRotationType rotation_type_;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSOffsetRotationNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSOffsetRotationNonInterpolableValue);
 
 namespace {
 
 class UnderlyingRotationTypeChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<UnderlyingRotationTypeChecker> Create(
       OffsetRotationType underlying_rotation_type) {
     return WTF::WrapUnique(
         new UnderlyingRotationTypeChecker(underlying_rotation_type));
   }
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return underlying_rotation_type_ == ToCSSOffsetRotationNonInterpolableValue(
                                             *underlying.non_interpolable_value)
                                             .RotationType();
   }
 
  private:
   UnderlyingRotationTypeChecker(OffsetRotationType underlying_rotation_type)
       : underlying_rotation_type_(underlying_rotation_type) {}
 
   OffsetRotationType underlying_rotation_type_;
 };
 
 class InheritedRotationTypeChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedRotationTypeChecker> Create(
       OffsetRotationType inherited_rotation_type) {
     return WTF::WrapUnique(
         new InheritedRotationTypeChecker(inherited_rotation_type));
   }
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
-    return inherited_rotation_type_ ==
-           environment.GetState().ParentStyle()->OffsetRotate().type;
+    return inherited_rotation_type_ == state.ParentStyle()->OffsetRotate().type;
   }
 
  private:
   InheritedRotationTypeChecker(OffsetRotationType inherited_rotation_type)
       : inherited_rotation_type_(inherited_rotation_type) {}
 
   OffsetRotationType inherited_rotation_type_;
 };
 
 InterpolationValue ConvertOffsetRotate(const StyleOffsetRotation& rotation) {
@@ skipping 85 matching lines @@
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   state.Style()->SetOffsetRotate(StyleOffsetRotation(
       ToInterpolableNumber(interpolable_value).Value(),
       ToCSSOffsetRotationNonInterpolableValue(*non_interpolable_value)
           .RotationType()));
 }
 
 }  // namespace blink