Make all LayerAnimationElement::Create*Element return unique_ptr

ash/rotator/screen_rotation_animator.cc

 // Copyright 2015 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 "ash/rotator/screen_rotation_animator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/rotator/screen_rotation_animation.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_manager.h"
@@ skipping 164 matching lines @@
   // layer was added as a child to |root_window|'s layer so that it will be
   // rendered.
   // TODO(bruthig): Add a NOT_DRAWN layer in between the root_window's layer and
   // its current children so that we only need to initiate two
   // LayerAnimationSequences. One for the new layers and one for the old layer.
   for (ui::Layer* child_layer : root_window->layer()->children()) {
     // Skip the cloned layer because it has a different animation.
     if (child_layer == layer_cleanup_observer->GetRootLayer())
       continue;
 
-    std::unique_ptr<ScreenRotationAnimation> screen_rotation(
-        new ScreenRotationAnimation(
+    std::unique_ptr<ScreenRotationAnimation> screen_rotation =
+        base::MakeUnique<ScreenRotationAnimation>(
             child_layer, kRotationDegrees * rotation_factor,
             0 /* end_degrees */, child_layer->opacity(),
-            1.0f /* target_opacity */, pivot, duration, tween_type));
+            1.0f /* target_opacity */, pivot, duration, tween_type);
 
     ui::LayerAnimator* animator = child_layer->GetAnimator();
     animator->set_preemption_strategy(
         ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-    std::unique_ptr<ui::LayerAnimationSequence> animation_sequence(
-        new ui::LayerAnimationSequence(screen_rotation.release()));
+    std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
+        base::MakeUnique<ui::LayerAnimationSequence>(
+            std::move(screen_rotation));
     animator->StartAnimation(animation_sequence.release());
   }
 
   // The old layer will also be transformed into the new orientation. We will
   // translate it so that the old layer's center point aligns with the new
   // orientation's center point and use that center point as the pivot for the
   // rotation animation.
   gfx::Transform translate_transform;
   translate_transform.Translate(
       (rotated_screen_bounds.width() - original_screen_bounds.width()) / 2,
       (rotated_screen_bounds.height() - original_screen_bounds.height()) / 2);
   layer_cleanup_observer->GetRootLayer()->SetTransform(translate_transform);
 
-  std::unique_ptr<ScreenRotationAnimation> screen_rotation(
-      new ScreenRotationAnimation(
+  std::unique_ptr<ScreenRotationAnimation> screen_rotation =
+      base::MakeUnique<ScreenRotationAnimation>(
           layer_cleanup_observer->GetRootLayer(),
           old_layer_initial_rotation_degrees * rotation_factor,
           (old_layer_initial_rotation_degrees - kRotationDegrees) *
               rotation_factor,
           layer_cleanup_observer->GetRootLayer()->opacity(),
-          0.0f /* target_opacity */, pivot, duration, tween_type));
+          0.0f /* target_opacity */, pivot, duration, tween_type);
 
   ui::LayerAnimator* animator =
       layer_cleanup_observer->GetRootLayer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-  std::unique_ptr<ui::LayerAnimationSequence> animation_sequence(
-      new ui::LayerAnimationSequence(screen_rotation.release()));
+  std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
+      base::MakeUnique<ui::LayerAnimationSequence>(std::move(screen_rotation));
   // Add an observer so that the cloned layers can be cleaned up with the
   // animation completes/aborts.
   animation_sequence->AddObserver(layer_cleanup_observer.release());
   animator->StartAnimation(animation_sequence.release());
 }
 
 }  // namespace
 
 ScreenRotationAnimator::ScreenRotationAnimator(int64_t display_id)
     : display_id_(display_id) {}
@@ skipping 12 matching lines @@
   const display::Display::Rotation current_rotation =
       GetCurrentRotation(display_id_);
 
   if (current_rotation == new_rotation)
     return;
 
   RotateScreen(display_id_, new_rotation, source);
 }
 
 }  // namespace ash