Convert //ash from scoped_ptr to std::unique_ptr

ash/shelf/shelf_view.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/shelf/shelf_view.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/scoped_target_root_window.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_menu_model.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/auto_reset.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_strings.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
@@ skipping 281 matching lines @@
     view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
   void AnimationEnded(const Animation* animation) override {
     shelf_view_->OnFadeOutAnimationEnded();
   }
   void AnimationCanceled(const Animation* animation) override {}
 
  private:
   ShelfView* shelf_view_;
-  scoped_ptr<views::View> view_;
+  std::unique_ptr<views::View> view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeOutAnimationDelegate);
 };
 
 // AnimationDelegate used to trigger fading an element in. When an item is
 // inserted this delegate is attached to the animation that expands the size of
 // the item.  When done it kicks off another animation to fade the item in.
 class ShelfView::StartFadeAnimationDelegate : public gfx::AnimationDelegate {
  public:
   StartFadeAnimationDelegate(ShelfView* host,
@@ skipping 657 matching lines @@
   view->set_context_menu_controller(this);
   ConfigureChildView(view);
   return view;
 }
 
 void ShelfView::FadeIn(views::View* view) {
   view->SetVisible(true);
   view->layer()->SetOpacity(0);
   AnimateToIdealBounds();
   bounds_animator_->SetAnimationDelegate(
-      view,
-      scoped_ptr<gfx::AnimationDelegate>(new FadeInAnimationDelegate(view)));
+      view, std::unique_ptr<gfx::AnimationDelegate>(
+                new FadeInAnimationDelegate(view)));
 }
 
 void ShelfView::PrepareForDrag(Pointer pointer, const ui::LocatedEvent& event) {
   DCHECK(!dragging());
   DCHECK(drag_view_);
   drag_pointer_ = pointer;
   start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
 
   if (start_drag_index_== -1) {
     CancelDrag(-1);
@@ skipping 340 matching lines @@
 }
 
 void ShelfView::StartFadeInLastVisibleItem() {
   // If overflow button is visible and there is a valid new last item, fading
   // the new last item in after sliding animation is finished.
   if (overflow_button_->visible() && last_visible_index_ >= 0) {
     views::View* last_visible_view = view_model_->view_at(last_visible_index_);
     last_visible_view->layer()->SetOpacity(0);
     bounds_animator_->SetAnimationDelegate(
         last_visible_view,
-        scoped_ptr<gfx::AnimationDelegate>(
+        std::unique_ptr<gfx::AnimationDelegate>(
             new StartFadeAnimationDelegate(this, last_visible_view)));
   }
 }
 
 void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) const {
   const int first_overflow_index = last_visible_index_ + 1;
   const int last_overflow_index = last_hidden_index_;
   DCHECK_LE(first_overflow_index, last_overflow_index);
   DCHECK_LT(last_overflow_index, view_model_->view_size());
 
@@ skipping 159 matching lines @@
   CalculateIdealBounds(&ideal_bounds);
   view->SetBoundsRect(view_model_->ideal_bounds(model_index));
 
   // The first animation moves all the views to their target position. |view|
   // is hidden, so it visually appears as though we are providing space for
   // it. When done we'll fade the view in.
   AnimateToIdealBounds();
   if (model_index <= last_visible_index_ ||
       model_index >= model_->FirstPanelIndex()) {
     bounds_animator_->SetAnimationDelegate(
-        view,
-        scoped_ptr<gfx::AnimationDelegate>(
-            new StartFadeAnimationDelegate(this, view)));
+        view, std::unique_ptr<gfx::AnimationDelegate>(
+                  new StartFadeAnimationDelegate(this, view)));
   } else {
     // Undo the hiding if animation does not run.
     view->layer()->SetOpacity(1.0f);
   }
 }
 
 void ShelfView::ShelfItemRemoved(int model_index, ShelfID id) {
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
   {
@@ skipping 13 matching lines @@
     last_hidden_index_ = std::min(last_hidden_index_,
                                   view_model_->view_size() - 1);
     UpdateOverflowRange(overflow_bubble_->shelf_view());
   }
 
   if (view->visible()) {
     // The first animation fades out the view. When done we'll animate the rest
     // of the views to their target location.
     bounds_animator_->AnimateViewTo(view, view->bounds());
     bounds_animator_->SetAnimationDelegate(
-        view,
-        scoped_ptr<gfx::AnimationDelegate>(
-            new FadeOutAnimationDelegate(this, view)));
+        view, std::unique_ptr<gfx::AnimationDelegate>(
+                  new FadeOutAnimationDelegate(this, view)));
   } else {
     // We don't need to show a fade out animation for invisible |view|. When an
     // item is ripped out from the shelf, its |view| is already invisible.
     AnimateToIdealBounds();
   }
 
   if (view == tooltip_.GetCurrentAnchorView())
     tooltip_.Close();
 }
 
 void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
   const ShelfItem& item(model_->items()[model_index]);
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     model_index = CancelDrag(model_index);
-    scoped_ptr<views::View> old_view(view_model_->view_at(model_index));
+    std::unique_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     // Removing and re-inserting a view in our view model will strip the ideal
     // bounds from the item. To avoid recalculation of everything the bounds
     // get remembered and restored after the insertion to the previous value.
     gfx::Rect old_ideal_bounds = view_model_->ideal_bounds(model_index);
     view_model_->Remove(model_index);
     views::View* new_view = CreateViewForItem(item);
     AddChildView(new_view);
     view_model_->Add(new_view, model_index);
     view_model_->set_ideal_bounds(model_index, old_ideal_bounds);
@@ skipping 67 matching lines @@
   // animating open due to the first click, then immediately minimizes due to
   // the second click. The user most likely intended to open or minimize the
   // item once, not do both.
   if (event.flags() & ui::EF_IS_DOUBLE_CLICK)
     return;
 
   {
     ScopedTargetRootWindow scoped_target(
         sender->GetWidget()->GetNativeView()->GetRootWindow());
     // Slow down activation animations if shift key is pressed.
-    scoped_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
+    std::unique_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
     if (event.IsShiftDown()) {
       slowing_animations.reset(new ui::ScopedAnimationDurationScaleMode(
             ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
     }
 
     // Collect usage statistics before we decide what to do with the click.
     switch (model_->items()[view_index].type) {
       case TYPE_APP_SHORTCUT:
       case TYPE_WINDOWED_APP:
       case TYPE_PLATFORM_APP:
@@ skipping 26 matching lines @@
     if (performed_action != ShelfItemDelegate::kNewWindowCreated)
       ShowListMenuForView(model_->items()[view_index], sender, event);
   }
 }
 
 void ShelfView::ShowListMenuForView(const ShelfItem& item,
                                     views::View* source,
                                     const ui::Event& event) {
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(item.id);
-  scoped_ptr<ui::MenuModel> list_menu_model(
+  std::unique_ptr<ui::MenuModel> list_menu_model(
       item_delegate->CreateApplicationMenu(event.flags()));
 
   // Make sure we have a menu and it has at least two items in addition to the
   // application title and the 3 spacing separators.
   if (!list_menu_model.get() || list_menu_model->GetItemCount() <= 5)
     return;
 
   context_menu_id_ = item.id;
   ShowMenu(list_menu_model.get(), source, gfx::Point(), false,
            ui::GetMenuSourceTypeForEvent(event));
 }
 
 void ShelfView::ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
   const ShelfItem* item = ShelfItemForView(source);
   if (!item) {
     Shell::GetInstance()->ShowContextMenu(point, source_type);
     return;
   }
 
-  scoped_ptr<ui::MenuModel> context_menu_model(
+  std::unique_ptr<ui::MenuModel> context_menu_model(
       Shell::GetInstance()->delegate()->CreateContextMenu(shelf_, item));
   if (!context_menu_model)
     return;
 
   context_menu_id_ = item ? item->id : 0;
   ShowMenu(context_menu_model.get(), source, point, true, source_type);
 }
 
 void ShelfView::ShowMenu(ui::MenuModel* menu_model,
                          views::View* source,
@@ skipping 103 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash