Convert //cc from scoped_ptr to std::unique_ptr.

cc/animation/layer_animation_controller.cc

 // Copyright 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 "cc/animation/layer_animation_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 78 matching lines @@
       changed_for_active_observers, changed_for_pending_observers);
 }
 
 void LayerAnimationController::RemoveAnimation(int animation_id) {
   bool removed_transform_animation = false;
   // Since we want to use the animations that we're going to remove, we need to
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
       animations_.begin(), animations_.end(),
-      [animation_id](const scoped_ptr<Animation>& animation) {
+      [animation_id](const std::unique_ptr<Animation>& animation) {
         return animation->id() != animation_id;
       });
   for (auto it = animations_to_remove; it != animations_.end(); ++it) {
     if ((*it)->target_property() == TargetProperty::SCROLL_OFFSET) {
       scroll_offset_animation_was_interrupted_ = true;
     } else if ((*it)->target_property() == TargetProperty::TRANSFORM &&
                !(*it)->is_finished()) {
       removed_transform_animation = true;
     }
   }
@@ skipping 171 matching lines @@
 void LayerAnimationController::ActivateAnimations() {
   bool changed_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_observers() !=
             animations_[i]->affects_pending_observers() &&
         animations_[i]->target_property() == TargetProperty::TRANSFORM)
       changed_transform_animation = true;
     animations_[i]->set_affects_active_observers(
         animations_[i]->affects_pending_observers());
   }
-  auto affects_no_observers = [](const scoped_ptr<Animation>& animation) {
+  auto affects_no_observers = [](const std::unique_ptr<Animation>& animation) {
     return !animation->affects_active_observers() &&
            !animation->affects_pending_observers();
   };
   animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
                                    affects_no_observers),
                     animations_.end());
   scroll_offset_animation_was_interrupted_ = false;
   UpdateActivation(NORMAL_ACTIVATION);
   if (changed_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
-void LayerAnimationController::AddAnimation(scoped_ptr<Animation> animation) {
+void LayerAnimationController::AddAnimation(
+    std::unique_ptr<Animation> animation) {
   bool added_transform_animation =
       animation->target_property() == TargetProperty::TRANSFORM;
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
   if (added_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 Animation* LayerAnimationController::GetAnimation(
@@ skipping 118 matching lines @@
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationTakeover(
     const AnimationEvent& event) {
   DCHECK(event.target_property == TargetProperty::SCROLL_OFFSET);
   if (layer_animation_delegate_) {
-    scoped_ptr<AnimationCurve> animation_curve = event.curve->Clone();
+    std::unique_ptr<AnimationCurve> animation_curve = event.curve->Clone();
     layer_animation_delegate_->NotifyAnimationTakeover(
         event.monotonic_time, event.target_property, event.animation_start_time,
         std::move(animation_curve));
   }
 }
 
 void LayerAnimationController::NotifyAnimationAborted(
     const AnimationEvent& event) {
   bool aborted_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 262 matching lines @@
         // scroll offset will be up-to-date.
         current_scroll_offset = value_provider_->ScrollOffsetForAnimation();
       }
       animations_[i]->curve()->ToScrollOffsetAnimationCurve()->SetInitialValue(
           current_scroll_offset);
     }
 
     // The new animation should be set to run as soon as possible.
     Animation::RunState initial_run_state =
         Animation::WAITING_FOR_TARGET_AVAILABILITY;
-    scoped_ptr<Animation> to_add(
+    std::unique_ptr<Animation> to_add(
         animations_[i]->CloneAndInitialize(initial_run_state));
     DCHECK(!to_add->needs_synchronized_start_time());
     to_add->set_affects_active_observers(false);
     controller_impl->AddAnimation(std::move(to_add));
   }
 }
 
 static bool IsCompleted(
     Animation* animation,
     const LayerAnimationController* main_thread_controller) {
@@ skipping 13 matching lines @@
   // immediately.
   auto& animations = controller_impl->animations_;
   for (const auto& animation : animations) {
     if (IsCompleted(animation.get(), this)) {
       animation->set_affects_pending_observers(false);
       if (animation->target_property() == TargetProperty::TRANSFORM)
         removed_transform_animation = true;
     }
   }
   auto affects_active_only_and_is_waiting_for_deletion = [](
-      const scoped_ptr<Animation>& animation) {
+      const std::unique_ptr<Animation>& animation) {
     return animation->run_state() == Animation::WAITING_FOR_DELETION &&
            !animation->affects_pending_observers();
   };
   animations.erase(
       std::remove_if(animations.begin(), animations.end(),
                      affects_active_only_and_is_waiting_for_deletion),
       animations.end());
 
   if (removed_transform_animation)
     controller_impl->UpdatePotentiallyAnimatingTransform();
@@ skipping 303 matching lines @@
         }
       }
     }
   }
 
   if (aborted_transform_animation)
     controller_impl->UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
-  animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
-                                   [](const scoped_ptr<Animation>& animation) {
-                                     return animation->run_state() ==
-                                            Animation::WAITING_FOR_DELETION;
-                                   }),
-                    animations_.end());
+  animations_.erase(
+      std::remove_if(animations_.begin(), animations_.end(),
+                     [](const std::unique_ptr<Animation>& animation) {
+                       return animation->run_state() ==
+                              Animation::WAITING_FOR_DELETION;
+                     }),
+      animations_.end());
 }
 
 void LayerAnimationController::TickAnimations(base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING ||
         animations_[i]->run_state() == Animation::RUNNING ||
         animations_[i]->run_state() == Animation::PAUSED) {
       if (!animations_[i]->InEffect(monotonic_time))
         continue;
 
@@ skipping 185 matching lines @@
         &value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc