Blink Compositor Animation: Use PassOwnPtr in CompositorFactory.

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 618 matching lines @@
             keyframeTimingFunction = &keyframe->easing();
         }
 
         // FIXME: This relies on StringKeyframes being eagerly evaluated, which will
         // not happen eventually. Instead we should extract the CSSValue here
         // and convert using another set of toAnimatableXXXOperations functions.
         const AnimatableValue* value = keyframe->getAnimatableValue().get();
 
         switch (curve.type()) {
         case CompositorAnimationCurve::AnimationCurveTypeFilter: {
-            OwnPtr<CompositorFilterOperations> ops = adoptPtr(CompositorFactory::current().createFilterOperations());
+            OwnPtr<CompositorFilterOperations> ops = CompositorFactory::current().createFilterOperations();
             toCompositorFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
 
             CompositorFilterKeyframe filterKeyframe(keyframe->offset(), ops.release());
             CompositorFilterAnimationCurve* filterCurve = static_cast<CompositorFilterAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*filterCurve, filterKeyframe, keyframeTimingFunction);
             break;
         }
         case CompositorAnimationCurve::AnimationCurveTypeFloat: {
             CompositorFloatKeyframe floatKeyframe(keyframe->offset(), toAnimatableDouble(value)->toDouble());
             CompositorFloatAnimationCurve* floatCurve = static_cast<CompositorFloatAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*floatCurve, floatKeyframe, keyframeTimingFunction);
             break;
         }
         case CompositorAnimationCurve::AnimationCurveTypeTransform: {
-            OwnPtr<CompositorTransformOperations> ops = adoptPtr(CompositorFactory::current().createTransformOperations());
+            OwnPtr<CompositorTransformOperations> ops = CompositorFactory::current().createTransformOperations();
             toCompositorTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
 
             CompositorTransformKeyframe transformKeyframe(keyframe->offset(), ops.release());
             CompositorTransformAnimationCurve* transformCurve = static_cast<CompositorTransformAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*transformCurve, transformKeyframe, keyframeTimingFunction);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
         }
@@ skipping 12 matching lines @@
     for (const auto& property : properties) {
         PropertySpecificKeyframeVector values;
         getKeyframeValuesForProperty(&effect, property, compositorTiming.scaledDuration, values);
 
         CompositorAnimation::TargetProperty targetProperty;
         OwnPtr<CompositorAnimationCurve> curve;
         switch (property.cssProperty()) {
         case CSSPropertyOpacity: {
             targetProperty = CompositorAnimation::TargetPropertyOpacity;
 
-            CompositorFloatAnimationCurve* floatCurve = CompositorFactory::current().createFloatAnimationCurve();
+            OwnPtr<CompositorFloatAnimationCurve> floatCurve = CompositorFactory::current().createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values, timing);
             setTimingFunctionOnCurve(*floatCurve, timing.timingFunction.get());
-            curve = adoptPtr(floatCurve);
+            curve = floatCurve.release();
             break;
         }
         case CSSPropertyWebkitFilter:
         case CSSPropertyBackdropFilter: {
             targetProperty = CompositorAnimation::TargetPropertyFilter;
-            CompositorFilterAnimationCurve* filterCurve = CompositorFactory::current().createFilterAnimationCurve();
+            OwnPtr<CompositorFilterAnimationCurve> filterCurve = CompositorFactory::current().createFilterAnimationCurve();
             addKeyframesToCurve(*filterCurve, values, timing);
             setTimingFunctionOnCurve(*filterCurve, timing.timingFunction.get());
-            curve = adoptPtr(filterCurve);
+            curve = filterCurve.release();
             break;
         }
         case CSSPropertyRotate:
         case CSSPropertyScale:
         case CSSPropertyTranslate:
         case CSSPropertyTransform: {
             targetProperty = CompositorAnimation::TargetPropertyTransform;
-            CompositorTransformAnimationCurve* transformCurve = CompositorFactory::current().createTransformAnimationCurve();
+            OwnPtr<CompositorTransformAnimationCurve> transformCurve = CompositorFactory::current().createTransformAnimationCurve();
             addKeyframesToCurve(*transformCurve, values, timing);
             setTimingFunctionOnCurve(*transformCurve, timing.timingFunction.get());
-            curve = adoptPtr(transformCurve);
+            curve = transformCurve.release();
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             continue;
         }
         ASSERT(curve.get());
 
-        OwnPtr<CompositorAnimation> animation = adoptPtr(CompositorFactory::current().createAnimation(*curve, targetProperty, group, 0));
+        OwnPtr<CompositorAnimation> animation = CompositorFactory::current().createAnimation(*curve, targetProperty, group, 0);
 
         if (!std::isnan(startTime))
             animation->setStartTime(startTime);
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setIterationStart(compositorTiming.iterationStart);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
 
         switch (compositorTiming.direction) {
         case Timing::PlaybackDirectionNormal:
@@ skipping 28 matching lines @@
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink