Move AnimationValue onto the heap

Source/core/animation/InvalidatableStyleInterpolation.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/InvalidatableStyleInterpolation.h"
 
 #include "core/animation/StringKeyframe.h"
 
 namespace blink {
 
 InvalidatableStyleInterpolation::InvalidatableStyleInterpolation(
     const Vector<const AnimationType*>& animationTypes,
     const CSSPropertySpecificKeyframe& startKeyframe,
     const CSSPropertySpecificKeyframe& endKeyframe)
     : StyleInterpolation(nullptr, nullptr, animationTypes.first()->property())
     , m_animationTypes(animationTypes)
     , m_startKeyframe(startKeyframe)
     , m_endKeyframe(endKeyframe)
 {
     maybeCachePairwiseConversion(nullptr);
     interpolate(0, 0);
 }
 
 bool InvalidatableStyleInterpolation::maybeCachePairwiseConversion(const StyleResolverState* state) const
 {
     for (const auto& animationType : m_animationTypes) {
         OwnPtrWillBeRawPtr<PairwisePrimitiveInterpolation> pairwiseConversion = animationType->maybeConvertPairwise(m_startKeyframe, m_endKeyframe, state, m_conversionCheckers);
         if (pairwiseConversion) {
-            m_cachedValue.type = animationType;
-            pairwiseConversion->initializeAnimationValue(m_cachedValue);
+            m_cachedValue = pairwiseConversion->initialValue();
             m_cachedConversion = pairwiseConversion.release();
             return true;
         }
     }
     return false;
 }
 
 void InvalidatableStyleInterpolation::interpolate(int, double fraction)
 {
     m_currentFraction = fraction;
     if (m_cachedConversion)
         m_cachedConversion->interpolate(fraction, m_cachedValue);
     // We defer the interpolation to ensureValidInterpolation() if m_cachedConversion is null.
 }
 
-PassOwnPtrWillBeRawPtr<FlipPrimitiveInterpolation::Side> InvalidatableStyleInterpolation::convertSingleKeyframe(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState& state) const
+PassOwnPtrWillBeRawPtr<AnimationValue> InvalidatableStyleInterpolation::convertSingleKeyframe(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState& state) const
 {
     for (const auto& animationType : m_animationTypes) {
-        OwnPtrWillBeRawPtr<FlipPrimitiveInterpolation::Side> result = animationType->maybeConvertSingle(keyframe, &state, m_conversionCheckers);
+        OwnPtrWillBeRawPtr<AnimationValue> result = animationType->maybeConvertSingle(keyframe, &state, m_conversionCheckers);
         if (result)
             return result.release();
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 bool InvalidatableStyleInterpolation::isCacheValid(const StyleResolverState& state) const
 {
     for (const auto& checker : m_conversionCheckers) {
@@ skipping 12 matching lines @@
         m_cachedConversion = FlipPrimitiveInterpolation::create(
             convertSingleKeyframe(m_startKeyframe, state),
             convertSingleKeyframe(m_endKeyframe, state));
     }
     m_cachedConversion->interpolate(m_currentFraction, m_cachedValue);
 }
 
 void InvalidatableStyleInterpolation::apply(StyleResolverState& state) const
 {
     ensureValidInterpolation(state);
-    m_cachedValue.type->apply(*m_cachedValue.interpolableValue, m_cachedValue.nonInterpolableValue.get(), state);
+    m_cachedValue->type().apply(m_cachedValue->interpolableValue(), m_cachedValue->nonInterpolableValue(), state);
 }
 
 } // namespace blink