Make all LayerAnimationElement::Create*Element return unique_ptr

ui/compositor/layer_animation_element.cc

Index: ui/compositor/layer_animation_element.cc
diff --git a/ui/compositor/layer_animation_element.cc b/ui/compositor/layer_animation_element.cc
index 1e9f93fd7bc7510b66d57e22fda1aa6174343260..e3dca785161661f47ad48daf45d1a09faef1c4bb 100644
--- a/ui/compositor/layer_animation_element.cc
+++ b/ui/compositor/layer_animation_element.cc
@@ -52,11 +52,11 @@ class Pause : public LayerAnimationElement {
 
 class InterpolatedTransformTransition : public LayerAnimationElement {
  public:
-  InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
-                                  base::TimeDelta duration)
+  InterpolatedTransformTransition(
+      std::unique_ptr<InterpolatedTransform> interpolated_transform,
+      base::TimeDelta duration)
       : LayerAnimationElement(TRANSFORM, duration),
-        interpolated_transform_(interpolated_transform) {
-  }
+        interpolated_transform_(std::move(interpolated_transform)) {}
   ~InterpolatedTransformTransition() override {}
 
  protected:
@@ -598,67 +598,68 @@ base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
-    const gfx::Transform& transform,
-    base::TimeDelta duration) {
-  return new ThreadedTransformTransition(transform, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateTransformElement(const gfx::Transform& transform,
+                                              base::TimeDelta duration) {
+  return base::MakeUnique<ThreadedTransformTransition>(transform, duration);

[loyso (OOO), 2016/12/13 02:24:49]

Looks like this file doesn't 
#include "base/memory/ptr_util.h"
for base::MakeUnique.
Could you make sure that we include <memory> for unique_ptr and ptr_util.h for
MakeUnique?
Thanks in advance!

 }
 
 // static
-LayerAnimationElement*
+std::unique_ptr<LayerAnimationElement>
 LayerAnimationElement::CreateInterpolatedTransformElement(
-    InterpolatedTransform* interpolated_transform,
+    std::unique_ptr<InterpolatedTransform> interpolated_transform,
     base::TimeDelta duration) {
-  return new InterpolatedTransformTransition(interpolated_transform, duration);
+  return base::MakeUnique<InterpolatedTransformTransition>(
+      std::move(interpolated_transform), duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateBoundsElement(
-    const gfx::Rect& bounds,
-    base::TimeDelta duration) {
-  return new BoundsTransition(bounds, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateBoundsElement(const gfx::Rect& bounds,
+                                           base::TimeDelta duration) {
+  return base::MakeUnique<BoundsTransition>(bounds, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateOpacityElement(
-    float opacity,
-    base::TimeDelta duration) {
-  return new ThreadedOpacityTransition(opacity, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateOpacityElement(float opacity,
+                                            base::TimeDelta duration) {
+  return base::MakeUnique<ThreadedOpacityTransition>(opacity, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement(
-    bool visibility,
-    base::TimeDelta duration) {
-  return new VisibilityTransition(visibility, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateVisibilityElement(bool visibility,
+                                               base::TimeDelta duration) {
+  return base::MakeUnique<VisibilityTransition>(visibility, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateBrightnessElement(
-    float brightness,
-    base::TimeDelta duration) {
-  return new BrightnessTransition(brightness, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateBrightnessElement(float brightness,
+                                               base::TimeDelta duration) {
+  return base::MakeUnique<BrightnessTransition>(brightness, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement(
-    float grayscale,
-    base::TimeDelta duration) {
-  return new GrayscaleTransition(grayscale, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateGrayscaleElement(float grayscale,
+                                              base::TimeDelta duration) {
+  return base::MakeUnique<GrayscaleTransition>(grayscale, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
-    AnimatableProperties properties,
-    base::TimeDelta duration) {
-  return new Pause(properties, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreatePauseElement(AnimatableProperties properties,
+                                          base::TimeDelta duration) {
+  return base::MakeUnique<Pause>(properties, duration);
 }
 
 // static
-LayerAnimationElement* LayerAnimationElement::CreateColorElement(
-    SkColor color,
-    base::TimeDelta duration) {
-  return new ColorTransition(color, duration);
+std::unique_ptr<LayerAnimationElement>
+LayerAnimationElement::CreateColorElement(SkColor color,
+                                          base::TimeDelta duration) {
+  return base::MakeUnique<ColorTransition>(color, duration);
 }
 
 }  // namespace ui