Make all LayerAnimationElement::Create*Element return unique_ptr

ui/views/animation/flood_fill_ink_drop_ripple.cc

 // Copyright 2016 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/views/animation/flood_fill_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 282 matching lines @@
 void FloodFillInkDropRipple::AnimateToTransform(
     const gfx::Transform& transform,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   ui::LayerAnimator* animator = painted_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetPreemptionStrategy(preemption_strategy);
   animation.SetTweenType(tween);
-  ui::LayerAnimationElement* element =
+
+  std::unique_ptr<ui::LayerAnimationElement> element =
       ui::LayerAnimationElement::CreateTransformElement(transform, duration);
+
   ui::LayerAnimationSequence* sequence =
-      new ui::LayerAnimationSequence(element);
+      new ui::LayerAnimationSequence(std::move(element));
 
   if (animation_observer)
     sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(sequence);
 }
 
 void FloodFillInkDropRipple::SetOpacity(float opacity) {
   root_layer_.SetOpacity(opacity);
 }
 
 void FloodFillInkDropRipple::AnimateToOpacity(
     float opacity,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   ui::LayerAnimator* animator = root_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation_settings(animator);
   animation_settings.SetPreemptionStrategy(preemption_strategy);
   animation_settings.SetTweenType(tween);
-  ui::LayerAnimationElement* animation_element =
+  std::unique_ptr<ui::LayerAnimationElement> animation_element =
       ui::LayerAnimationElement::CreateOpacityElement(opacity, duration);
   ui::LayerAnimationSequence* animation_sequence =
-      new ui::LayerAnimationSequence(animation_element);
+      new ui::LayerAnimationSequence(std::move(animation_element));
 
   if (animation_observer)
     animation_sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(animation_sequence);
 }
 
 gfx::Transform FloodFillInkDropRipple::CalculateTransform(
     float target_radius) const {
   const float target_scale = target_radius / circle_layer_delegate_.radius();
@@ skipping 24 matching lines @@
       (bounds.bottom_right() - point).Length();
 
   float largest_distance =
       std::max(distance_to_top_left, distance_to_top_right);
   largest_distance = std::max(largest_distance, distance_to_bottom_left);
   largest_distance = std::max(largest_distance, distance_to_bottom_right);
   return largest_distance;
 }
 
 }  // namespace views