Make all LayerAnimationElement::Create*Element return unique_ptr

ui/gfx/interpolated_transform.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_GFX_INTERPOLATED_TRANSFORM_H_
 #define UI_GFX_INTERPOLATED_TRANSFORM_H_
 
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 namespace ui {
 
 ///////////////////////////////////////////////////////////////////////////////
 // class InterpolatedTransform
@@ skipping 14 matching lines @@
   InterpolatedTransform(float start_time, float end_time);
   virtual ~InterpolatedTransform();
 
   // Returns the interpolated transform at time t. Note: not virtual.
   gfx::Transform Interpolate(float t) const;
 
   // The Intepolate ultimately returns the product of our transform at time t
   // and our child's transform at time t (if we have one).
   //
   // This function takes ownership of the passed InterpolatedTransform.
-  void SetChild(InterpolatedTransform* child);
+  void SetChild(std::unique_ptr<InterpolatedTransform> child);
 
   // If the interpolated transform is reversed, Interpolate(t) will return
   // Interpolate(1 - t)
   void SetReversed(bool reversed) { reversed_ = reversed; }
   bool Reversed() const { return reversed_; }
 
  protected:
   // Calculates the interpolated transform without considering our child.
   virtual gfx::Transform InterpolateButDoNotCompose(float t) const = 0;
 
@@ skipping 160 matching lines @@
 //
 // Represents an animated transform with a transformed origin. Essentially,
 // at each time, t, the interpolated transform is created by composing
 // P * T * P^-1 where P is a constant transform to the new origin.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class GFX_EXPORT InterpolatedTransformAboutPivot
     : public InterpolatedTransform {
  public:
   // Takes ownership of the passed transform.
-  InterpolatedTransformAboutPivot(const gfx::Point& pivot,
-                                  InterpolatedTransform* transform);
+  InterpolatedTransformAboutPivot(
+      const gfx::Point& pivot,
+      std::unique_ptr<InterpolatedTransform> transform);
 
   // Takes ownership of the passed transform.
-  InterpolatedTransformAboutPivot(const gfx::Point& pivot,
-                                  InterpolatedTransform* transform,
-                                  float start_time,
-                                  float end_time);
+  InterpolatedTransformAboutPivot(
+      const gfx::Point& pivot,
+      std::unique_ptr<InterpolatedTransform> transform,
+      float start_time,
+      float end_time);
   ~InterpolatedTransformAboutPivot() override;
 
  protected:
   gfx::Transform InterpolateButDoNotCompose(float t) const override;
 
  private:
-  void Init(const gfx::Point& pivot, InterpolatedTransform* transform);
+  void Init(const gfx::Point& pivot,
+            std::unique_ptr<InterpolatedTransform> transform);
 
   std::unique_ptr<InterpolatedTransform> transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformAboutPivot);
 };
 
 class GFX_EXPORT InterpolatedMatrixTransform : public InterpolatedTransform {
  public:
   InterpolatedMatrixTransform(const gfx::Transform& start_transform,
                               const gfx::Transform& end_transform);
@@ skipping 12 matching lines @@
   void Init(const gfx::Transform& start_transform,
             const gfx::Transform& end_transform);
 
   gfx::DecomposedTransform start_decomp_;
   gfx::DecomposedTransform end_decomp_;
 };
 
 } // namespace ui
 
 #endif  // UI_GFX_INTERPOLATED_TRANSFORM_H_