Replace scoped_ptr with std::unique_ptr in //ui

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 "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "cc/animation/animation_events.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"
@@ skipping 552 matching lines @@
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBoundsFromAnimation(start_bounds);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
                                                         delta)));
 
-  scoped_ptr<LayerAnimationSequence> bounds_and_grayscale(
-      new LayerAnimationSequence(
-          LayerAnimationElement::CreateGrayscaleElement(start_grayscale,
-                                                        delta)));
+  std::unique_ptr<LayerAnimationSequence> bounds_and_grayscale(
+      new LayerAnimationSequence(LayerAnimationElement::CreateGrayscaleElement(
+          start_grayscale, delta)));
 
   bounds_and_grayscale->AddElement(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
 
   animator->ScheduleAnimation(bounds_and_grayscale.release());
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(start_bounds, delta)));
 
@@ skipping 784 matching lines @@
   TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(CreateDefaultTestAnimator(&delegate));
 
   double start_brightness(0.0);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
-  scoped_ptr<LayerAnimationSequence> sequence(
-      new LayerAnimationSequence(
-          LayerAnimationElement::CreateBrightnessElement(target_brightness,
-                                                         delta)));
+  std::unique_ptr<LayerAnimationSequence> sequence(
+      new LayerAnimationSequence(LayerAnimationElement::CreateBrightnessElement(
+          target_brightness, delta)));
 
   sequence->AddElement(
       LayerAnimationElement::CreateBrightnessElement(start_brightness, delta));
 
   sequence->set_is_cyclic(true);
 
   animator->StartAnimation(sequence.release());
 
   base::TimeTicks start_time = animator->last_step_time();
 
@@ skipping 36 matching lines @@
       CreateDefaultTestAnimator(&delegate));
   LayerAnimator* animator = test_controller.animator();
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
-  scoped_ptr<LayerAnimationSequence> sequence(
-      new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+  std::unique_ptr<LayerAnimationSequence> sequence(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   sequence->AddElement(
       LayerAnimationElement::CreateOpacityElement(start_opacity, delta));
 
   sequence->set_is_cyclic(true);
 
   test_controller.animator()->StartAnimation(sequence.release());
 
   base::TimeTicks start_time = test_controller.animator()->last_step_time();
   base::TimeTicks effective_start = start_time + delta;
@@ skipping 268 matching lines @@
   base::TimeTicks start_time = animator->last_step_time();
 
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
   TestLayerAnimationDelegate delegate;
-  scoped_ptr<TestLayerAnimationObserver> observer(
+  std::unique_ptr<TestLayerAnimationObserver> observer(
       new TestLayerAnimationObserver);
   scoped_refptr<LayerAnimator> animator(
       CreateDefaultTestAnimator(&delegate, observer.get()));
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
 
@@ skipping 94 matching lines @@
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(5, 5, 5, 5);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
   delegate.SetBoundsFromAnimation(start_bounds);
 
   base::TimeDelta brightness_delta = base::TimeDelta::FromSeconds(1);
   base::TimeDelta halfway_delta = base::TimeDelta::FromSeconds(2);
   base::TimeDelta bounds_delta = base::TimeDelta::FromSeconds(3);
 
-  scoped_ptr<DeletingLayerAnimationObserver> observer(
+  std::unique_ptr<DeletingLayerAnimationObserver> observer(
       new DeletingLayerAnimationObserver(animator.get()));
 
   animator->AddObserver(observer.get());
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(
               target_brightness, brightness_delta)));
 
   animator->StartAnimation(new LayerAnimationSequence(
@@ skipping 86 matching lines @@
   double start_brightness(0.0);
   double target_brightness(1.0);
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(5, 5, 5, 5);
   base::TimeDelta brightness_delta = base::TimeDelta::FromSeconds(1);
   base::TimeDelta bounds_delta = base::TimeDelta::FromSeconds(2);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
   delegate.SetBoundsFromAnimation(start_bounds);
 
-  scoped_ptr<DeletingLayerAnimationObserver> observer(
+  std::unique_ptr<DeletingLayerAnimationObserver> observer(
       new DeletingLayerAnimationObserver(animator.get()));
   animator->AddObserver(observer.get());
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(
               target_brightness, brightness_delta)));
   animator->StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(
           target_bounds, bounds_delta)));
@@ skipping 20 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);
 
-  scoped_ptr<LayerAnimationSequence> sequence(
-      new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+  std::unique_ptr<LayerAnimationSequence> sequence(new 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);
-  scoped_ptr<TestLayerAnimationSequence> sequence(
+  std::unique_ptr<TestLayerAnimationSequence> sequence(
       new TestLayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(target_bounds, delta),
           &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());
 
@@ skipping 169 matching lines @@
     if (delete_on_animation_aborted_)
       delete this;
   }
 
   void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {
     if (delete_on_animation_scheduled_)
       delete this;
   }
 
 private:
-  scoped_ptr<AnimatorOwner> animator_owner_;
-  bool delete_on_animation_ended_;
-  bool delete_on_animation_aborted_;
-  bool delete_on_animation_scheduled_;
-  bool* was_deleted_;
+ std::unique_ptr<AnimatorOwner> animator_owner_;
+ bool delete_on_animation_ended_;
+ bool delete_on_animation_aborted_;
+ bool delete_on_animation_scheduled_;
+ bool* was_deleted_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeletingObserver);
+ DISALLOW_COPY_AND_ASSIGN(DeletingObserver);
 };
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterFinishingAnimation) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 226 matching lines @@
   EXPECT_FALSE(animator->is_started_);
 
   CollectionLayerAnimationDelegate collection_delegate;
   animator->SetDelegate(&collection_delegate);
   animator->UpdateAnimationState();
   EXPECT_TRUE(animator->is_started_);
   animator->SetDelegate(NULL);
 }
 
 TEST(LayerAnimatorTest, AnimatorRemovedFromCollectionWhenLayerIsDestroyed) {
-  scoped_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
+  std::unique_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
   LayerAnimatorTestController test_controller(layer->GetAnimator());
   scoped_refptr<LayerAnimator> animator = test_controller.animator();
   CollectionLayerAnimationDelegate collection_delegate;
   animator->SetDelegate(&collection_delegate);
 
   double target_opacity = 1.0;
   base::TimeDelta time_delta = base::TimeDelta::FromSeconds(1);
   animator->ScheduleAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(target_opacity, time_delta)));
 
   EXPECT_TRUE(
       collection_delegate.GetLayerAnimatorCollection()->HasActiveAnimators());
 
   layer.reset();
   EXPECT_EQ(NULL, animator->delegate());
   EXPECT_FALSE(
       collection_delegate.GetLayerAnimatorCollection()->HasActiveAnimators());
 }
 
 TEST(LayerAnimatorTest, LayerMovedBetweenCompositorsDuringAnimation) {
   bool enable_pixel_output = false;
   ui::ContextFactory* context_factory =
       InitializeContextFactoryForTests(enable_pixel_output);
   const gfx::Rect bounds(10, 10, 100, 100);
-  scoped_ptr<TestCompositorHost> host_1(
+  std::unique_ptr<TestCompositorHost> host_1(
       TestCompositorHost::Create(bounds, context_factory));
-  scoped_ptr<TestCompositorHost> host_2(
+  std::unique_ptr<TestCompositorHost> host_2(
       TestCompositorHost::Create(bounds, context_factory));
   host_1->Show();
   host_2->Show();
 
   Compositor* compositor_1 = host_1->GetCompositor();
   Layer root_1;
   compositor_1->SetRootLayer(&root_1);
 
   Compositor* compositor_2 = host_2->GetCompositor();
   Layer root_2;
@@ skipping 25 matching lines @@
   host_2.reset();
   host_1.reset();
   TerminateContextFactoryForTests();
 }
 
 TEST(LayerAnimatorTest, ThreadedAnimationSurvivesIfLayerRemovedAdded) {
   bool enable_pixel_output = false;
   ui::ContextFactory* context_factory =
       InitializeContextFactoryForTests(enable_pixel_output);
   const gfx::Rect bounds(10, 10, 100, 100);
-  scoped_ptr<TestCompositorHost> host(
+  std::unique_ptr<TestCompositorHost> host(
       TestCompositorHost::Create(bounds, context_factory));
   host->Show();
 
   Compositor* compositor = host->GetCompositor();
 
   Layer root;
   compositor->SetRootLayer(&root);
 
   Layer layer;
   root.Add(&layer);
@@ skipping 35 matching lines @@
     animator_layer_.reset();
   }
 
   LayerAnimationDelegate* animator_layer() {
     return animator_layer_.get();
   }
 
   void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {}
 
  private:
-  scoped_ptr<Layer> animator_layer_;
+  std::unique_ptr<Layer> animator_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerOwnerAnimationObserver);
 };
 
 TEST(LayerAnimatorTest, ObserverDeletesLayerInStopAnimating) {
   scoped_refptr<LayerAnimator> animator(CreateImplicitTestAnimator());
   LayerOwnerAnimationObserver observer(animator.get());
   LayerAnimationDelegate* delegate = observer.animator_layer();
 
   const gfx::Rect start_bounds(0, 0, 50, 50);
@@ skipping 217 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