Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSFontSizeInterpolationType.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/CSSFontSizeInterpolationType.h"
 
 #include <memory>
 #include "core/animation/LengthInterpolationFunctions.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "platform/LengthFunctions.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
-class IsMonospaceChecker : public InterpolationType::ConversionChecker {
+class IsMonospaceChecker : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<IsMonospaceChecker> Create(bool is_monospace) {
     return WTF::WrapUnique(new IsMonospaceChecker(is_monospace));
   }
 
  private:
   IsMonospaceChecker(bool is_monospace) : is_monospace_(is_monospace) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
-    return is_monospace_ ==
-           environment.GetState().Style()->GetFontDescription().IsMonospace();
+    return is_monospace_ == state.Style()->GetFontDescription().IsMonospace();
   }
 
   const bool is_monospace_;
 };
 
-class InheritedFontSizeChecker : public InterpolationType::ConversionChecker {
+class InheritedFontSizeChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedFontSizeChecker> Create(
       const FontDescription::Size& inherited_font_size) {
     return WTF::WrapUnique(new InheritedFontSizeChecker(inherited_font_size));
   }
 
  private:
   InheritedFontSizeChecker(const FontDescription::Size& inherited_font_size)
       : inherited_font_size_(inherited_font_size.value) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
     return inherited_font_size_ ==
-           environment.GetState().ParentFontDescription().GetSize().value;
+           state.ParentFontDescription().GetSize().value;
   }
 
   const float inherited_font_size_;
 };
 
 InterpolationValue ConvertFontSize(float size) {
   return InterpolationValue(
       LengthInterpolationFunctions::CreateInterpolablePixels(size));
 }
 
@@ skipping 81 matching lines @@
       interpolable_value, nullptr, state.FontSizeConversionData(),
       kValueRangeNonNegative);
   float font_size =
       FloatValueForLength(font_size_length, parent_font.GetSize().value);
   state.GetFontBuilder().SetSize(FontDescription::Size(
       0, font_size,
       !font_size_length.IsPercentOrCalc() || parent_font.IsAbsoluteSize()));
 }
 
 }  // namespace blink