Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSFilterListInterpolationType.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/CSSFilterListInterpolationType.h"
 
 #include <memory>
 #include "core/animation/FilterInterpolationFunctions.h"
 #include "core/animation/FilterListPropertyFunctions.h"
 #include "core/animation/ListInterpolationFunctions.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
 class UnderlyingFilterListChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<UnderlyingFilterListChecker> Create(
       PassRefPtr<NonInterpolableList> non_interpolable_list) {
     return WTF::WrapUnique(
         new UnderlyingFilterListChecker(std::move(non_interpolable_list)));
   }
 
-  bool IsValid(const InterpolationEnvironment&,
+  bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     const NonInterpolableList& underlying_non_interpolable_list =
         ToNonInterpolableList(*underlying.non_interpolable_value);
     if (non_interpolable_list_->length() !=
         underlying_non_interpolable_list.length())
       return false;
     for (size_t i = 0; i < non_interpolable_list_->length(); i++) {
       if (!FilterInterpolationFunctions::FiltersAreCompatible(
               *non_interpolable_list_->Get(i),
               *underlying_non_interpolable_list.Get(i)))
         return false;
     }
     return true;
   }
 
  private:
   UnderlyingFilterListChecker(
       PassRefPtr<NonInterpolableList> non_interpolable_list)
       : non_interpolable_list_(std::move(non_interpolable_list)) {}
 
   RefPtr<NonInterpolableList> non_interpolable_list_;
 };
 
-class InheritedFilterListChecker : public InterpolationType::ConversionChecker {
+class InheritedFilterListChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedFilterListChecker> Create(
       CSSPropertyID property,
       const FilterOperations& filter_operations) {
     return WTF::WrapUnique(
         new InheritedFilterListChecker(property, filter_operations));
   }
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
     const FilterOperations& filter_operations =
         filter_operations_wrapper_->Operations();
-    return filter_operations ==
-           FilterListPropertyFunctions::GetFilterList(
-               property_, *environment.GetState().ParentStyle());
+    return filter_operations == FilterListPropertyFunctions::GetFilterList(
+                                    property_, *state.ParentStyle());
   }
 
  private:
   InheritedFilterListChecker(CSSPropertyID property,
                              const FilterOperations& filter_operations)
       : property_(property),
         filter_operations_wrapper_(
             FilterOperationsWrapper::Create(filter_operations)) {}
 
   const CSSPropertyID property_;
@@ skipping 213 matching lines @@
   for (size_t i = 0; i < length; i++) {
     filter_operations.Operations().push_back(
         FilterInterpolationFunctions::CreateFilter(
             *interpolable_list.Get(i), *non_interpolable_list.Get(i), state));
   }
   FilterListPropertyFunctions::SetFilterList(CssProperty(), *state.Style(),
                                              std::move(filter_operations));
 }
 
 }  // namespace blink