Make InterpolationEnvironment virutal

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/CSSInterpolationEnvironment.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"
@@ skipping 102 matching lines @@
   }
   return result;
 }
 
 InterpolationValue CSSInterpolationType::MaybeConvertSingleInternal(
     const PropertySpecificKeyframe& keyframe,
     const InterpolationEnvironment& environment,
     const InterpolationValue& underlying,
     ConversionCheckers& conversion_checkers) const {
   const CSSValue* value = ToCSSPropertySpecificKeyframe(keyframe).Value();
-  const StyleResolverState& state = environment.GetState();
+  const StyleResolverState& state =
+      ToCSSInterpolationEnvironment(environment).GetState();
 
   if (!value)
     return MaybeConvertNeutral(underlying, conversion_checkers);
 
   if (GetProperty().IsCSSCustomProperty()) {
     return MaybeConvertCustomPropertyDeclaration(
         ToCSSCustomPropertyDeclaration(*value), state, conversion_checkers);
   }
 
   if (value->IsVariableReferenceValue() ||
@@ skipping 94 matching lines @@
     if (parsed_value) {
       return MaybeConvertValue(*parsed_value, &state, conversion_checkers);
     }
   }
 
   return nullptr;
 }
 
 InterpolationValue CSSInterpolationType::MaybeConvertUnderlyingValue(
     const InterpolationEnvironment& environment) const {
-  const ComputedStyle& style = environment.Style();
+  const ComputedStyle& style =
+      ToCSSInterpolationEnvironment(environment).Style();
   if (!GetProperty().IsCSSCustomProperty()) {
     return MaybeConvertStandardPropertyUnderlyingValue(style);
   }
 
   const PropertyHandle property = GetProperty();
   const AtomicString& name = property.CustomPropertyName();
   if (!registration_) {
     return nullptr;
   }
   const CSSValue* underlying_value =
       style.GetRegisteredVariable(name, registration_->Inherits());
   if (!underlying_value) {
     underlying_value = registration_->Initial();
   }
   if (!underlying_value) {
     return nullptr;
   }
   // TODO(alancutter): Remove the need for passing in conversion checkers.
   ConversionCheckers dummy_conversion_checkers;
   return MaybeConvertValue(*underlying_value, nullptr,
                            dummy_conversion_checkers);
 }
 
 void CSSInterpolationType::Apply(
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     InterpolationEnvironment& environment) const {
-  StyleResolverState& state = environment.GetState();
+  StyleResolverState& state =
+      ToCSSInterpolationEnvironment(environment).GetState();
 
   if (GetProperty().IsCSSCustomProperty()) {
     ApplyCustomPropertyValue(interpolable_value, non_interpolable_value, state);
     return;
   }
   ApplyStandardPropertyValue(interpolable_value, non_interpolable_value, state);
 }
 
 void CSSInterpolationType::ApplyCustomPropertyValue(
     const InterpolableValue& interpolable_value,
@@ skipping 22 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