Replaced RefPtr::release with std::move in Source/core.

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"
 #include <memory>
@@ skipping 28 matching lines @@
       continue;
     ConversionCheckers conversionCheckers;
     PairwiseInterpolationValue result = interpolationType->maybeConvertPairwise(
         *m_startKeyframe, *m_endKeyframe, environment,
         underlyingValueOwner.value(), conversionCheckers);
     addConversionCheckers(*interpolationType, conversionCheckers);
     if (result) {
       return PairwisePrimitiveInterpolation::create(
           *interpolationType, std::move(result.startInterpolableValue),
           std::move(result.endInterpolableValue),
-          result.nonInterpolableValue.release());
+          std::move(result.nonInterpolableValue));
     }
   }
   return nullptr;
 }
 
 std::unique_ptr<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)
+    if (result) {
       return TypedInterpolationValue::create(
           *interpolationType, std::move(result.interpolableValue),
-          result.nonInterpolableValue.release());
+          std::move(result.nonInterpolableValue));
+    }
   }
   DCHECK(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.push_back(std::move(conversionCheckers[i]));
   }
 }
 
 std::unique_ptr<TypedInterpolationValue>
 InvalidatableInterpolation::maybeConvertUnderlyingValue(
     const InterpolationEnvironment& environment) const {
   for (const auto& interpolationType : *m_interpolationTypes) {
     InterpolationValue result =
         interpolationType->maybeConvertUnderlyingValue(environment);
-    if (result)
+    if (result) {
       return TypedInterpolationValue::create(
           *interpolationType, std::move(result.interpolableValue),
-          result.nonInterpolableValue.release());
+          std::move(result.nonInterpolableValue));
+    }
   }
   return nullptr;
 }
 
 bool InvalidatableInterpolation::dependsOnUnderlyingValue() const {
   return (m_startKeyframe->underlyingFraction() != 0 &&
           m_currentFraction != 1) ||
          (m_endKeyframe->underlyingFraction() != 0 && m_currentFraction != 0);
 }
 
@@ skipping 164 matching lines @@
                                      currentInterpolation.m_currentFraction);
   }
 
   if (shouldApply && underlyingValueOwner)
     underlyingValueOwner.type().apply(
         *underlyingValueOwner.value().interpolableValue,
         underlyingValueOwner.value().nonInterpolableValue.get(), environment);
 }
 
 }  // namespace blink