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

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"
@@ skipping 57 matching lines @@
 };
 
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(BasicShapeNonInterpolableValue);
 DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(BasicShapeNonInterpolableValue);
 
 namespace {
 
 PassOwnPtr<InterpolableValue> unwrap(InterpolationValue&& value)
 {
     ASSERT(value.interpolableValue);
-    return value.interpolableValue.release();
+    return std::move(value.interpolableValue);
 }
 
 PassOwnPtr<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)
@@ skipping 77 matching lines @@
 
 InterpolationValue convertCSSValue(const CSSBasicShapeCircleValue& circle)
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, convertCSSCoordinate(circle.centerX()));
     list->set(CircleCenterYIndex, convertCSSCoordinate(circle.centerY()));
 
     OwnPtr<InterpolableValue> radius;
     if (!(radius = convertCSSRadius(circle.radius())))
         return nullptr;
-    list->set(CircleRadiusIndex, radius.release());
+    list->set(CircleRadiusIndex, std::move(radius));
 
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeCircle& circle, double zoom)
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, convertCoordinate(circle.centerX(), zoom));
     list->set(CircleCenterYIndex, convertCoordinate(circle.centerY(), zoom));
 
     OwnPtr<InterpolableValue> radius;
     if (!(radius = convertRadius(circle.radius(), zoom)))
         return nullptr;
-    list->set(CircleRadiusIndex, radius.release());
+    list->set(CircleRadiusIndex, std::move(radius));
 
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeCircleType));
 }
 
 PassOwnPtr<InterpolableValue> createNeutralValue()
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(CircleComponentIndexCount);
     list->set(CircleCenterXIndex, createNeutralInterpolableCoordinate());
     list->set(CircleCenterYIndex, createNeutralInterpolableCoordinate());
     list->set(CircleRadiusIndex, createNeutralInterpolableRadius());
-    return list.release();
+    return static_pointer_cast<InterpolableValue>(std::move(list));

[tzik, 2016/05/16 02:32:37]

Can we just "return std::move(list);" here?
It might look weird to use std::move on return statement for a local variable,
but I think we can't avoid it.

 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
     const InterpolableList& list = toInterpolableList(interpolableValue);
     circle->setCenterX(createCoordinate(*list.get(CircleCenterXIndex), conversionData));
     circle->setCenterY(createCoordinate(*list.get(CircleCenterYIndex), conversionData));
     circle->setRadius(createRadius(*list.get(CircleRadiusIndex), conversionData));
     return circle.release();
@@ skipping 13 matching lines @@
 
 InterpolationValue convertCSSValue(const CSSBasicShapeEllipseValue& ellipse)
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, convertCSSCoordinate(ellipse.centerX()));
     list->set(EllipseCenterYIndex, convertCSSCoordinate(ellipse.centerY()));
 
     OwnPtr<InterpolableValue> radius;
     if (!(radius = convertCSSRadius(ellipse.radiusX())))
         return nullptr;
-    list->set(EllipseRadiusXIndex, radius.release());
+    list->set(EllipseRadiusXIndex, std::move(radius));
     if (!(radius = convertCSSRadius(ellipse.radiusY())))
         return nullptr;
-    list->set(EllipseRadiusYIndex, radius.release());
+    list->set(EllipseRadiusYIndex, std::move(radius));
 
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeEllipse& ellipse, double zoom)
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, convertCoordinate(ellipse.centerX(), zoom));
     list->set(EllipseCenterYIndex, convertCoordinate(ellipse.centerY(), zoom));
 
     OwnPtr<InterpolableValue> radius;
     if (!(radius = convertRadius(ellipse.radiusX(), zoom)))
         return nullptr;
-    list->set(EllipseRadiusXIndex, radius.release());
+    list->set(EllipseRadiusXIndex, std::move(radius));
     if (!(radius = convertRadius(ellipse.radiusY(), zoom)))
         return nullptr;
-    list->set(EllipseRadiusYIndex, radius.release());
+    list->set(EllipseRadiusYIndex, std::move(radius));
 
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeEllipseType));
 }
 
 PassOwnPtr<InterpolableValue> createNeutralValue()
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(EllipseComponentIndexCount);
     list->set(EllipseCenterXIndex, createNeutralInterpolableCoordinate());
     list->set(EllipseCenterYIndex, createNeutralInterpolableCoordinate());
     list->set(EllipseRadiusXIndex, createNeutralInterpolableRadius());
     list->set(EllipseRadiusYIndex, createNeutralInterpolableRadius());
-    return list.release();
+    return static_pointer_cast<InterpolableValue>(std::move(list));
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
     const InterpolableList& list = toInterpolableList(interpolableValue);
     ellipse->setCenterX(createCoordinate(*list.get(EllipseCenterXIndex), conversionData));
     ellipse->setCenterY(createCoordinate(*list.get(EllipseCenterYIndex), conversionData));
     ellipse->setRadiusX(createRadius(*list.get(EllipseRadiusXIndex), conversionData));
     ellipse->setRadiusY(createRadius(*list.get(EllipseRadiusYIndex), conversionData));
@@ skipping 29 matching lines @@
     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(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
 }
 
 InterpolationValue convertBasicShape(const BasicShapeInset& inset, double zoom)
 {
     OwnPtr<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(list.release(), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::create(BasicShape::BasicShapeInsetType));
 }
 
 PassOwnPtr<InterpolableValue> createNeutralValue()
 {
     OwnPtr<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());
     list->set(InsetBorderBottomRightHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderBottomLeftWidthIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
     list->set(InsetBorderBottomLeftHeightIndex, CSSLengthInterpolationType::createNeutralInterpolableValue());
-    return list.release();
+    return static_pointer_cast<InterpolableValue>(std::move(list));
 }
 
 PassRefPtr<BasicShape> createBasicShape(const InterpolableValue& interpolableValue, const CSSToLengthConversionData& conversionData)
 {
     RefPtr<BasicShapeInset> inset = BasicShapeInset::create();
     const InterpolableList& list = toInterpolableList(interpolableValue);
     inset->setTop(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetTopIndex), nullptr, conversionData));
     inset->setRight(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetRightIndex), nullptr, conversionData));
     inset->setBottom(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetBottomIndex), nullptr, conversionData));
     inset->setLeft(CSSLengthInterpolationType::resolveInterpolableLength(*list.get(InsetLeftIndex), nullptr, conversionData));
 
     inset->setTopLeftRadius(createBorderRadius(*list.get(InsetBorderTopLeftWidthIndex), *list.get(InsetBorderTopLeftHeightIndex), conversionData));
     inset->setTopRightRadius(createBorderRadius(*list.get(InsetBorderTopRightWidthIndex), *list.get(InsetBorderTopRightHeightIndex), conversionData));
     inset->setBottomRightRadius(createBorderRadius(*list.get(InsetBorderBottomRightWidthIndex), *list.get(InsetBorderBottomRightHeightIndex), conversionData));
     inset->setBottomLeftRadius(createBorderRadius(*list.get(InsetBorderBottomLeftWidthIndex), *list.get(InsetBorderBottomLeftHeightIndex), conversionData));
     return inset.release();
 }
 
 } // namespace InsetFunctions
 
 namespace PolygonFunctions {
 
 InterpolationValue convertCSSValue(const CSSBasicShapePolygonValue& polygon)
 {
     size_t size = polygon.values().size();
     OwnPtr<InterpolableList> list = InterpolableList::create(size);
     for (size_t i = 0; i < size; i++)
         list->set(i, convertCSSLength(polygon.values()[i].get()));
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::createPolygon(polygon.getWindRule(), size));
+    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);
     for (size_t i = 0; i < size; i++)
         list->set(i, convertLength(polygon.values()[i], zoom));
-    return InterpolationValue(list.release(), BasicShapeNonInterpolableValue::createPolygon(polygon.getWindRule(), size));
+    return InterpolationValue(std::move(list), BasicShapeNonInterpolableValue::createPolygon(polygon.getWindRule(), size));
 }
 
 PassOwnPtr<InterpolableValue> createNeutralValue(const BasicShapeNonInterpolableValue& nonInterpolableValue)
 {
     OwnPtr<InterpolableList> list = InterpolableList::create(nonInterpolableValue.size());
     for (size_t i = 0; i < nonInterpolableValue.size(); i++)
         list->set(i, CSSLengthInterpolationType::createNeutralInterpolableValue());
-    return list.release();
+    return static_pointer_cast<InterpolableValue>(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);
     size_t size = nonInterpolableValue.size();
     ASSERT(list.length() == size);
     ASSERT(size % 2 == 0);
@@ skipping 76 matching lines @@
         return InsetFunctions::createBasicShape(interpolableValue, conversionData);
     case BasicShape::BasicShapePolygonType:
         return PolygonFunctions::createBasicShape(interpolableValue, nonInterpolableValue, conversionData);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 } // namespace blink