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

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 599 matching lines @@
         // 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());
             toCompositorFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
 
-            CompositorFilterKeyframe filterKeyframe(keyframe->offset(), ops.release());
+            CompositorFilterKeyframe filterKeyframe(keyframe->offset(), std::move(ops));
             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());
             toCompositorTransformOperations(toAnimatableTransform(value)->transformOperations(), ops.get());
 
-            CompositorTransformKeyframe transformKeyframe(keyframe->offset(), ops.release());
+            CompositorTransformKeyframe transformKeyframe(keyframe->offset(), std::move(ops));
             CompositorTransformAnimationCurve* transformCurve = static_cast<CompositorTransformAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*transformCurve, transformKeyframe, keyframeTimingFunction);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
@@ skipping 91 matching lines @@
             break;
         case Timing::FillModeBackwards:
             animation->setFillMode(CompositorAnimation::FillModeBackwards);
             break;
         case Timing::FillModeBoth:
             animation->setFillMode(CompositorAnimation::FillModeBoth);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
-        animations.append(animation.release());
+        animations.append(std::move(animation));
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink