Remove OwnPtr from Blink.

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

Index: third_party/WebKit/Source/core/animation/CompositorAnimations.cpp
diff --git a/third_party/WebKit/Source/core/animation/CompositorAnimations.cpp b/third_party/WebKit/Source/core/animation/CompositorAnimations.cpp
index 09fb12473c475cf30248bb469add073690b8fb97..0e846c3c2cabcadc7a28f3eb8c1f998237568a06 100644
--- a/third_party/WebKit/Source/core/animation/CompositorAnimations.cpp
+++ b/third_party/WebKit/Source/core/animation/CompositorAnimations.cpp
@@ -54,9 +54,10 @@
 #include "platform/graphics/CompositorFactory.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
-
+#include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <cmath>
+#include <memory>
 
 namespace blink {
 
@@ -333,14 +334,14 @@ void CompositorAnimations::startAnimationOnCompositor(const Element& element, in
 
     const KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(effect);
 
-    Vector<OwnPtr<CompositorAnimation>> animations;
+    Vector<std::unique_ptr<CompositorAnimation>> animations;
     getAnimationOnCompositor(timing, group, startTime, timeOffset, keyframeEffect, animations, animationPlaybackRate);
     ASSERT(!animations.isEmpty());
     for (auto& compositorAnimation : animations) {
         int id = compositorAnimation->id();
         CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
         ASSERT(compositorPlayer);
-        compositorPlayer->addAnimation(compositorAnimation.leakPtr());
+        compositorPlayer->addAnimation(compositorAnimation.release());
         startedAnimationIds.append(id);
     }
     ASSERT(!startedAnimationIds.isEmpty());
@@ -511,7 +512,7 @@ void setTimingFunctionOnCurve(PlatformAnimationCurveType& curve, TimingFunction*
 void addKeyframeToCurve(CompositorFilterAnimationCurve& curve, Keyframe::PropertySpecificKeyframe* keyframe,
     const AnimatableValue* value, const TimingFunction* keyframeTimingFunction)
 {
-    OwnPtr<CompositorFilterOperations> ops = adoptPtr(CompositorFactory::current().createFilterOperations());
+    std::unique_ptr<CompositorFilterOperations> ops = wrapUnique(CompositorFactory::current().createFilterOperations());
     toCompositorFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
 
     CompositorFilterKeyframe filterKeyframe(keyframe->offset(), std::move(ops));
@@ -528,7 +529,7 @@ void addKeyframeToCurve(CompositorFloatAnimationCurve& curve, Keyframe::Property
 void addKeyframeToCurve(CompositorTransformAnimationCurve& curve, Keyframe::PropertySpecificKeyframe* keyframe,
     const AnimatableValue* value, const TimingFunction* keyframeTimingFunction)
 {
-    OwnPtr<CompositorTransformOperations> ops = adoptPtr(CompositorFactory::current().createTransformOperations());
+    std::unique_ptr<CompositorTransformOperations> ops = wrapUnique(CompositorFactory::current().createTransformOperations());
     toCompositorTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
 
     CompositorTransformKeyframe transformKeyframe(keyframe->offset(), std::move(ops));
@@ -556,7 +557,7 @@ void addKeyframesToCurve(PlatformAnimationCurveType& curve, const AnimatableValu
 
 } // namespace
 
-void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<OwnPtr<CompositorAnimation>>& animations, double animationPlaybackRate)
+void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int group, double startTime, double timeOffset, const KeyframeEffectModelBase& effect, Vector<std::unique_ptr<CompositorAnimation>>& animations, double animationPlaybackRate)
 {
     ASSERT(animations.isEmpty());
     CompositorTiming compositorTiming;
@@ -577,7 +578,7 @@ void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int gr
         getKeyframeValuesForProperty(&effect, property, scale, values);
 
         CompositorTargetProperty::Type targetProperty;
-        OwnPtr<CompositorAnimationCurve> curve;
+        std::unique_ptr<CompositorAnimationCurve> curve;
         switch (property.cssProperty()) {
         case CSSPropertyOpacity: {
             targetProperty = CompositorTargetProperty::OPACITY;
@@ -585,7 +586,7 @@ void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int gr
             CompositorFloatAnimationCurve* floatCurve = CompositorFactory::current().createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values);
             setTimingFunctionOnCurve(*floatCurve, timing.timingFunction.get());
-            curve = adoptPtr(floatCurve);
+            curve = wrapUnique(floatCurve);
             break;
         }
         case CSSPropertyWebkitFilter:
@@ -594,7 +595,7 @@ void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int gr
             CompositorFilterAnimationCurve* filterCurve = CompositorFactory::current().createFilterAnimationCurve();
             addKeyframesToCurve(*filterCurve, values);
             setTimingFunctionOnCurve(*filterCurve, timing.timingFunction.get());
-            curve = adoptPtr(filterCurve);
+            curve = wrapUnique(filterCurve);
             break;
         }
         case CSSPropertyRotate:
@@ -605,7 +606,7 @@ void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int gr
             CompositorTransformAnimationCurve* transformCurve = CompositorFactory::current().createTransformAnimationCurve();
             addKeyframesToCurve(*transformCurve, values);
             setTimingFunctionOnCurve(*transformCurve, timing.timingFunction.get());
-            curve = adoptPtr(transformCurve);
+            curve = wrapUnique(transformCurve);
             break;
         }
         default:
@@ -614,7 +615,7 @@ void CompositorAnimations::getAnimationOnCompositor(const Timing& timing, int gr
         }
         ASSERT(curve.get());
 
-        OwnPtr<CompositorAnimation> animation = adoptPtr(CompositorFactory::current().createAnimation(*curve, targetProperty, group, 0));
+        std::unique_ptr<CompositorAnimation> animation = wrapUnique(CompositorFactory::current().createAnimation(*curve, targetProperty, group, 0));
 
         if (!std::isnan(startTime))
             animation->setStartTime(startTime);