Replace scoped_ptr with std::unique_ptr in //ui

ui/compositor/layer_animator.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 <stddef.h>
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/output/begin_frame_args.h"
@@ skipping 59 matching lines @@
   return new LayerAnimator(
       base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
 }
 
 // This macro provides the implementation for the setter and getter (well,
 // the getter of the target value) for an animated property. For example,
 // it is used for the implementations of SetTransform and GetTargetTransform.
 // It is worth noting that SetFoo avoids invoking the usual animation machinery
 // if the transition duration is zero -- in this case we just set the property
 // on the layer animation delegate immediately.
-#define ANIMATED_PROPERTY(type, property, name, member_type, member)  \
-void LayerAnimator::Set##name(type value) {                           \
-  base::TimeDelta duration = GetTransitionDuration();                 \
-  if (duration == base::TimeDelta() && delegate() &&                  \
-      (preemption_strategy_ != ENQUEUE_NEW_ANIMATION)) {              \
-    StopAnimatingProperty(LayerAnimationElement::property);           \
-    delegate()->Set##name##FromAnimation(value);                      \
-    return;                                                           \
-  }                                                                   \
-  scoped_ptr<LayerAnimationElement> element(                          \
-      LayerAnimationElement::Create##name##Element(value, duration)); \
-  element->set_tween_type(tween_type_);                               \
-  StartAnimation(new LayerAnimationSequence(element.release()));      \
-}                                                                     \
-                                                                      \
-member_type LayerAnimator::GetTarget##name() const {                  \
-  LayerAnimationElement::TargetValue target(delegate());              \
-  GetTargetValue(&target);                                            \
-  return target.member;                                               \
-}
+#define ANIMATED_PROPERTY(type, property, name, member_type, member)    \
+  void LayerAnimator::Set##name(type value) {                           \
+    base::TimeDelta duration = GetTransitionDuration();                 \
+    if (duration == base::TimeDelta() && delegate() &&                  \
+        (preemption_strategy_ != ENQUEUE_NEW_ANIMATION)) {              \
+      StopAnimatingProperty(LayerAnimationElement::property);           \
+      delegate()->Set##name##FromAnimation(value);                      \
+      return;                                                           \
+    }                                                                   \
+    std::unique_ptr<LayerAnimationElement> element(                     \
+        LayerAnimationElement::Create##name##Element(value, duration)); \
+    element->set_tween_type(tween_type_);                               \
+    StartAnimation(new LayerAnimationSequence(element.release()));      \
+  }                                                                     \
+                                                                        \
+  member_type LayerAnimator::GetTarget##name() const {                  \
+    LayerAnimationElement::TargetValue target(delegate());              \
+    GetTargetValue(&target);                                            \
+    return target.member;                                               \
+  }
 
 ANIMATED_PROPERTY(
     const gfx::Transform&, TRANSFORM, Transform, gfx::Transform, transform);
 ANIMATED_PROPERTY(const gfx::Rect&, BOUNDS, Bounds, gfx::Rect, bounds);
 ANIMATED_PROPERTY(float, OPACITY, Opacity, float, opacity);
 ANIMATED_PROPERTY(bool, VISIBILITY, Visibility, bool, visibility);
 ANIMATED_PROPERTY(float, BRIGHTNESS, Brightness, float, brightness);
 ANIMATED_PROPERTY(float, GRAYSCALE, Grayscale, float, grayscale);
 ANIMATED_PROPERTY(SkColor, COLOR, Color, SkColor, color);
 
@@ skipping 85 matching lines @@
   if (animation_player_->element_animations()) {
     animation_player_->element_animations()
         ->layer_animation_controller()
         ->RemoveEventObserver(this);
   }
 
   if (animation_player_->layer_id())
     animation_player_->DetachLayer();
 }
 
-void LayerAnimator::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
+void LayerAnimator::AddThreadedAnimation(
+    std::unique_ptr<cc::Animation> animation) {
   animation_player_->AddAnimation(std::move(animation));
 }
 
 void LayerAnimator::RemoveThreadedAnimation(int animation_id) {
   animation_player_->RemoveAnimation(animation_id);
 }
 
 bool LayerAnimator::HasPendingThreadedAnimationsForTesting() const {
   return animation_player_->has_pending_animations_for_testing();
 }
@@ skipping 383 matching lines @@
         (*queue_iter)->Start(delegate());
       }
     }
   }
   return to_return.release();
 }
 
 void LayerAnimator::FinishAnimation(
     LayerAnimationSequence* sequence, bool abort) {
   scoped_refptr<LayerAnimator> retain(this);
-  scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequence));
+  std::unique_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequence));
   if (abort)
     sequence->Abort(delegate());
   else
     ProgressAnimationToEnd(sequence);
   if (!delegate())
     return;
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::FinishAnyAnimationWithZeroDuration() {
   scoped_refptr<LayerAnimator> retain(this);
   // Special case: if we've started a 0 duration animation, just finish it now
   // and get rid of it. We need to make a copy because Progress may indirectly
   // cause new animations to start running.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     if (running_animations_copy[i].sequence()->IsFinished(
           running_animations_copy[i].sequence()->start_time())) {
       SAFE_INVOKE_VOID(ProgressAnimationToEnd, running_animations_copy[i]);
-      scoped_ptr<LayerAnimationSequence> removed(
+      std::unique_ptr<LayerAnimationSequence> removed(
           SAFE_INVOKE_PTR(RemoveAnimation, running_animations_copy[i]));
     }
   }
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::ClearAnimations() {
   scoped_refptr<LayerAnimator> retain(this);
   ClearAnimationsInternal();
@@ skipping 31 matching lines @@
   // progress them to the end and remove them. Note, Aborting or Progressing
   // animations may affect the collection of running animations, so we need to
   // operate on a copy.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     if (running_animations_copy[i].sequence()->HasConflictingProperty(
             sequence->properties())) {
-      scoped_ptr<LayerAnimationSequence> removed(
+      std::unique_ptr<LayerAnimationSequence> removed(
           SAFE_INVOKE_PTR(RemoveAnimation, running_animations_copy[i]));
       if (abort)
         running_animations_copy[i].sequence()->Abort(delegate());
       else
         SAFE_INVOKE_VOID(ProgressAnimationToEnd, running_animations_copy[i]);
     }
   }
 
   // Same for the queued animations that haven't been started. Again, we'll
   // need to operate on a copy.
   std::vector<base::WeakPtr<LayerAnimationSequence> > sequences;
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter)
     sequences.push_back((*queue_iter)->AsWeakPtr());
 
   for (size_t i = 0; i < sequences.size(); ++i) {
     if (!sequences[i].get() || !HasAnimation(sequences[i].get()))
       continue;
 
     if (sequences[i]->HasConflictingProperty(sequence->properties())) {
-      scoped_ptr<LayerAnimationSequence> removed(
+      std::unique_ptr<LayerAnimationSequence> removed(
           RemoveAnimation(sequences[i].get()));
       if (abort)
         sequences[i]->Abort(delegate());
       else
         ProgressAnimationToEnd(sequences[i].get());
     }
   }
 }
 
 void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
@@ skipping 196 matching lines @@
 void LayerAnimator::ClearAnimationsInternal() {
   PurgeDeletedAnimations();
 
   // Abort should never affect the set of running animations, but just in case
   // clients are badly behaved, we will use a copy of the running animations.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
-    scoped_ptr<LayerAnimationSequence> removed(
+    std::unique_ptr<LayerAnimationSequence> removed(
         RemoveAnimation(running_animations_copy[i].sequence()));
     if (removed.get())
       removed->Abort(delegate());
   }
   // This *should* have cleared the list of running animations.
   DCHECK(running_animations_.empty());
   running_animations_.clear();
   animation_queue_.clear();
   UpdateAnimationState();
 }
@@ skipping 19 matching lines @@
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const RunningAnimation& other) = default;
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui