Remove OwnPtr from Blink.

third_party/WebKit/Source/core/animation/SVGPathSegInterpolationFunctions.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/SVGPathSegInterpolationFunctions.h"
 
+#include <memory>
+
 namespace blink {
 
 
-PassOwnPtr<InterpolableNumber> consumeControlAxis(double value, bool isAbsolute, double currentValue)
+std::unique_ptr<InterpolableNumber> consumeControlAxis(double value, bool isAbsolute, double currentValue)
 {
     return InterpolableNumber::create(isAbsolute ? value : currentValue + value);
 }
 
 double consumeInterpolableControlAxis(const InterpolableValue* number, bool isAbsolute, double currentValue)
 {
     double value = toInterpolableNumber(number)->value();
     return isAbsolute ? value : value - currentValue;
 }
 
-PassOwnPtr<InterpolableNumber> consumeCoordinateAxis(double value, bool isAbsolute, double& currentValue)
+std::unique_ptr<InterpolableNumber> consumeCoordinateAxis(double value, bool isAbsolute, double& currentValue)
 {
     if (isAbsolute)
         currentValue = value;
     else
         currentValue += value;
     return InterpolableNumber::create(currentValue);
 }
 
 double consumeInterpolableCoordinateAxis(const InterpolableValue* number, bool isAbsolute, double& currentValue)
 {
     double previousValue = currentValue;
     currentValue = toInterpolableNumber(number)->value();
     return isAbsolute ? currentValue : currentValue - previousValue;
 }
 
-PassOwnPtr<InterpolableValue> consumeClosePath(const PathSegmentData&, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeClosePath(const PathSegmentData&, PathCoordinates& coordinates)
 {
     coordinates.currentX = coordinates.initialX;
     coordinates.currentY = coordinates.initialY;
     return InterpolableList::create(0);
 }
 
 PathSegmentData consumeInterpolableClosePath(const InterpolableValue&, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     coordinates.currentX = coordinates.initialX;
     coordinates.currentY = coordinates.initialY;
 
     PathSegmentData segment;
     segment.command = segType;
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeSingleCoordinate(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeSingleCoordinate(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
-    OwnPtr<InterpolableList> result = InterpolableList::create(2);
+    std::unique_ptr<InterpolableList> result = InterpolableList::create(2);
     result->set(0, consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX));
     result->set(1, consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY));
 
     if (toAbsolutePathSegType(segment.command) == PathSegMoveToAbs) {
         // Any upcoming 'closepath' commands bring us back to the location we have just moved to.
         coordinates.initialX = coordinates.currentX;
         coordinates.initialY = coordinates.currentY;
     }
 
     return std::move(result);
@@ skipping 10 matching lines @@
 
     if (toAbsolutePathSegType(segType) == PathSegMoveToAbs) {
         // Any upcoming 'closepath' commands bring us back to the location we have just moved to.
         coordinates.initialX = coordinates.currentX;
         coordinates.initialY = coordinates.currentY;
     }
 
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeCurvetoCubic(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeCurvetoCubic(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
-    OwnPtr<InterpolableList> result = InterpolableList::create(6);
+    std::unique_ptr<InterpolableList> result = InterpolableList::create(6);
     result->set(0, consumeControlAxis(segment.x1(), isAbsolute, coordinates.currentX));
     result->set(1, consumeControlAxis(segment.y1(), isAbsolute, coordinates.currentY));
     result->set(2, consumeControlAxis(segment.x2(), isAbsolute, coordinates.currentX));
     result->set(3, consumeControlAxis(segment.y2(), isAbsolute, coordinates.currentY));
     result->set(4, consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX));
     result->set(5, consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY));
     return std::move(result);
 }
 
 PathSegmentData consumeInterpolableCurvetoCubic(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     const InterpolableList& list = toInterpolableList(value);
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.point1.setX(consumeInterpolableControlAxis(list.get(0), isAbsolute, coordinates.currentX));
     segment.point1.setY(consumeInterpolableControlAxis(list.get(1), isAbsolute, coordinates.currentY));
     segment.point2.setX(consumeInterpolableControlAxis(list.get(2), isAbsolute, coordinates.currentX));
     segment.point2.setY(consumeInterpolableControlAxis(list.get(3), isAbsolute, coordinates.currentY));
     segment.targetPoint.setX(consumeInterpolableCoordinateAxis(list.get(4), isAbsolute, coordinates.currentX));
     segment.targetPoint.setY(consumeInterpolableCoordinateAxis(list.get(5), isAbsolute, coordinates.currentY));
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeCurvetoQuadratic(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeCurvetoQuadratic(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
-    OwnPtr<InterpolableList> result = InterpolableList::create(4);
+    std::unique_ptr<InterpolableList> result = InterpolableList::create(4);
     result->set(0, consumeControlAxis(segment.x1(), isAbsolute, coordinates.currentX));
     result->set(1, consumeControlAxis(segment.y1(), isAbsolute, coordinates.currentY));
     result->set(2, consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX));
     result->set(3, consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY));
     return std::move(result);
 }
 
 PathSegmentData consumeInterpolableCurvetoQuadratic(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     const InterpolableList& list = toInterpolableList(value);
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.point1.setX(consumeInterpolableControlAxis(list.get(0), isAbsolute, coordinates.currentX));
     segment.point1.setY(consumeInterpolableControlAxis(list.get(1), isAbsolute, coordinates.currentY));
     segment.targetPoint.setX(consumeInterpolableCoordinateAxis(list.get(2), isAbsolute, coordinates.currentX));
     segment.targetPoint.setY(consumeInterpolableCoordinateAxis(list.get(3), isAbsolute, coordinates.currentY));
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeArc(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeArc(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
-    OwnPtr<InterpolableList> result = InterpolableList::create(7);
+    std::unique_ptr<InterpolableList> result = InterpolableList::create(7);
     result->set(0, consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX));
     result->set(1, consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY));
     result->set(2, InterpolableNumber::create(segment.r1()));
     result->set(3, InterpolableNumber::create(segment.r2()));
     result->set(4, InterpolableNumber::create(segment.arcAngle()));
     result->set(5, InterpolableBool::create(segment.largeArcFlag()));
     result->set(6, InterpolableBool::create(segment.sweepFlag()));
     return std::move(result);
 }
 
 PathSegmentData consumeInterpolableArc(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     const InterpolableList& list = toInterpolableList(value);
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.targetPoint.setX(consumeInterpolableCoordinateAxis(list.get(0), isAbsolute, coordinates.currentX));
     segment.targetPoint.setY(consumeInterpolableCoordinateAxis(list.get(1), isAbsolute, coordinates.currentY));
     segment.arcRadii().setX(toInterpolableNumber(list.get(2))->value());
     segment.arcRadii().setY(toInterpolableNumber(list.get(3))->value());
     segment.setArcAngle(toInterpolableNumber(list.get(4))->value());
     segment.arcLarge = toInterpolableBool(list.get(5))->value();
     segment.arcSweep = toInterpolableBool(list.get(6))->value();
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeLinetoHorizontal(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeLinetoHorizontal(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
     return consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX);
 }
 
 PathSegmentData consumeInterpolableLinetoHorizontal(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.targetPoint.setX(consumeInterpolableCoordinateAxis(&value, isAbsolute, coordinates.currentX));
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeLinetoVertical(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeLinetoVertical(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
     return consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY);
 }
 
 PathSegmentData consumeInterpolableLinetoVertical(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.targetPoint.setY(consumeInterpolableCoordinateAxis(&value, isAbsolute, coordinates.currentY));
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> consumeCurvetoCubicSmooth(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> consumeCurvetoCubicSmooth(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
-    OwnPtr<InterpolableList> result = InterpolableList::create(4);
+    std::unique_ptr<InterpolableList> result = InterpolableList::create(4);
     result->set(0, consumeControlAxis(segment.x2(), isAbsolute, coordinates.currentX));
     result->set(1, consumeControlAxis(segment.y2(), isAbsolute, coordinates.currentY));
     result->set(2, consumeCoordinateAxis(segment.x(), isAbsolute, coordinates.currentX));
     result->set(3, consumeCoordinateAxis(segment.y(), isAbsolute, coordinates.currentY));
     return std::move(result);
 }
 
 PathSegmentData consumeInterpolableCurvetoCubicSmooth(const InterpolableValue& value, SVGPathSegType segType, PathCoordinates& coordinates)
 {
     const InterpolableList& list = toInterpolableList(value);
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.point2.setX(consumeInterpolableControlAxis(list.get(0), isAbsolute, coordinates.currentX));
     segment.point2.setY(consumeInterpolableControlAxis(list.get(1), isAbsolute, coordinates.currentY));
     segment.targetPoint.setX(consumeInterpolableCoordinateAxis(list.get(2), isAbsolute, coordinates.currentX));
     segment.targetPoint.setY(consumeInterpolableCoordinateAxis(list.get(3), isAbsolute, coordinates.currentY));
     return segment;
 }
 
-PassOwnPtr<InterpolableValue> SVGPathSegInterpolationFunctions::consumePathSeg(const PathSegmentData& segment, PathCoordinates& coordinates)
+std::unique_ptr<InterpolableValue> SVGPathSegInterpolationFunctions::consumePathSeg(const PathSegmentData& segment, PathCoordinates& coordinates)
 {
     switch (segment.command) {
     case PathSegClosePath:
         return consumeClosePath(segment, coordinates);
 
     case PathSegMoveToAbs:
     case PathSegMoveToRel:
     case PathSegLineToAbs:
     case PathSegLineToRel:
     case PathSegCurveToQuadraticSmoothAbs:
@@ skipping 70 matching lines @@
         return consumeInterpolableCurvetoCubicSmooth(value, segType, coordinates);
 
     case PathSegUnknown:
     default:
         ASSERT_NOT_REACHED();
         return PathSegmentData();
     }
 }
 
 } // namespace blink