Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSVisibilityInterpolationType.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/CSSVisibilityInterpolationType.h"
 
 #include <memory>
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "platform/wtf/PtrUtil.h"
@@ skipping 31 matching lines @@
 
   const EVisibility start_;
   const EVisibility end_;
   const bool is_single_;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(CSSVisibilityNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(CSSVisibilityNonInterpolableValue);
 
 class UnderlyingVisibilityChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   ~UnderlyingVisibilityChecker() final {}
 
   static std::unique_ptr<UnderlyingVisibilityChecker> Create(
       EVisibility visibility) {
     return WTF::WrapUnique(new UnderlyingVisibilityChecker(visibility));
   }
 
  private:
   UnderlyingVisibilityChecker(EVisibility visibility)
       : visibility_(visibility) {}
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     double underlying_fraction =
         ToInterpolableNumber(*underlying.interpolable_value).Value();
     EVisibility underlying_visibility =
         ToCSSVisibilityNonInterpolableValue(*underlying.non_interpolable_value)
             .Visibility(underlying_fraction);
     return visibility_ == underlying_visibility;
   }
 
   const EVisibility visibility_;
 };
 
-class InheritedVisibilityChecker : public InterpolationType::ConversionChecker {
+class InheritedVisibilityChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedVisibilityChecker> Create(
       EVisibility visibility) {
     return WTF::WrapUnique(new InheritedVisibilityChecker(visibility));
   }
 
  private:
   InheritedVisibilityChecker(EVisibility visibility)
       : visibility_(visibility) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
-    return visibility_ == environment.GetState().ParentStyle()->Visibility();
+    return visibility_ == state.ParentStyle()->Visibility();
   }
 
   const EVisibility visibility_;
 };
 
 InterpolationValue CSSVisibilityInterpolationType::CreateVisibilityValue(
     EVisibility visibility) const {
   return InterpolationValue(
       InterpolableNumber::Create(0),
       CSSVisibilityNonInterpolableValue::Create(visibility, visibility));
@@ skipping 92 matching lines @@
   // Visibility interpolation has been deferred to application time here due to
   // its non-linear behaviour.
   double fraction = ToInterpolableNumber(interpolable_value).Value();
   EVisibility visibility =
       ToCSSVisibilityNonInterpolableValue(non_interpolable_value)
           ->Visibility(fraction);
   state.Style()->SetVisibility(visibility);
 }
 
 }  // namespace blink