Add CSSInterpolationType specific ConversionChecker

third_party/WebKit/Source/core/animation/CSSInterpolationType.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/CSSInterpolationType.h"
 
 #include <memory>
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSValue.h"
 #include "core/css/CSSVariableReferenceValue.h"
 #include "core/css/ComputedStyleCSSValueMapping.h"
 #include "core/css/PropertyRegistration.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/resolver/CSSVariableResolver.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/DataEquivalency.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
-class ResolvedVariableChecker : public InterpolationType::ConversionChecker {
+class ResolvedVariableChecker
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<ResolvedVariableChecker> Create(
       CSSPropertyID property,
       const CSSValue* variable_reference,
       const CSSValue* resolved_value) {
     return WTF::WrapUnique(new ResolvedVariableChecker(
         property, variable_reference, resolved_value));
   }
 
  private:
   ResolvedVariableChecker(CSSPropertyID property,
                           const CSSValue* variable_reference,
                           const CSSValue* resolved_value)
       : property_(property),
         variable_reference_(variable_reference),
         resolved_value_(resolved_value) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     // TODO(alancutter): Just check the variables referenced instead of doing a
     // full CSSValue resolve.
     bool omit_animation_tainted = false;
     const CSSValue* resolved_value =
         CSSVariableResolver::ResolveVariableReferences(
-            environment.GetState(), property_, *variable_reference_,
-            omit_animation_tainted);
+            state, property_, *variable_reference_, omit_animation_tainted);
     return DataEquivalent(resolved_value_.Get(), resolved_value);
   }
 
   CSSPropertyID property_;
   Persistent<const CSSValue> variable_reference_;
   Persistent<const CSSValue> resolved_value_;
 };
 
 class InheritedCustomPropertyChecker
-    : public InterpolationType::ConversionChecker {
+    : public CSSInterpolationType::CSSConversionChecker {
  public:
   static std::unique_ptr<InheritedCustomPropertyChecker> Create(
       const AtomicString& property,
       bool is_inherited_property,
       const CSSValue* inherited_value,
       const CSSValue* initial_value) {
     return WTF::WrapUnique(new InheritedCustomPropertyChecker(
         property, is_inherited_property, inherited_value, initial_value));
   }
 
  private:
   InheritedCustomPropertyChecker(const AtomicString& name,
                                  bool is_inherited_property,
                                  const CSSValue* inherited_value,
                                  const CSSValue* initial_value)
       : name_(name),
         is_inherited_property_(is_inherited_property),
         inherited_value_(inherited_value),
         initial_value_(initial_value) {}
 
-  bool IsValid(const InterpolationEnvironment& environment,
+  bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
     const CSSValue* inherited_value =
-        environment.GetState().ParentStyle()->GetRegisteredVariable(
-            name_, is_inherited_property_);
+        state.ParentStyle()->GetRegisteredVariable(name_,
+                                                   is_inherited_property_);
     if (!inherited_value) {
       inherited_value = initial_value_.Get();
     }
     return DataEquivalent(inherited_value_.Get(), inherited_value);
   }
 
   const AtomicString& name_;
   const bool is_inherited_property_;
   Persistent<const CSSValue> inherited_value_;
   Persistent<const CSSValue> initial_value_;
@@ skipping 210 matching lines @@
   if (registration_->Inherits()) {
     style.SetResolvedInheritedVariable(property_name, std::move(variable_data),
                                        css_value);
   } else {
     style.SetResolvedNonInheritedVariable(property_name,
                                           std::move(variable_data), css_value);
   }
 }
 
 }  // namespace blink