Remove OwnPtr::release() calls in core/ (part 1).

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 "core/animation/InvalidatableInterpolation.h"
 
 #include "core/animation/InterpolationEnvironment.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/resolver/StyleResolverState.h"
 
@@ skipping 17 matching lines @@
 {
     ASSERT(m_currentFraction != 0 && m_currentFraction != 1);
     for (const auto& interpolationType : m_interpolationTypes) {
         if ((m_startKeyframe->isNeutral() || m_endKeyframe->isNeutral()) && (!underlyingValueOwner || underlyingValueOwner.type() != *interpolationType))
             continue;
         ConversionCheckers conversionCheckers;
         PairwiseInterpolationValue result = interpolationType->maybeConvertPairwise(*m_startKeyframe, *m_endKeyframe, environment, underlyingValueOwner.value(), conversionCheckers);
         addConversionCheckers(*interpolationType, conversionCheckers);
         if (result) {
             return PairwisePrimitiveInterpolation::create(*interpolationType,
-                result.startInterpolableValue.release(),
-                result.endInterpolableValue.release(),
+                std::move(result.startInterpolableValue),
+                std::move(result.endInterpolableValue),
                 result.nonInterpolableValue.release());
         }
     }
     return nullptr;
 }
 
 PassOwnPtr<TypedInterpolationValue> InvalidatableInterpolation::convertSingleKeyframe(const PropertySpecificKeyframe& keyframe, const InterpolationEnvironment& environment, const UnderlyingValueOwner& underlyingValueOwner) const
 {
     if (keyframe.isNeutral() && !underlyingValueOwner)
         return nullptr;
     for (const auto& interpolationType : m_interpolationTypes) {
         if (keyframe.isNeutral() && underlyingValueOwner.type() != *interpolationType)
             continue;
         ConversionCheckers conversionCheckers;
         InterpolationValue result = interpolationType->maybeConvertSingle(keyframe, environment, underlyingValueOwner.value(), conversionCheckers);
         addConversionCheckers(*interpolationType, conversionCheckers);
         if (result)
-            return TypedInterpolationValue::create(*interpolationType, result.interpolableValue.release(), result.nonInterpolableValue.release());
+            return TypedInterpolationValue::create(*interpolationType, std::move(result.interpolableValue), result.nonInterpolableValue.release());
     }
     ASSERT(keyframe.isNeutral());
     return nullptr;
 }
 
 void InvalidatableInterpolation::addConversionCheckers(const InterpolationType& type, ConversionCheckers& conversionCheckers) const
 {
     for (size_t i = 0; i < conversionCheckers.size(); i++) {
         conversionCheckers[i]->setType(type);
-        m_conversionCheckers.append(conversionCheckers[i].release());
+        m_conversionCheckers.append(std::move(conversionCheckers[i]));
     }
 }
 
 PassOwnPtr<TypedInterpolationValue> InvalidatableInterpolation::maybeConvertUnderlyingValue(const InterpolationEnvironment& environment) const
 {
     for (const auto& interpolationType : m_interpolationTypes) {
         InterpolationValue result = interpolationType->maybeConvertUnderlyingValue(environment);
         if (result)
-            return TypedInterpolationValue::create(*interpolationType, result.interpolableValue.release(), result.nonInterpolableValue.release());
+            return TypedInterpolationValue::create(*interpolationType, std::move(result.interpolableValue), result.nonInterpolableValue.release());
     }
     return nullptr;
 }
 
 bool InvalidatableInterpolation::dependsOnUnderlyingValue() const
 {
     return (m_startKeyframe->underlyingFraction() != 0 && m_currentFraction != 1) || (m_endKeyframe->underlyingFraction() != 0 && m_currentFraction != 0);
 }
 
 bool InvalidatableInterpolation::isNeutralKeyframeActive() const
@@ skipping 34 matching lines @@
         return m_cachedValue.get();
     clearCache();
     if (m_currentFraction == 0) {
         m_cachedValue = convertSingleKeyframe(*m_startKeyframe, environment, underlyingValueOwner);
     } else if (m_currentFraction == 1) {
         m_cachedValue = convertSingleKeyframe(*m_endKeyframe, environment, underlyingValueOwner);
     } else {
         OwnPtr<PairwisePrimitiveInterpolation> pairwiseConversion = maybeConvertPairwise(environment, underlyingValueOwner);
         if (pairwiseConversion) {
             m_cachedValue = pairwiseConversion->initialValue();
-            m_cachedPairConversion = pairwiseConversion.release();
+            m_cachedPairConversion = std::move(pairwiseConversion);
         } else {
             m_cachedPairConversion = FlipPrimitiveInterpolation::create(
                 convertSingleKeyframe(*m_startKeyframe, environment, underlyingValueOwner),
                 convertSingleKeyframe(*m_endKeyframe, environment, underlyingValueOwner));
         }
         m_cachedPairConversion->interpolateValue(m_currentFraction, m_cachedValue);
     }
     m_isCached = true;
     return m_cachedValue.get();
 }
@@ skipping 60 matching lines @@
             underlyingValueOwner.set(currentValue);
         else
             currentValue->type().composite(underlyingValueOwner, underlyingFraction, currentValue->value(), currentInterpolation.m_currentFraction);
     }
 
     if (shouldApply && underlyingValueOwner)
         underlyingValueOwner.type().apply(*underlyingValueOwner.value().interpolableValue, underlyingValueOwner.value().nonInterpolableValue.get(), environment);
 }
 
 } // namespace blink