Make all LayerAnimationElement::Create*Element return unique_ptr

ui/gfx/interpolated_transform.cc

 // 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.
 
 #include "ui/gfx/interpolated_transform.h"
 
 #include <cmath>
 
+#include "base/memory/ptr_util.h"
+
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
 #include "base/logging.h"
 #include "ui/gfx/animation/tween.h"
 
 namespace {
 
 static const double EPSILON = 1e-6;
@@ skipping 70 matching lines @@
 gfx::Transform InterpolatedTransform::Interpolate(float t) const {
   if (reversed_)
     t = 1.0f - t;
   gfx::Transform result = InterpolateButDoNotCompose(t);
   if (child_.get()) {
     result.ConcatTransform(child_->Interpolate(t));
   }
   return result;
 }
 
-void InterpolatedTransform::SetChild(InterpolatedTransform* child) {
-  child_.reset(child);
+void InterpolatedTransform::SetChild(
+    std::unique_ptr<InterpolatedTransform> child) {
+  child_ = std::move(child);
 }
 
 inline float InterpolatedTransform::ValueBetween(float time,
                                                  float start_value,
                                                  float end_value) const {
   // can't handle NaN
   DCHECK(time == time && start_time_ == start_time_ && end_time_ == end_time_);
   if (time != time || start_time_ != start_time_ || end_time_ != end_time_)
     return start_value;
 
@@ skipping 180 matching lines @@
   return transform_;
 }
 
 InterpolatedConstantTransform::~InterpolatedConstantTransform() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedTransformAboutPivot
 //
 
 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
-  const gfx::Point& pivot,
-  InterpolatedTransform* transform)
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> transform)
     : InterpolatedTransform() {
-  Init(pivot, transform);
+  Init(pivot, std::move(transform));
 }
 
 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
-  const gfx::Point& pivot,
-  InterpolatedTransform* transform,
-  float start_time,
-  float end_time)
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> transform,
+    float start_time,
+    float end_time)
     : InterpolatedTransform() {
-  Init(pivot, transform);
+  Init(pivot, std::move(transform));
 }
 
 InterpolatedTransformAboutPivot::~InterpolatedTransformAboutPivot() {}
 
 gfx::Transform
 InterpolatedTransformAboutPivot::InterpolateButDoNotCompose(float t) const {
   if (transform_.get()) {
     return transform_->Interpolate(t);
   }
   return gfx::Transform();
 }
 
-void InterpolatedTransformAboutPivot::Init(const gfx::Point& pivot,
-                                           InterpolatedTransform* xform) {
+void InterpolatedTransformAboutPivot::Init(
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> xform) {
   gfx::Transform to_pivot;
   gfx::Transform from_pivot;
   to_pivot.Translate(SkIntToMScalar(-pivot.x()), SkIntToMScalar(-pivot.y()));
   from_pivot.Translate(SkIntToMScalar(pivot.x()), SkIntToMScalar(pivot.y()));
 
-  std::unique_ptr<InterpolatedTransform> pre_transform(
-      new InterpolatedConstantTransform(to_pivot));
-  std::unique_ptr<InterpolatedTransform> post_transform(
-      new InterpolatedConstantTransform(from_pivot));
+  std::unique_ptr<InterpolatedTransform> pre_transform =
+      base::MakeUnique<InterpolatedConstantTransform>(to_pivot);
+  std::unique_ptr<InterpolatedTransform> post_transform =
+      base::MakeUnique<InterpolatedConstantTransform>(from_pivot);
 
-  pre_transform->SetChild(xform);
-  xform->SetChild(post_transform.release());
+  xform->SetChild(std::move(post_transform));
+  pre_transform->SetChild(std::move(xform));
   transform_ = std::move(pre_transform);
 }
 
 InterpolatedMatrixTransform::InterpolatedMatrixTransform(
     const gfx::Transform& start_transform,
     const gfx::Transform& end_transform)
     : InterpolatedTransform() {
   Init(start_transform, end_transform);
 }
 
@@ skipping 21 matching lines @@
 
 void InterpolatedMatrixTransform::Init(const gfx::Transform& start_transform,
                                        const gfx::Transform& end_transform) {
   bool success = gfx::DecomposeTransform(&start_decomp_, start_transform);
   DCHECK(success);
   success = gfx::DecomposeTransform(&end_decomp_, end_transform);
   DCHECK(success);
 }
 
 } // namespace ui