Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/window_animations.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 "ash/wm/window_animations.h"
 
 #include <math.h>
 #include <algorithm>
 #include <utility>
 #include <vector>
@@ skipping 87 matching lines @@
   // Recalculate the transform at restore time since the launcher item may have
   // moved while the window was minimized.
   gfx::Rect bounds = window->bounds();
   gfx::Rect target_bounds = GetMinimizeAnimationTargetBoundsInScreen(window);
   target_bounds =
       ScreenUtil::ConvertRectFromScreen(window->parent(), target_bounds);
 
   float scale_x = static_cast<float>(target_bounds.width()) / bounds.width();
   float scale_y = static_cast<float>(target_bounds.height()) / bounds.height();
 
-  scoped_ptr<ui::InterpolatedTransform> scale(
-      new ui::InterpolatedScale(gfx::Point3F(1, 1, 1),
-                                gfx::Point3F(scale_x, scale_y, 1)));
+  std::unique_ptr<ui::InterpolatedTransform> scale(new ui::InterpolatedScale(
+      gfx::Point3F(1, 1, 1), gfx::Point3F(scale_x, scale_y, 1)));
 
-  scoped_ptr<ui::InterpolatedTransform> translation(
+  std::unique_ptr<ui::InterpolatedTransform> translation(
       new ui::InterpolatedTranslation(
           gfx::PointF(), gfx::PointF(target_bounds.x() - bounds.x(),
                                      target_bounds.y() - bounds.y())));
 
   scale->SetChild(translation.release());
   scale->SetReversed(show);
 
   base::TimeDelta duration = window->layer()->GetAnimator()->
       GetTransitionDuration();
 
-  scoped_ptr<ui::LayerAnimationElement> transition(
+  std::unique_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           scale.release(), duration));
 
   transition->set_tween_type(
       show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
 
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(transition.release()));
 
   // When hiding a window, turn off blending until the animation is 3 / 4 done
@@ skipping 128 matching lines @@
 // Observer for a window cross-fade animation. If either the window closes or
 // the layer's animation completes or compositing is aborted due to GPU crash,
 // it deletes the layer and removes itself as an observer.
 class CrossFadeObserver : public ui::CompositorObserver,
                           public aura::WindowObserver,
                           public ui::ImplicitAnimationObserver {
  public:
   // Observes |window| for destruction, but does not take ownership.
   // Takes ownership of |layer| and its child layers.
   CrossFadeObserver(aura::Window* window,
-                    scoped_ptr<ui::LayerTreeOwner> layer_owner)
+                    std::unique_ptr<ui::LayerTreeOwner> layer_owner)
       : window_(window), layer_owner_(std::move(layer_owner)) {
     window_->AddObserver(this);
     layer_owner_->root()->GetCompositor()->AddObserver(this);
   }
   ~CrossFadeObserver() override {
     window_->RemoveObserver(this);
     window_ = NULL;
     layer_owner_->root()->GetCompositor()->RemoveObserver(this);
   }
 
@@ skipping 17 matching lines @@
   void OnWindowRemovingFromRootWindow(aura::Window* window,
                                       aura::Window* new_root) override {
     layer_owner_->root()->GetAnimator()->StopAnimating();
   }
 
   // ui::ImplicitAnimationObserver overrides:
   void OnImplicitAnimationsCompleted() override { delete this; }
 
  private:
   aura::Window* window_;  // not owned
-  scoped_ptr<ui::LayerTreeOwner> layer_owner_;
+  std::unique_ptr<ui::LayerTreeOwner> layer_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 };
 
 base::TimeDelta CrossFadeAnimation(
     aura::Window* window,
-    scoped_ptr<ui::LayerTreeOwner> old_layer_owner,
+    std::unique_ptr<ui::LayerTreeOwner> old_layer_owner,
     gfx::Tween::Type tween_type) {
   DCHECK(old_layer_owner->root());
   const gfx::Rect old_bounds(old_layer_owner->root()->bounds());
   gfx::RectF old_transformed_bounds(old_bounds);
   gfx::Transform old_transform(old_layer_owner->root()->transform());
   gfx::Transform old_transform_in_root;
   old_transform_in_root.Translate(old_bounds.x(), old_bounds.y());
   old_transform_in_root.PreconcatTransform(old_transform);
   old_transform_in_root.Translate(-old_bounds.x(), -old_bounds.y());
   old_transform_in_root.TransformRect(&old_transformed_bounds);
@@ skipping 78 matching lines @@
     return AnimateShowWindow(window);
   // Don't start hiding the window again if it's already being hidden.
   return window->layer()->GetTargetOpacity() != 0.0f &&
       AnimateHideWindow(window);
 }
 
 std::vector<ui::LayerAnimationSequence*>
 CreateBrightnessGrayscaleAnimationSequence(float target_value,
                                            base::TimeDelta duration) {
   gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT;
-  scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
+  std::unique_ptr<ui::LayerAnimationSequence> brightness_sequence(
       new ui::LayerAnimationSequence());
-  scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
+  std::unique_ptr<ui::LayerAnimationSequence> grayscale_sequence(
       new ui::LayerAnimationSequence());
 
-  scoped_ptr<ui::LayerAnimationElement> brightness_element(
-      ui::LayerAnimationElement::CreateBrightnessElement(
-          target_value, duration));
+  std::unique_ptr<ui::LayerAnimationElement> brightness_element(
+      ui::LayerAnimationElement::CreateBrightnessElement(target_value,
+                                                         duration));
   brightness_element->set_tween_type(animation_type);
   brightness_sequence->AddElement(brightness_element.release());
 
-  scoped_ptr<ui::LayerAnimationElement> grayscale_element(
-      ui::LayerAnimationElement::CreateGrayscaleElement(
-          target_value, duration));
+  std::unique_ptr<ui::LayerAnimationElement> grayscale_element(
+      ui::LayerAnimationElement::CreateGrayscaleElement(target_value,
+                                                        duration));
   grayscale_element->set_tween_type(animation_type);
   grayscale_sequence->AddElement(grayscale_element.release());
 
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(brightness_sequence.release());
   animations.push_back(grayscale_sequence.release());
 
   return animations;
 }
 
@@ skipping 50 matching lines @@
   gfx::Rect work_area =
       gfx::Screen::GetScreen()->GetDisplayNearestWindow(window).work_area();
   int ltr_adjusted_x = base::i18n::IsRTL() ? work_area.right() : work_area.x();
   return shelf->SelectValueForShelfAlignment(
       gfx::Rect(ltr_adjusted_x, work_area.bottom(), 0, 0),
       gfx::Rect(work_area.x(), work_area.y(), 0, 0),
       gfx::Rect(work_area.right(), work_area.y(), 0, 0));
 }
 
 }  // namespace ash