Add ComputedStyle constructor and getter to InterpolationEnvironment

third_party/WebKit/Source/core/animation/CSSImageSliceInterpolationType.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/CSSImageSliceInterpolationType.h"
 
 #include "core/animation/CSSLengthInterpolationType.h"
 #include "core/animation/ImageSlicePropertyFunctions.h"
 #include "core/css/CSSBorderImageSliceValue.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 178 matching lines @@
         const CSSPrimitiveValue& side = *sides[i];
         ASSERT_UNUSED(side, side.isNumber() || side.isPercentage());
         list->set(i, InterpolableNumber::create(sides[i]->getDoubleValue()));
     }
 
     return InterpolationValue(std::move(list), CSSImageSliceNonInterpolableValue::create(SliceTypes(slice)));
 }
 
 InterpolationValue CSSImageSliceInterpolationType::maybeConvertUnderlyingValue(const InterpolationEnvironment& environment) const
 {
-    const ComputedStyle& style = *environment.state().style();
+    const ComputedStyle& style = environment.style();
     return convertImageSlice(ImageSlicePropertyFunctions::getImageSlice(cssProperty(), style), style.effectiveZoom());
 }
 
 PairwiseInterpolationValue CSSImageSliceInterpolationType::maybeMergeSingles(InterpolationValue&& start, InterpolationValue&& end) const
 {
     const SliceTypes& startSliceTypes = toCSSImageSliceNonInterpolableValue(*start.nonInterpolableValue).types();
     const SliceTypes& endSliceTypes = toCSSImageSliceNonInterpolableValue(*end.nonInterpolableValue).types();
 
     if (startSliceTypes != endSliceTypes)
         return nullptr;
 
     return PairwiseInterpolationValue(std::move(start.interpolableValue), std::move(end.interpolableValue), start.nonInterpolableValue.release());
 }
 
 void CSSImageSliceInterpolationType::composite(UnderlyingValueOwner& underlyingValueOwner, double underlyingFraction, const InterpolationValue& value, double interpolationFraction) const
 {
     const SliceTypes& underlyingTypes = toCSSImageSliceNonInterpolableValue(*underlyingValueOwner.value().nonInterpolableValue).types();
     const SliceTypes& types = toCSSImageSliceNonInterpolableValue(*value.nonInterpolableValue).types();
 
     if (underlyingTypes == types)
         underlyingValueOwner.mutableValue().interpolableValue->scaleAndAdd(underlyingFraction, *value.interpolableValue);
     else
         underlyingValueOwner.set(*this, value);
 }
 
 void CSSImageSliceInterpolationType::apply(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue, InterpolationEnvironment& environment) const
 {
-    ComputedStyle& style = *environment.state().style();
+    ComputedStyle& style = environment.style();
     const InterpolableList& list = toInterpolableList(interpolableValue);
     const SliceTypes& types = toCSSImageSliceNonInterpolableValue(nonInterpolableValue)->types();
     const auto& convertSide = [&types, &list, &style](size_t index)
     {
         float value = clampTo<float>(toInterpolableNumber(list.get(index))->value(), 0);
         return types.isNumber[index] ? Length(value * style.effectiveZoom(), Fixed) : Length(value, Percent);
     };
     LengthBox box(
         convertSide(SideTop),
         convertSide(SideRight),
         convertSide(SideBottom),
         convertSide(SideLeft));
     ImageSlicePropertyFunctions::setImageSlice(cssProperty(), style, ImageSlice(box, types.fill));
 }
 
 } // namespace blink