Make all LayerAnimationElement::Create*Element return unique_ptr

ui/compositor/layer_animation_element.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <set>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "cc/animation/animation.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 43 matching lines @@
 
   typedef uint32_t AnimatableProperties;
 
   LayerAnimationElement(AnimatableProperties properties,
                         base::TimeDelta duration);
 
   virtual ~LayerAnimationElement();
 
   // Creates an element that transitions to the given transform. The caller owns
   // the return value.
-  static LayerAnimationElement* CreateTransformElement(
+  static std::unique_ptr<LayerAnimationElement> CreateTransformElement(
       const gfx::Transform& transform,
       base::TimeDelta duration);
 
   // Creates an element that transitions to another in a way determined by an
   // interpolated transform. The element accepts ownership of the interpolated
   // transform. NB: at every step, the interpolated transform clobbers the
   // existing transform. That is, it does not interpolate between the existing
   // transform and the last value the interpolated transform will assume. It is
   // therefore important that the value of the interpolated at time 0 matches
   // the current transform.
-  static LayerAnimationElement* CreateInterpolatedTransformElement(
-      InterpolatedTransform* interpolated_transform,
+  static std::unique_ptr<LayerAnimationElement>
+  CreateInterpolatedTransformElement(
+      std::unique_ptr<InterpolatedTransform> interpolated_transform,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given bounds. The caller owns
   // the return value.
-  static LayerAnimationElement* CreateBoundsElement(
+  static std::unique_ptr<LayerAnimationElement> CreateBoundsElement(
       const gfx::Rect& bounds,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given opacity. The caller owns
   // the return value.
-  static LayerAnimationElement* CreateOpacityElement(
+  static std::unique_ptr<LayerAnimationElement> CreateOpacityElement(
       float opacity,
       base::TimeDelta duration);
 
   // Creates an element that sets visibily following a delay. The caller owns
   // the return value.
-  static LayerAnimationElement* CreateVisibilityElement(
+  static std::unique_ptr<LayerAnimationElement> CreateVisibilityElement(
       bool visibility,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given brightness.
   // The caller owns the return value.
-  static LayerAnimationElement* CreateBrightnessElement(
+  static std::unique_ptr<LayerAnimationElement> CreateBrightnessElement(
       float brightness,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given grayscale value.
   // The caller owns the return value.
-  static LayerAnimationElement* CreateGrayscaleElement(
+  static std::unique_ptr<LayerAnimationElement> CreateGrayscaleElement(
       float grayscale,
       base::TimeDelta duration);
 
   // Creates an element that pauses the given properties. The caller owns the
   // return value.
-  static LayerAnimationElement* CreatePauseElement(
+  static std::unique_ptr<LayerAnimationElement> CreatePauseElement(
       AnimatableProperties properties,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given color. The caller owns the
   // return value.
-  static LayerAnimationElement* CreateColorElement(
+  static std::unique_ptr<LayerAnimationElement> CreateColorElement(
       SkColor color,
       base::TimeDelta duration);
 
   // Sets the start time for the animation. This must be called before the first
   // call to {Start, IsFinished}. Once the animation is finished, this must
   // be called again in order to restart the animation.
   void set_requested_start_time(base::TimeTicks start_time) {
     requested_start_time_ = start_time;
   }
   base::TimeTicks requested_start_time() const { return requested_start_time_; }
@@ skipping 90 matching lines @@
   double last_progressed_fraction_;
 
   base::WeakPtrFactory<LayerAnimationElement> weak_ptr_factory_;
 
   DISALLOW_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_