Replace scoped_ptr with std::unique_ptr in //ui

ui/app_list/views/apps_grid_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 "ui/app_list/views/apps_grid_view.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
@@ skipping 148 matching lines @@
   }
   void AnimationCanceled(const gfx::Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
     view_->SchedulePaint();
   }
 
  private:
   // The view that needs to be wrapped. Owned by views hierarchy.
   views::View* view_;
 
-  scoped_ptr<ui::Layer> layer_;
+  std::unique_ptr<ui::Layer> layer_;
   const gfx::Rect layer_start_;
   const gfx::Rect layer_target_;
 
   DISALLOW_COPY_AND_ASSIGN(RowMoveAnimationDelegate);
 };
 
 // ItemRemoveAnimationDelegate is used to show animation for removing an item.
 // This happens when user drags an item into a folder. The dragged item will
 // be removed from the original list after it is dropped into the folder.
 class ItemRemoveAnimationDelegate : public gfx::AnimationDelegate {
  public:
   explicit ItemRemoveAnimationDelegate(views::View* view)
       : view_(view) {
   }
 
   ~ItemRemoveAnimationDelegate() override {}
 
   // gfx::AnimationDelegate overrides:
   void AnimationProgressed(const gfx::Animation* animation) override {
     view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
 
  private:
-  scoped_ptr<views::View> view_;
+  std::unique_ptr<views::View> view_;
 
   DISALLOW_COPY_AND_ASSIGN(ItemRemoveAnimationDelegate);
 };
 
 // ItemMoveAnimationDelegate observes when an item finishes animating when it is
 // not moving between rows. This is to ensure an item is repainted for the
 // "zoom out" case when releasing an item being dragged.
 class ItemMoveAnimationDelegate : public gfx::AnimationDelegate {
  public:
   explicit ItemMoveAnimationDelegate(views::View* view) : view_(view) {}
@@ skipping 1085 matching lines @@
     const int y_diff = target.y() - current.y();
     if (visible && y_diff && y_diff % GetTotalTileSize().height() == 0) {
       AnimationBetweenRows(view,
                            current_visible,
                            current,
                            target_visible,
                            target);
     } else if (visible || bounds_animator_.IsAnimating(view)) {
       bounds_animator_.AnimateViewTo(view, target);
       bounds_animator_.SetAnimationDelegate(
-          view,
-          scoped_ptr<gfx::AnimationDelegate>(
-              new ItemMoveAnimationDelegate(view)));
+          view, std::unique_ptr<gfx::AnimationDelegate>(
+                    new ItemMoveAnimationDelegate(view)));
     } else {
       view->SetBoundsRect(target);
     }
   }
 }
 
 void AppsGridView::AnimationBetweenRows(AppListItemView* view,
                                         bool animate_current,
                                         const gfx::Rect& current,
                                         bool animate_target,
                                         const gfx::Rect& target) {
   // Determine page of |current| and |target|. -1 means in the left invisible
   // page, 0 is the center visible page and 1 means in the right invisible page.
   const int current_page = current.x() < 0 ? -1 :
       current.x() >= width() ? 1 : 0;
   const int target_page = target.x() < 0 ? -1 :
       target.x() >= width() ? 1 : 0;
 
   const int dir = current_page < target_page ||
       (current_page == target_page && current.y() < target.y()) ? 1 : -1;
 
-  scoped_ptr<ui::Layer> layer;
+  std::unique_ptr<ui::Layer> layer;
   if (animate_current) {
     layer = view->RecreateLayer();
     layer->SuppressPaint();
 
     view->layer()->SetFillsBoundsOpaquely(false);
     view->layer()->SetOpacity(0.f);
   }
 
   gfx::Size total_tile_size = GetTotalTileSize();
   gfx::Rect current_out(current);
   current_out.Offset(dir * total_tile_size.width(), 0);
 
   gfx::Rect target_in(target);
   if (animate_target)
     target_in.Offset(-dir * total_tile_size.width(), 0);
   view->SetBoundsRect(target_in);
   bounds_animator_.AnimateViewTo(view, target);
 
   bounds_animator_.SetAnimationDelegate(
       view,
-      scoped_ptr<gfx::AnimationDelegate>(
+      std::unique_ptr<gfx::AnimationDelegate>(
           new RowMoveAnimationDelegate(view, layer.release(), current_out)));
 }
 
 void AppsGridView::ExtractDragLocation(const ui::LocatedEvent& event,
                                        gfx::Point* drag_point) {
   // Use root location of |event| instead of location in |drag_view_|'s
   // coordinates because |drag_view_| has a scale transform and location
   // could have integer round error and causes jitter.
   *drag_point = event.root_location();
 
@@ skipping 451 matching lines @@
     } else {
       LOG(ERROR) << "Folder no longer in item_list: " << folder_item_id;
     }
   }
 
   // Fade out the drag_view_ and delete it when animation ends.
   int drag_view_index = view_model_.GetIndexOfView(drag_view_);
   view_model_.Remove(drag_view_index);
   bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
   bounds_animator_.SetAnimationDelegate(
-      drag_view_,
-      scoped_ptr<gfx::AnimationDelegate>(
-          new ItemRemoveAnimationDelegate(drag_view_)));
+      drag_view_, std::unique_ptr<gfx::AnimationDelegate>(
+                      new ItemRemoveAnimationDelegate(drag_view_)));
   UpdatePaging();
 }
 
 void AppsGridView::ReparentItemForReorder(AppListItemView* item_view,
                                           const Index& target) {
   item_list_->RemoveObserver(this);
   model_->RemoveObserver(this);
 
   AppListItem* reparent_item = item_view->item();
   DCHECK(reparent_item->IsInFolder());
@@ skipping 92 matching lines @@
 
   RemoveLastItemFromReparentItemFolderIfNecessary(source_folder_id);
 
   item_list_->AddObserver(this);
 
   // Fade out the drag_view_ and delete it when animation ends.
   int drag_view_index = view_model_.GetIndexOfView(drag_view_);
   view_model_.Remove(drag_view_index);
   bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
   bounds_animator_.SetAnimationDelegate(
-      drag_view_,
-      scoped_ptr<gfx::AnimationDelegate>(
-          new ItemRemoveAnimationDelegate(drag_view_)));
+      drag_view_, std::unique_ptr<gfx::AnimationDelegate>(
+                      new ItemRemoveAnimationDelegate(drag_view_)));
   UpdatePaging();
 
   return true;
 }
 
 // After moving the re-parenting item out of the folder, if there is only 1 item
 // left, remove the last item out of the folder, delete the folder and insert it
 // to the data model at the same position. Make the same change to view_model_
 // accordingly.
 void AppsGridView::RemoveLastItemFromReparentItemFolderIfNecessary(
@@ skipping 239 matching lines @@
 
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
       GetViewDisplayedAtSlotOnCurrentPage(target_index.slot);
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list