Pass InterpolationEnvironment as a reference to InterpolationType conversion functions

third_party/WebKit/Source/core/animation/InvalidatableInterpolation.cpp

 // Copyright 2015 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 "config.h"
 #include "core/animation/InvalidatableInterpolation.h"
 
 #include "core/animation/InterpolationEnvironment.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/resolver/StyleResolverState.h"
 
 namespace blink {
 
 void InvalidatableInterpolation::interpolate(int, double fraction)
 {
     if (fraction == m_currentFraction)
         return;
 
     if (m_currentFraction == 0 || m_currentFraction == 1 || fraction == 0 || fraction == 1)
         clearCache();
 
     m_currentFraction = fraction;
     if (m_isCached && m_cachedPairConversion)
         m_cachedPairConversion->interpolateValue(fraction, m_cachedValue);
     // We defer the interpolation to ensureValidInterpolation() if m_cachedPairConversion is null.
 }
 
-PassOwnPtr<PairwisePrimitiveInterpolation> InvalidatableInterpolation::maybeConvertPairwise(const InterpolationEnvironment* environment, const UnderlyingValue& underlyingValue) const
+PassOwnPtr<PairwisePrimitiveInterpolation> InvalidatableInterpolation::maybeConvertPairwise(const InterpolationEnvironment& environment, const UnderlyingValue& underlyingValue) const
 {
     ASSERT(m_currentFraction != 0 && m_currentFraction != 1);
     for (const auto& interpolationType : m_interpolationTypes) {
         if ((m_startKeyframe->isNeutral() || m_endKeyframe->isNeutral()) && (!underlyingValue || underlyingValue->type() != *interpolationType))
             continue;
         OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = interpolationType->maybeConvertPairwise(*m_startKeyframe, *m_endKeyframe, environment, underlyingValue, m_conversionCheckers);
         if (pairwiseConversion) {
             ASSERT(pairwiseConversion->type() == *interpolationType);
             return pairwiseConversion.release();
         }
     }
     return nullptr;
 }
 
 PassOwnPtr<InterpolationValue> InvalidatableInterpolation::convertSingleKeyframe(const PropertySpecificKeyframe& keyframe, const InterpolationEnvironment& environment, const UnderlyingValue& underlyingValue) const
 {
     if (keyframe.isNeutral() && !underlyingValue)
         return nullptr;
     for (const auto& interpolationType : m_interpolationTypes) {
         if (keyframe.isNeutral() && underlyingValue->type() != *interpolationType)
             continue;
-        OwnPtr<InterpolationValue> result = interpolationType->maybeConvertSingle(keyframe, &environment, underlyingValue, m_conversionCheckers);
+        OwnPtr<InterpolationValue> result = interpolationType->maybeConvertSingle(keyframe, environment, underlyingValue, m_conversionCheckers);
         if (result) {
             ASSERT(result->type() == *interpolationType);
             return result.release();
         }
     }
     ASSERT(keyframe.isNeutral());
     return nullptr;
 }
 
 PassOwnPtr<InterpolationValue> InvalidatableInterpolation::maybeConvertUnderlyingValue(const InterpolationEnvironment& environment) const
@@ skipping 46 matching lines @@
 {
     ASSERT(!std::isnan(m_currentFraction));
     if (isCacheValid(environment, underlyingValue))
         return m_cachedValue.get();
     clearCache();
     if (m_currentFraction == 0) {
         m_cachedValue = convertSingleKeyframe(*m_startKeyframe, environment, underlyingValue);
     } else if (m_currentFraction == 1) {
         m_cachedValue = convertSingleKeyframe(*m_endKeyframe, environment, underlyingValue);
     } else {
-        OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = maybeConvertPairwise(&environment, underlyingValue);
+        OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = maybeConvertPairwise(environment, underlyingValue);
         if (pairwiseConversion) {
             m_cachedValue = pairwiseConversion->initialValue();
             m_cachedPairConversion = pairwiseConversion.release();
         } else {
             m_cachedPairConversion = FlipPrimitiveInterpolation::create(
                 convertSingleKeyframe(*m_startKeyframe, environment, underlyingValue),
                 convertSingleKeyframe(*m_endKeyframe, environment, underlyingValue));
         }
         m_cachedPairConversion->interpolateValue(m_currentFraction, m_cachedValue);
     }
@@ skipping 63 matching lines @@
             underlyingValue.set(currentValue);
         else
             currentValue->type().composite(underlyingValue, underlyingFraction, *currentValue);
     }
 
     if (shouldApply && underlyingValue)
         underlyingValue->type().apply(underlyingValue->interpolableValue(), underlyingValue->nonInterpolableValue(), environment);
 }
 
 } // namespace blink