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

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

 // Copyright 2016 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/PathInterpolationFunctions.h"
 
 #include "core/animation/InterpolatedSVGPathSource.h"
 #include "core/animation/InterpolationEnvironment.h"
 #include "core/animation/SVGPathSegInterpolationFunctions.h"
 #include "core/css/CSSPathValue.h"
@@ skipping 45 matching lines @@
 
     while (pathSource.hasMoreData()) {
         const PathSegmentData segment = pathSource.parseSegment();
         interpolablePathSegs.append(SVGPathSegInterpolationFunctions::consumePathSeg(segment, currentCoordinates));
         pathSegTypes.append(segment.command);
         length++;
     }
 
     OwnPtr<InterpolableList> pathArgs = InterpolableList::create(length);
     for (size_t i = 0; i < interpolablePathSegs.size(); i++)
-        pathArgs->set(i, interpolablePathSegs[i].release());
+        pathArgs->set(i, std::move(interpolablePathSegs[i]));
 
     OwnPtr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
-    result->set(PathArgsIndex, pathArgs.release());
+    result->set(PathArgsIndex, std::move(pathArgs));
     result->set(PathNeutralIndex, InterpolableNumber::create(0));
 
-    return InterpolationValue(result.release(), SVGPathNonInterpolableValue::create(pathSegTypes));
+    return InterpolationValue(std::move(result), SVGPathNonInterpolableValue::create(pathSegTypes));
 }
 
 InterpolationValue PathInterpolationFunctions::convertValue(const StylePath* stylePath)
 {
     if (stylePath)
         return convertValue(stylePath->byteStream());
 
     OwnPtr<SVGPathByteStream> emptyPath = SVGPathByteStream::create();
     return convertValue(*emptyPath);
 }
@@ skipping 24 matching lines @@
 
     Vector<SVGPathSegType> m_pathSegTypes;
 };
 
 InterpolationValue PathInterpolationFunctions::maybeConvertNeutral(const InterpolationValue& underlying, InterpolationType::ConversionCheckers& conversionCheckers)
 {
     conversionCheckers.append(UnderlyingPathSegTypesChecker::create(underlying));
     OwnPtr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
     result->set(PathArgsIndex, toInterpolableList(*underlying.interpolableValue).get(PathArgsIndex)->cloneAndZero());
     result->set(PathNeutralIndex, InterpolableNumber::create(1));
-    return InterpolationValue(result.release(), underlying.nonInterpolableValue.get());
+    return InterpolationValue(std::move(result), underlying.nonInterpolableValue.get());
 }
 
 static bool pathSegTypesMatch(const Vector<SVGPathSegType>& a, const Vector<SVGPathSegType>& b)
 {
     if (a.size() != b.size())
         return false;
 
     for (size_t i = 0; i < a.size(); i++) {
         if (toAbsolutePathSegType(a[i]) != toAbsolutePathSegType(b[i]))
             return false;
     }
 
     return true;
 }
 
 PairwiseInterpolationValue PathInterpolationFunctions::maybeMergeSingles(InterpolationValue&& start, InterpolationValue&& end)
 {
     const Vector<SVGPathSegType>& startTypes = toSVGPathNonInterpolableValue(*start.nonInterpolableValue).pathSegTypes();
     const Vector<SVGPathSegType>& endTypes = toSVGPathNonInterpolableValue(*end.nonInterpolableValue).pathSegTypes();
     if (!pathSegTypesMatch(startTypes, endTypes))
         return nullptr;
 
-    return PairwiseInterpolationValue(start.interpolableValue.release(), end.interpolableValue.release(), end.nonInterpolableValue.release());
+    return PairwiseInterpolationValue(std::move(start.interpolableValue), std::move(end.interpolableValue), end.nonInterpolableValue.release());
 }
 
 void PathInterpolationFunctions::composite(UnderlyingValueOwner& underlyingValueOwner, double underlyingFraction, const InterpolationType& type, const InterpolationValue& value)
 {
     const InterpolableList& list = toInterpolableList(*value.interpolableValue);
     double neutralComponent = toInterpolableNumber(list.get(PathNeutralIndex))->value();
 
     if (neutralComponent == 0) {
         underlyingValueOwner.set(type, value);
         return;
     }
 
     ASSERT(pathSegTypesMatch(
         toSVGPathNonInterpolableValue(*underlyingValueOwner.value().nonInterpolableValue).pathSegTypes(),
         toSVGPathNonInterpolableValue(*value.nonInterpolableValue).pathSegTypes()));
     underlyingValueOwner.mutableValue().interpolableValue->scaleAndAdd(neutralComponent, *value.interpolableValue);
     underlyingValueOwner.mutableValue().nonInterpolableValue = value.nonInterpolableValue.get();
 }
 
 PassOwnPtr<SVGPathByteStream> PathInterpolationFunctions::appliedValue(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue)
 {
     OwnPtr<SVGPathByteStream> pathByteStream = SVGPathByteStream::create();
     InterpolatedSVGPathSource source(
         toInterpolableList(*toInterpolableList(interpolableValue).get(PathArgsIndex)),
         toSVGPathNonInterpolableValue(nonInterpolableValue)->pathSegTypes());
     SVGPathByteStreamBuilder builder(*pathByteStream);
     SVGPathParser::parsePath(source, builder);
-    return pathByteStream.release();
+    return pathByteStream;
 }
 
 } // namespace blink