Make all LayerAnimationElement::Create*Element return unique_ptr

ui/compositor/layer_animator_unittest.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/compositor/layer_animator.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator_collection.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
@@ skipping 14 matching lines @@
 // space and the order if A R G B.
 std::string ColorToString(SkColor color) {
   return base::StringPrintf("%d %d %d %d", SkColorGetA(color),
                             SkColorGetR(color), SkColorGetG(color),
                             SkColorGetB(color));
 }
 
 // Creates vector with two LayerAnimationSequences, based on |first| and
 // |second| layer animation elements.
 std::vector<LayerAnimationSequence*> CreateMultiSequence(
-    LayerAnimationElement* first,
-    LayerAnimationElement* second) {
+    std::unique_ptr<LayerAnimationElement> first,
+    std::unique_ptr<LayerAnimationElement> second) {
   LayerAnimationSequence* first_sequence = new LayerAnimationSequence();
-  first_sequence->AddElement(first);
+  first_sequence->AddElement(std::move(first));
   LayerAnimationSequence* second_sequence = new LayerAnimationSequence();
-  second_sequence->AddElement(second);
+  second_sequence->AddElement(std::move(second));
 
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(first_sequence);
   animations.push_back(second_sequence);
   return animations;
 }
 
 // Creates a default animator with timers disabled for test. |delegate| and
 // |observer| are attached if non-null.
 LayerAnimator* CreateDefaultTestAnimator(LayerAnimationDelegate* delegate,
@@ skipping 172 matching lines @@
  private:
   LayerAnimatorDestructionObserver* destruction_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimator);
 };
 
 // The test layer animation sequence updates a live instances count when it is
 // created and destroyed.
 class TestLayerAnimationSequence : public LayerAnimationSequence {
  public:
-  TestLayerAnimationSequence(LayerAnimationElement* element,
+  TestLayerAnimationSequence(std::unique_ptr<LayerAnimationElement> element,
                              int* num_live_instances)
-      : LayerAnimationSequence(element),
+      : LayerAnimationSequence(std::move(element)),
         num_live_instances_(num_live_instances) {
     (*num_live_instances_)++;
   }
 
   ~TestLayerAnimationSequence() override { (*num_live_instances_)--; }
 
  private:
   int* num_live_instances_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationSequence);
@@ skipping 1841 matching lines @@
   TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
-  std::unique_ptr<LayerAnimationSequence> sequence(new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+  std::unique_ptr<LayerAnimationSequence> sequence =
+      base::MakeUnique<LayerAnimationSequence>(
+          LayerAnimationElement::CreateOpacityElement(target_opacity, delta));
 
   animator->StartAnimation(sequence.release());
 
   animator->SetOpacity(0.5);
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(0.5, animator->GetTargetOpacity());
 }
 
 // Tests that the preemption mode IMMEDIATELY_SET_NEW_TARGET, doesn't cause the
@@ skipping 12 matching lines @@
   {
     // start an implicit bounds animation.
     ScopedLayerAnimationSettings settings(animator.get());
     animator->SetBounds(middle_bounds);
   }
 
   EXPECT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   int num_live_instances = 0;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
-  std::unique_ptr<TestLayerAnimationSequence> sequence(
-      new TestLayerAnimationSequence(
+  std::unique_ptr<TestLayerAnimationSequence> sequence =
+      base::MakeUnique<TestLayerAnimationSequence>(
           LayerAnimationElement::CreateBoundsElement(target_bounds, delta),
-          &num_live_instances));
+          &num_live_instances);
 
   EXPECT_EQ(1, num_live_instances);
 
   // This should interrupt the running sequence causing us to immediately set
   // the target value. The sequence should alse be destructed.
   animator->StartAnimation(sequence.release());
 
   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
   EXPECT_EQ(0, num_live_instances);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
@@ skipping 792 matching lines @@
   EXPECT_EQ(observer.last_ended_sequence(), nullptr);
   EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
 
   EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
   EXPECT_TRUE(observer.AbortedEpochIsBeforeStartedEpoch());
   EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
   EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
 }
 
 }  // namespace ui