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

cc/animation/animation_host.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 "cc/animation/animation_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.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/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
 #include "ui/gfx/geometry/box_f.h"
@@ skipping 19 matching lines @@
 
   ~ScrollOffsetAnimations() override {
     scroll_offset_timeline_->DetachPlayer(
         scroll_offset_animation_player_.get());
     animation_host_->RemoveAnimationTimeline(scroll_offset_timeline_.get());
   }
 
   void ScrollAnimationCreate(int layer_id,
                              const gfx::ScrollOffset& target_offset,
                              const gfx::ScrollOffset& current_offset) {
-    scoped_ptr<ScrollOffsetAnimationCurve> curve =
+    std::unique_ptr<ScrollOffsetAnimationCurve> curve =
         ScrollOffsetAnimationCurve::Create(
             target_offset, EaseInOutTimingFunction::Create(),
             ScrollOffsetAnimationCurve::DurationBehavior::INVERSE_DELTA);
     curve->SetInitialValue(current_offset);
 
-    scoped_ptr<Animation> animation = Animation::Create(
+    std::unique_ptr<Animation> animation = Animation::Create(
         std::move(curve), AnimationIdProvider::NextAnimationId(),
         AnimationIdProvider::NextGroupId(), TargetProperty::SCROLL_OFFSET);
     animation->set_is_impl_only(true);
 
     DCHECK(scroll_offset_animation_player_);
     DCHECK(scroll_offset_animation_player_->animation_timeline());
 
     ReattachScrollOffsetPlayerIfNeeded(layer_id);
 
     scroll_offset_animation_player_->AddAnimation(std::move(animation));
@@ skipping 48 matching lines @@
     DCHECK_EQ(target_property, TargetProperty::SCROLL_OFFSET);
     DCHECK(animation_host_->mutator_host_client());
     animation_host_->mutator_host_client()->ScrollOffsetAnimationFinished();
   }
   void NotifyAnimationAborted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {}
   void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                double animation_start_time,
-                               scoped_ptr<AnimationCurve> curve) override {}
+                               std::unique_ptr<AnimationCurve> curve) override {
+  }
 
  private:
   void ReattachScrollOffsetPlayerIfNeeded(int layer_id) {
     if (scroll_offset_animation_player_->layer_id() != layer_id) {
       if (scroll_offset_animation_player_->layer_id())
         scroll_offset_animation_player_->DetachLayer();
       if (layer_id)
         scroll_offset_animation_player_->AttachLayer(layer_id);
     }
   }
 
   AnimationHost* animation_host_;
   scoped_refptr<AnimationTimeline> scroll_offset_timeline_;
 
   // We have just one player for impl-only scroll offset animations.
   // I.e. only one layer can have an impl-only scroll offset animation at
   // any given time.
   scoped_refptr<AnimationPlayer> scroll_offset_animation_player_;
 
   DISALLOW_COPY_AND_ASSIGN(ScrollOffsetAnimations);
 };
 
-scoped_ptr<AnimationHost> AnimationHost::Create(
+std::unique_ptr<AnimationHost> AnimationHost::Create(
     ThreadInstance thread_instance) {
-  return make_scoped_ptr(new AnimationHost(thread_instance));
+  return base::WrapUnique(new AnimationHost(thread_instance));
 }
 
 AnimationHost::AnimationHost(ThreadInstance thread_instance)
     : animation_registrar_(AnimationRegistrar::Create()),
       mutator_host_client_(nullptr),
       thread_instance_(thread_instance) {
   if (thread_instance_ == ThreadInstance::IMPL)
     scroll_offset_animations_ =
-        make_scoped_ptr(new ScrollOffsetAnimations(this));
+        base::WrapUnique(new ScrollOffsetAnimations(this));
 }
 
 AnimationHost::~AnimationHost() {
   scroll_offset_animations_ = nullptr;
 
   ClearTimelines();
   DCHECK(!mutator_host_client());
   DCHECK(layer_to_element_animations_map_.empty());
 }
 
@@ skipping 191 matching lines @@
 bool AnimationHost::AnimateLayers(base::TimeTicks monotonic_time) {
   return animation_registrar_->AnimateLayers(monotonic_time);
 }
 
 bool AnimationHost::UpdateAnimationState(bool start_ready_animations,
                                          AnimationEvents* events) {
   return animation_registrar_->UpdateAnimationState(start_ready_animations,
                                                     events);
 }
 
-scoped_ptr<AnimationEvents> AnimationHost::CreateEvents() {
+std::unique_ptr<AnimationEvents> AnimationHost::CreateEvents() {
   return animation_registrar_->CreateEvents();
 }
 
-void AnimationHost::SetAnimationEvents(scoped_ptr<AnimationEvents> events) {
+void AnimationHost::SetAnimationEvents(
+    std::unique_ptr<AnimationEvents> events) {
   return animation_registrar_->SetAnimationEvents(std::move(events));
 }
 
 bool AnimationHost::ScrollOffsetAnimationWasInterrupted(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller ? controller->scroll_offset_animation_was_interrupted()
                     : false;
 }
 
 static LayerAnimationController::ObserverType ObserverTypeFromTreeType(
@@ skipping 210 matching lines @@
   return scroll_offset_animations_->ScrollAnimationUpdateTarget(
       layer_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
 }
 
 void AnimationHost::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationAbort(needs_completion);
 }
 
 }  // namespace cc