Oilpan: Unship oilpan from temporary animation objects

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"
 #include "core/css/resolver/StyleResolverState.h"
 
@@ skipping 10 matching lines @@
 {
     maybeCachePairwiseConversion(nullptr, nullptr);
     interpolate(0, 0);
 }
 
 bool InvalidatableStyleInterpolation::maybeCachePairwiseConversion(const StyleResolverState* state, const InterpolationValue* underlyingValue) const
 {
     for (const auto& interpolationType : m_interpolationTypes) {
         if ((m_startKeyframe->isNeutral() || m_endKeyframe->isNeutral()) && (!underlyingValue || underlyingValue->type() != *interpolationType))
             continue;
-        OwnPtrWillBeRawPtr<PairwisePrimitiveInterpolation> pairwiseConversion = interpolationType->maybeConvertPairwise(*m_startKeyframe, *m_endKeyframe, state, m_conversionCheckers);
+        OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = interpolationType->maybeConvertPairwise(*m_startKeyframe, *m_endKeyframe, state, m_conversionCheckers);
         if (pairwiseConversion) {
             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->interpolateValue(fraction, m_cachedValue);
     // We defer the interpolation to ensureValidInterpolation() if m_cachedConversion is null.
 }
 
-PassOwnPtrWillBeRawPtr<InterpolationValue> InvalidatableStyleInterpolation::convertSingleKeyframe(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState& state, const InterpolationValue* underlyingValue) const
+PassOwnPtr<InterpolationValue> InvalidatableStyleInterpolation::convertSingleKeyframe(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState& state, const InterpolationValue* underlyingValue) const
 {
     if (keyframe.isNeutral() && !underlyingValue)
         return nullptr;
     for (const auto& interpolationType : m_interpolationTypes) {
         if (keyframe.isNeutral() && underlyingValue->type() != *interpolationType)
             continue;
-        OwnPtrWillBeRawPtr<InterpolationValue> result = interpolationType->maybeConvertSingle(keyframe, &state, m_conversionCheckers);
+        OwnPtr<InterpolationValue> result = interpolationType->maybeConvertSingle(keyframe, &state, m_conversionCheckers);
         if (result)
             return result.release();
     }
     ASSERT(keyframe.isNeutral());
     return nullptr;
 }
 
-PassOwnPtrWillBeRawPtr<InterpolationValue> InvalidatableStyleInterpolation::maybeConvertUnderlyingValue(const StyleResolverState& state) const
+PassOwnPtr<InterpolationValue> InvalidatableStyleInterpolation::maybeConvertUnderlyingValue(const StyleResolverState& state) const
 {
     for (const auto& interpolationType : m_interpolationTypes) {
-        OwnPtrWillBeRawPtr<InterpolationValue> result = interpolationType->maybeConvertUnderlyingValue(state);
+        OwnPtr<InterpolationValue> result = interpolationType->maybeConvertUnderlyingValue(state);
         if (result)
             return result.release();
     }
     return nullptr;
 }
 
 bool InvalidatableStyleInterpolation::dependsOnUnderlyingValue() const
 {
     return (m_startKeyframe->underlyingFraction() != 0 && m_currentFraction != 1) || (m_endKeyframe->underlyingFraction() != 0 && m_currentFraction != 0);
 }
@@ skipping 37 matching lines @@
     if (!state.parentStyle())
         return;
     if ((m_startKeyframe->value() && m_startKeyframe->value()->isInheritedValue())
         || (m_endKeyframe->value() && m_endKeyframe->value()->isInheritedValue())) {
         state.parentStyle()->setHasExplicitlyInheritedProperties();
     }
 }
 
 void InvalidatableStyleInterpolation::apply(StyleResolverState& state) const
 {
-    OwnPtrWillBeRawPtr<InterpolationValue> underlyingValue = dependsOnUnderlyingValue() ? maybeConvertUnderlyingValue(state) : nullptr;
+    OwnPtr<InterpolationValue> underlyingValue = dependsOnUnderlyingValue() ? maybeConvertUnderlyingValue(state) : nullptr;
     ensureValidInterpolation(state, underlyingValue.get());
     if (!m_cachedValue)
         return;
     const InterpolableValue* appliedInterpolableValue = &m_cachedValue->interpolableValue();
     if (underlyingValue && m_cachedValue->type() == underlyingValue->type()) {
         double underlyingFraction = m_cachedConversion->interpolateUnderlyingFraction(m_startKeyframe->underlyingFraction(), m_endKeyframe->underlyingFraction(), m_currentFraction);
         underlyingValue->interpolableValue().scaleAndAdd(underlyingFraction, m_cachedValue->interpolableValue());
         appliedInterpolableValue = &underlyingValue->interpolableValue();
     }
     m_cachedValue->type().apply(*appliedInterpolableValue, m_cachedValue->nonInterpolableValue(), state);
     setFlagIfInheritUsed(state);
 }
 
 } // namespace blink