Remove OwnPtr from Blink.

third_party/WebKit/Source/core/animation/BasicShapeInterpolationFunctions.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/BasicShapeInterpolationFunctions.h"
 
 #include "core/animation/CSSLengthInterpolationType.h"
 #include "core/animation/CSSPositionAxisListInterpolationType.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/BasicShapes.h"
+#include <memory>
 
 namespace blink {
 
 class BasicShapeNonInterpolableValue : public NonInterpolableValue {
 public:
     static PassRefPtr<NonInterpolableValue> create(BasicShape::ShapeType type)
     {
         return adoptRef(new BasicShapeNonInterpolableValue(type));
     }
     static PassRefPtr<NonInterpolableValue> createPolygon(WindRule windRule, size_t size)
@@ skipping 43 matching lines @@
     const BasicShape::ShapeType m_type;
     const WindRule m_windRule;
     const size_t m_size;
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(BasicShapeNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(BasicShapeNonInterpolableValue);
 
 namespace {
 
-PassOwnPtr<InterpolableValue> unwrap(InterpolationValue&& value)
+std::unique_ptr<InterpolableValue> unwrap(InterpolationValue&& value)
 {
     ASSERT(value.interpolableValue);
     return std::move(value.interpolableValue);
 }
 
-PassOwnPtr<InterpolableValue> convertCSSCoordinate(const CSSValue* coordinate)
+std::unique_ptr<InterpolableValue> convertCSSCoordinate(const CSSValue* coordinate)
 {
     if (coordinate)
         return unwrap(CSSPositionAxisListInterpolationType::convertPositionAxisCSSValue(*coordinate));
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(Length(50, Percent), 1));
 }
 
-PassOwnPtr<InterpolableValue> convertCoordinate(const BasicShapeCenterCoordinate& coordinate, double zoom)
+std::unique_ptr<InterpolableValue> convertCoordinate(const BasicShapeCenterCoordinate& coordinate, double zoom)
 {
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(coordinate.computedLength(), zoom));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralInterpolableCoordinate()
+std::unique_ptr<InterpolableValue> createNeutralInterpolableCoordinate()
 {
     return CSSLengthInterpolationType::createNeutralInterpolableValue();
 }
 
 BasicShapeCenterCoordinate createCoordinate(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     return BasicShapeCenterCoordinate(
         BasicShapeCenterCoordinate::TopLeft,
         CSSLengthInterpolationType::resolveInterpolableLength(interpolableValue, nullptr, conversionData));
 }
 
-PassOwnPtr<InterpolableValue> convertCSSRadius(const CSSPrimitiveValue* radius)
+std::unique_ptr<InterpolableValue> convertCSSRadius(const CSSPrimitiveValue* radius)
 {
     if (!radius || radius->isValueID())
         return nullptr;
     return unwrap(CSSLengthInterpolationType::maybeConvertCSSValue(*radius));
 }
 
-PassOwnPtr<InterpolableValue> convertRadius(const BasicShapeRadius& radius, double zoom)
+std::unique_ptr<InterpolableValue> convertRadius(const BasicShapeRadius& radius, double zoom)
 {
     if (radius.type() != BasicShapeRadius::Value)
         return nullptr;
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(radius.value(), zoom));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralInterpolableRadius()
+std::unique_ptr<InterpolableValue> createNeutralInterpolableRadius()
 {
     return CSSLengthInterpolationType::createNeutralInterpolableValue();
 }
 
 BasicShapeRadius createRadius(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     return BasicShapeRadius(CSSLengthInterpolationType::resolveInterpolableLength(interpolableValue, nullptr, conversionData, ValueRangeNonNegative));
 }
 
-PassOwnPtr<InterpolableValue> convertCSSLength(const CSSValue* length)
+std::unique_ptr<InterpolableValue> convertCSSLength(const CSSValue* length)
 {
     if (!length)
         return CSSLengthInterpolationType::createNeutralInterpolableValue();
     return unwrap(CSSLengthInterpolationType::maybeConvertCSSValue(*length));
 }
 
-PassOwnPtr<InterpolableValue> convertLength(const Length& length, double zoom)
+std::unique_ptr<InterpolableValue> convertLength(const Length& length, double zoom)
 {
     return unwrap(CSSLengthInterpolationType::maybeConvertLength(length, zoom));
 }
 
-PassOwnPtr<InterpolableValue> convertCSSBorderRadiusWidth(const CSSValuePair* pair)
+std::unique_ptr<InterpolableValue> convertCSSBorderRadiusWidth(const CSSValuePair* pair)
 {
     return convertCSSLength(pair ? &pair->first() : nullptr);
 }
 
-PassOwnPtr<InterpolableValue> convertCSSBorderRadiusHeight(const CSSValuePair* pair)
+std::unique_ptr<InterpolableValue> convertCSSBorderRadiusHeight(const CSSValuePair* pair)
 {
     return convertCSSLength(pair ? &pair->second() : nullptr);
 }
 
 LengthSize createBorderRadius(const InterpolableValue& width, const InterpolableValue& height, const CSSToLengthConversionData& conversionData)
 {
     return LengthSize(
         CSSLengthInterpolationType::resolveInterpolableLength(width, nullptr, conversionData, ValueRangeNonNegative),
         CSSLengthInterpolationType::resolveInterpolableLength(height, nullptr, conversionData, ValueRangeNonNegative));
 }
 
 namespace CircleFunctions {
 
 enum CircleComponentIndex {
     CircleCenterXIndex,
     CircleCenterYIndex,
     CircleRadiusIndex,
     CircleComponentIndexCount,
 };
 
 InterpolationValue convertCSSValue(const CSSBasicShapeCircleValue& circle)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, convertCSSCoordinate(circle.centerX()));
     list->set(CircleCenterYIndex, convertCSSCoordinate(circle.centerY()));
 
-    OwnPtr<InterpolableValue> radius;
+    std::unique_ptr<InterpolableValue> radius;
     if (!(radius = convertCSSRadius(circle.radius())))
         return nullptr;
     list->set(CircleRadiusIndex, std::move(radius));
 
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeCircle& circle, double zoom)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, convertCoordinate(circle.centerX(), zoom));
     list->set(CircleCenterYIndex, convertCoordinate(circle.centerY(), zoom));
 
-    OwnPtr<InterpolableValue> radius;
+    std::unique_ptr<InterpolableValue> radius;
     if (!(radius = convertRadius(circle.radius(), zoom)))
         return nullptr;
     list->set(CircleRadiusIndex, std::move(radius));
 
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralValue()
+std::unique_ptr<InterpolableValue> createNeutralValue()
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, createNeutralInterpolableCoordinate());
     list->set(CircleCenterYIndex, createNeutralInterpolableCoordinate());
     list->set(CircleRadiusIndex, createNeutralInterpolableRadius());
     return std::move(list);
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
     const InterpolableList& list = toInterpolableList(interpolableValue);
@@ skipping 10 matching lines @@
 enum EllipseComponentIndex {
     EllipseCenterXIndex,
     EllipseCenterYIndex,
     EllipseRadiusXIndex,
     EllipseRadiusYIndex,
     EllipseComponentIndexCount,
 };
 
 InterpolationValue convertCSSValue(const CSSBasicShapeEllipseValue& ellipse)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, convertCSSCoordinate(ellipse.centerX()));
     list->set(EllipseCenterYIndex, convertCSSCoordinate(ellipse.centerY()));
 
-    OwnPtr<InterpolableValue> radius;
+    std::unique_ptr<InterpolableValue> radius;
     if (!(radius = convertCSSRadius(ellipse.radiusX())))
         return nullptr;
     list->set(EllipseRadiusXIndex, std::move(radius));
     if (!(radius = convertCSSRadius(ellipse.radiusY())))
         return nullptr;
     list->set(EllipseRadiusYIndex, std::move(radius));
 
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeEllipse& ellipse, double zoom)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, convertCoordinate(ellipse.centerX(), zoom));
     list->set(EllipseCenterYIndex, convertCoordinate(ellipse.centerY(), zoom));
 
-    OwnPtr<InterpolableValue> radius;
+    std::unique_ptr<InterpolableValue> radius;
     if (!(radius = convertRadius(ellipse.radiusX(), zoom)))
         return nullptr;
     list->set(EllipseRadiusXIndex, std::move(radius));
     if (!(radius = convertRadius(ellipse.radiusY(), zoom)))
         return nullptr;
     list->set(EllipseRadiusYIndex, std::move(radius));
 
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralValue()
+std::unique_ptr<InterpolableValue> createNeutralValue()
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, createNeutralInterpolableCoordinate());
     list->set(EllipseCenterYIndex, createNeutralInterpolableCoordinate());
     list->set(EllipseRadiusXIndex, createNeutralInterpolableRadius());
     list->set(EllipseRadiusYIndex, createNeutralInterpolableRadius());
     return std::move(list);
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
@@ skipping 20 matching lines @@
     InsetBorderTopRightHeightIndex,
     InsetBorderBottomRightWidthIndex,
     InsetBorderBottomRightHeightIndex,
     InsetBorderBottomLeftWidthIndex,
     InsetBorderBottomLeftHeightIndex,
     InsetComponentIndexCount,
 };
 
 InterpolationValue convertCSSValue(const CSSBasicShapeInsetValue& inset)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
     list->set(InsetTopIndex, convertCSSLength(inset.top()));
     list->set(InsetRightIndex, convertCSSLength(inset.right()));
     list->set(InsetBottomIndex, convertCSSLength(inset.bottom()));
     list->set(InsetLeftIndex, convertCSSLength(inset.left()));
 
     list->set(InsetBorderTopLeftWidthIndex, convertCSSBorderRadiusWidth(inset.topLeftRadius()));
     list->set(InsetBorderTopLeftHeightIndex, convertCSSBorderRadiusHeight(inset.topLeftRadius()));
     list->set(InsetBorderTopRightWidthIndex, convertCSSBorderRadiusWidth(inset.topRightRadius()));
     list->set(InsetBorderTopRightHeightIndex, convertCSSBorderRadiusHeight(inset.topRightRadius()));
     list->set(InsetBorderBottomRightWidthIndex, convertCSSBorderRadiusWidth(inset.bottomRightRadius()));
     list->set(InsetBorderBottomRightHeightIndex, convertCSSBorderRadiusHeight(inset.bottomRightRadius()));
     list->set(InsetBorderBottomLeftWidthIndex, convertCSSBorderRadiusWidth(inset.bottomLeftRadius()));
     list->set(InsetBorderBottomLeftHeightIndex, convertCSSBorderRadiusHeight(inset.bottomLeftRadius()));
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeInset& inset, double zoom)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
     list->set(InsetTopIndex, convertLength(inset.top(), zoom));
     list->set(InsetRightIndex, convertLength(inset.right(), zoom));
     list->set(InsetBottomIndex, convertLength(inset.bottom(), zoom));
     list->set(InsetLeftIndex, convertLength(inset.left(), zoom));
 
     list->set(InsetBorderTopLeftWidthIndex, convertLength(inset.topLeftRadius().width(), zoom));
     list->set(InsetBorderTopLeftHeightIndex, convertLength(inset.topLeftRadius().height(), zoom));
     list->set(InsetBorderTopRightWidthIndex, convertLength(inset.topRightRadius().width(), zoom));
     list->set(InsetBorderTopRightHeightIndex, convertLength(inset.topRightRadius().height(), zoom));
     list->set(InsetBorderBottomRightWidthIndex, convertLength(inset.bottomRightRadius().width(), zoom));
     list->set(InsetBorderBottomRightHeightIndex, convertLength(inset.bottomRightRadius().height(), zoom));
     list->set(InsetBorderBottomLeftWidthIndex, convertLength(inset.bottomLeftRadius().width(), zoom));
     list->set(InsetBorderBottomLeftHeightIndex, convertLength(inset.bottomLeftRadius().height(), zoom));
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralValue()
+std::unique_ptr<InterpolableValue> createNeutralValue()
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(InsetComponentIndexCount);
     list->set(InsetTopIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetRightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBottomIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetLeftIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
 
     list->set(InsetBorderTopLeftWidthIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderTopLeftHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderTopRightWidthIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderTopRightHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderBottomRightWidthIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
@@ skipping 19 matching lines @@
     return inset.release();
 }
 
 } // namespace InsetFunctions
 
 namespace PolygonFunctions {
 
 InterpolationValue convertCSSValue(const CSSBasicShapePolygonValue& polygon)
 {
     size_t size = polygon.values().size();
-    OwnPtr<InterpolableList> list = InterpolableList::create(size);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(size);
     for (size_t i = 0; i < size; i++)
         list->set(i, convertCSSLength(polygon.values()[i].get()));
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::createPolygon(polygon.getWindRule(), size));
 }
 
 InterpolationValue convertBasicShape(const BasicShapePolygon& polygon, double zoom)
 {
     size_t size = polygon.values().size();
-    OwnPtr<InterpolableList> list = InterpolableList::create(size);
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(size);
     for (size_t i = 0; i < size; i++)
         list->set(i, convertLength(polygon.values()[i], zoom));
     return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::createPolygon(polygon.getWindRule(), size));
 }
 
-PassOwnPtr<InterpolableValue> createNeutralValue(const BasicShapeNonInterpolableValue& nonInterpolableValue)
+std::unique_ptr<InterpolableValue> createNeutralValue(const BasicShapeNonInterpolableValue& nonInterpolableValue)
 {
-    OwnPtr<InterpolableList> list = InterpolableList::create(nonInterpolableValue.size());
+    std::unique_ptr<InterpolableList> list = InterpolableList::create(nonInterpolableValue.size());
     for (size_t i = 0; i < nonInterpolableValue.size(); i++)
         list->set(i, CSSLengthInterpolationType::createNeutralInterpolableValue());
     return std::move(list);
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const BasicShapeNonInterpolableValue& nonInterpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
     polygon->setWindRule(nonInterpolableValue.windRule());
     const InterpolableList& list = toInterpolableList(interpolableValue);
@@ skipping 37 matching lines @@
     case BasicShape::BasicShapeInsetType:
         return InsetFunctions::convertBasicShape(toBasicShapeInset(*shape), zoom);
     case BasicShape::BasicShapePolygonType:
         return PolygonFunctions::convertBasicShape(toBasicShapePolygon(*shape), zoom);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
-PassOwnPtr<InterpolableValue> BasicShapeInterpolationFunctions::createNeutralValue(const NonInterpolableValue& untypedNonInterpolableValue)
+std::unique_ptr<InterpolableValue> BasicShapeInterpolationFunctions::createNeutralValue(const NonInterpolableValue& untypedNonInterpolableValue)
 {
     const BasicShapeNonInterpolableValue& nonInterpolableValue = toBasicShapeNonInterpolableValue(untypedNonInterpolableValue);
     switch (nonInterpolableValue.type()) {
     case BasicShape::BasicShapeCircleType:
         return CircleFunctions::createNeutralValue();
     case BasicShape::BasicShapeEllipseType:
         return EllipseFunctions::createNeutralValue();
     case BasicShape::BasicShapeInsetType:
         return InsetFunctions::createNeutralValue();
     case BasicShape::BasicShapePolygonType:
@@ skipping 21 matching lines @@
         return InsetFunctions::createBasicShape(interpolableValue, conversionData);
     case BasicShape::BasicShapePolygonType:
         return PolygonFunctions::createBasicShape(interpolableValue, nonInterpolableValue, conversionData);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 } // namespace blink