Revert "Remove OwnPtr from Blink."

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"
 #include "core/svg/SVGPath.h"
 #include "core/svg/SVGPathByteStreamBuilder.h"
 #include "core/svg/SVGPathByteStreamSource.h"
 #include "core/svg/SVGPathParser.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace blink {
 
 class SVGPathNonInterpolableValue : public NonInterpolableValue {
 public:
     virtual ~SVGPathNonInterpolableValue() {}
 
     static PassRefPtr<SVGPathNonInterpolableValue> create(Vector<SVGPathSegType>& pathSegTypes)
     {
         return adoptRef(new SVGPathNonInterpolableValue(pathSegTypes));
@@ skipping 19 matching lines @@
     PathArgsIndex,
     PathNeutralIndex,
     PathComponentIndexCount,
 };
 
 InterpolationValue PathInterpolationFunctions::convertValue(const SVGPathByteStream& byteStream)
 {
     SVGPathByteStreamSource pathSource(byteStream);
     size_t length = 0;
     PathCoordinates currentCoordinates;
-    Vector<std::unique_ptr<InterpolableValue>> interpolablePathSegs;
+    Vector<OwnPtr<InterpolableValue>> interpolablePathSegs;
     Vector<SVGPathSegType> pathSegTypes;
 
     while (pathSource.hasMoreData()) {
         const PathSegmentData segment = pathSource.parseSegment();
         interpolablePathSegs.append(SVGPathSegInterpolationFunctions::consumePathSeg(segment, currentCoordinates));
         pathSegTypes.append(segment.command);
         length++;
     }
 
-    std::unique_ptr<InterpolableList> pathArgs = InterpolableList::create(length);
+    OwnPtr<InterpolableList> pathArgs = InterpolableList::create(length);
     for (size_t i = 0; i < interpolablePathSegs.size(); i++)
         pathArgs->set(i, std::move(interpolablePathSegs[i]));
 
-    std::unique_ptr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
+    OwnPtr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
     result->set(PathArgsIndex, std::move(pathArgs));
     result->set(PathNeutralIndex, InterpolableNumber::create(0));
 
     return InterpolationValue(std::move(result), SVGPathNonInterpolableValue::create(pathSegTypes));
 }
 
 InterpolationValue PathInterpolationFunctions::convertValue(const StylePath* stylePath)
 {
     if (stylePath)
         return convertValue(stylePath->byteStream());
 
-    std::unique_ptr<SVGPathByteStream> emptyPath = SVGPathByteStream::create();
+    OwnPtr<SVGPathByteStream> emptyPath = SVGPathByteStream::create();
     return convertValue(*emptyPath);
 }
 
 class UnderlyingPathSegTypesChecker : public InterpolationType::ConversionChecker {
 public:
     ~UnderlyingPathSegTypesChecker() final {}
 
-    static std::unique_ptr<UnderlyingPathSegTypesChecker> create(const InterpolationValue& underlying)
+    static PassOwnPtr<UnderlyingPathSegTypesChecker> create(const InterpolationValue& underlying)
     {
-        return wrapUnique(new UnderlyingPathSegTypesChecker(getPathSegTypes(underlying)));
+        return adoptPtr(new UnderlyingPathSegTypesChecker(getPathSegTypes(underlying)));
     }
 
 private:
     UnderlyingPathSegTypesChecker(const Vector<SVGPathSegType>& pathSegTypes)
         : m_pathSegTypes(pathSegTypes)
     { }
 
     static const Vector<SVGPathSegType>& getPathSegTypes(const InterpolationValue& underlying)
     {
         return toSVGPathNonInterpolableValue(*underlying.nonInterpolableValue).pathSegTypes();
     }
 
     bool isValid(const InterpolationEnvironment&, const InterpolationValue& underlying) const final
     {
         return m_pathSegTypes == getPathSegTypes(underlying);
     }
 
     Vector<SVGPathSegType> m_pathSegTypes;
 };
 
 InterpolationValue PathInterpolationFunctions::maybeConvertNeutral(const InterpolationValue& underlying, InterpolationType::ConversionCheckers& conversionCheckers)
 {
     conversionCheckers.append(UnderlyingPathSegTypesChecker::create(underlying));
-    std::unique_ptr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
+    OwnPtr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
     result->set(PathArgsIndex, toInterpolableList(*underlying.interpolableValue).get(PathArgsIndex)->cloneAndZero());
     result->set(PathNeutralIndex, InterpolableNumber::create(1));
     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;
 
@@ skipping 25 matching lines @@
         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();
 }
 
-std::unique_ptr<SVGPathByteStream> PathInterpolationFunctions::appliedValue(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue)
+PassOwnPtr<SVGPathByteStream> PathInterpolationFunctions::appliedValue(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue)
 {
-    std::unique_ptr<SVGPathByteStream> pathByteStream = SVGPathByteStream::create();
+    OwnPtr<SVGPathByteStream> pathByteStream = SVGPathByteStream::create();
     InterpolatedSVGPathSource source(
         toInterpolableList(*toInterpolableList(interpolableValue).get(PathArgsIndex)),
         toSVGPathNonInterpolableValue(nonInterpolableValue)->pathSegTypes());
     SVGPathByteStreamBuilder builder(*pathByteStream);
     SVGPathParser::parsePath(source, builder);
     return pathByteStream;
 }
 
 } // namespace blink