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

cc/animation/element_animations.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/element_animations.h"
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/trees/mutator_host_client.h"
 
 namespace cc {
 
 class ElementAnimations::ValueObserver : public LayerAnimationValueObserver {
  public:
@@ skipping 31 matching lines @@
 
   bool IsActive() const override { return tree_type_ == LayerTreeType::ACTIVE; }
 
  private:
   ElementAnimations* element_animations_;
   const LayerTreeType tree_type_;
 
   DISALLOW_COPY_AND_ASSIGN(ValueObserver);
 };
 
-scoped_ptr<ElementAnimations> ElementAnimations::Create(AnimationHost* host) {
-  return make_scoped_ptr(new ElementAnimations(host));
+std::unique_ptr<ElementAnimations> ElementAnimations::Create(
+    AnimationHost* host) {
+  return base::WrapUnique(new ElementAnimations(host));
 }
 
 ElementAnimations::ElementAnimations(AnimationHost* host)
-    : players_list_(make_scoped_ptr(new PlayersList())), animation_host_(host) {
+    : players_list_(base::WrapUnique(new PlayersList())),

[vmpstr, 2016/04/08 00:53:55]

I don't think you need this?

[danakj, 2016/04/08 00:59:01]

Done.

+      animation_host_(host) {
   DCHECK(animation_host_);
 }
 
 ElementAnimations::~ElementAnimations() {
   DCHECK(!layer_animation_controller_);
 }
 
 void ElementAnimations::CreateLayerAnimationController(int layer_id) {
   DCHECK(layer_id);
   DCHECK(!layer_animation_controller_);
@@ skipping 129 matching lines @@
   animation_host()
       ->mutator_host_client()
       ->LayerTransformIsPotentiallyAnimatingChanged(layer_id(), tree_type,
                                                     is_animating);
 }
 
 void ElementAnimations::CreateActiveValueObserver() {
   DCHECK(layer_animation_controller_);
   DCHECK(!active_value_observer_);
   active_value_observer_ =
-      make_scoped_ptr(new ValueObserver(this, LayerTreeType::ACTIVE));
+      base::WrapUnique(new ValueObserver(this, LayerTreeType::ACTIVE));
   layer_animation_controller_->AddValueObserver(active_value_observer_.get());
 }
 
 void ElementAnimations::DestroyActiveValueObserver() {
   if (layer_animation_controller_ && active_value_observer_)
     layer_animation_controller_->RemoveValueObserver(
         active_value_observer_.get());
   active_value_observer_ = nullptr;
 }
 
 void ElementAnimations::CreatePendingValueObserver() {
   DCHECK(layer_animation_controller_);
   DCHECK(!pending_value_observer_);
   pending_value_observer_ =
-      make_scoped_ptr(new ValueObserver(this, LayerTreeType::PENDING));
+      base::WrapUnique(new ValueObserver(this, LayerTreeType::PENDING));
   layer_animation_controller_->AddValueObserver(pending_value_observer_.get());
 }
 
 void ElementAnimations::DestroyPendingValueObserver() {
   if (layer_animation_controller_ && pending_value_observer_)
     layer_animation_controller_->RemoveValueObserver(
         pending_value_observer_.get());
   pending_value_observer_ = nullptr;
 }
 
@@ skipping 27 matching lines @@
        node != players_list_->end(); node = node->next()) {
     AnimationPlayer* player = node->value();
     player->NotifyAnimationAborted(monotonic_time, target_property, group);
   }
 }
 
 void ElementAnimations::NotifyAnimationTakeover(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     double animation_start_time,
-    scoped_ptr<AnimationCurve> curve) {
+    std::unique_ptr<AnimationCurve> curve) {
   DCHECK(curve);
   for (PlayersListNode* node = players_list_->head();
        node != players_list_->end(); node = node->next()) {
-    scoped_ptr<AnimationCurve> animation_curve = curve->Clone();
+    std::unique_ptr<AnimationCurve> animation_curve = curve->Clone();
     AnimationPlayer* player = node->value();
     player->NotifyAnimationTakeover(monotonic_time, target_property,
                                     animation_start_time,
                                     std::move(animation_curve));
   }
 }
 
 gfx::ScrollOffset ElementAnimations::ScrollOffsetForAnimation() const {
   DCHECK(layer_animation_controller_);
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         layer_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc