Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/views/tabs/tab_strip.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 "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 671 matching lines @@
       in_tab_close_(false),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
       stacked_layout_(false),
       adjust_layout_(false),
       reset_to_shrink_on_exit_(false),
       mouse_move_count_(0),
       immersive_style_(false) {
   Init();
   SetEventTargeter(
-      scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
+      std::unique_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 }
 
 TabStrip::~TabStrip() {
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripDeleted(this));
 
   // The animations may reference the tabs. Shut down the animation before we
   // delete the tabs.
   StopAnimating(false);
 
@@ skipping 998 matching lines @@
 
   newtab_button_bounds_.set_size(GetLayoutSize(NEW_TAB_BUTTON));
   newtab_button_bounds_.Inset(0, 0, 0, -GetNewTabButtonTopOffset());
   newtab_button_ = new NewTabButton(this, this);
   newtab_button_->SetTooltipText(
       l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
   newtab_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
   newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                     views::ImageButton::ALIGN_BOTTOM);
-  newtab_button_->SetEventTargeter(
-      scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(newtab_button_)));
+  newtab_button_->SetEventTargeter(std::unique_ptr<views::ViewTargeter>(
+      new views::ViewTargeter(newtab_button_)));
   AddChildView(newtab_button_);
 
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     gfx::ImageSkia* drop_image = GetDropArrowImage(true);
     drop_indicator_width = drop_image->width();
     drop_indicator_height = drop_image->height();
   }
 }
 
@@ skipping 40 matching lines @@
 
 void TabStrip::ScheduleRemoveTabAnimation(Tab* tab) {
   // Start an animation for the tabs.
   GenerateIdealBounds();
   AnimateToIdealBounds();
 
   // Animate the tab being closed to zero width.
   gfx::Rect tab_bounds = tab->bounds();
   tab_bounds.set_width(0);
   bounds_animator_.AnimateViewTo(tab, tab_bounds);
-  bounds_animator_.SetAnimationDelegate(
-      tab,
-      scoped_ptr<gfx::AnimationDelegate>(new RemoveTabDelegate(this, tab)));
+  bounds_animator_.SetAnimationDelegate(tab,
+                                        std::unique_ptr<gfx::AnimationDelegate>(
+                                            new RemoveTabDelegate(this, tab)));
 
   // Don't animate the new tab button when dragging tabs. Otherwise it looks
   // like the new tab button magically appears from beyond the end of the tab
   // strip.
   if (TabDragController::IsAttachedTo(this)) {
     bounds_animator_.StopAnimatingView(newtab_button_);
     newtab_button_->SetBoundsRect(newtab_button_bounds_);
   }
 }
 
 void TabStrip::AnimateToIdealBounds() {
   for (int i = 0; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
     if (!tab->dragging()) {
       bounds_animator_.AnimateViewTo(tab, ideal_bounds(i));
       bounds_animator_.SetAnimationDelegate(
-          tab,
-          scoped_ptr<gfx::AnimationDelegate>(
-              new TabAnimationDelegate(this, tab)));
+          tab, std::unique_ptr<gfx::AnimationDelegate>(
+                   new TabAnimationDelegate(this, tab)));
     }
   }
 
   bounds_animator_.AnimateViewTo(newtab_button_, newtab_button_bounds_);
 }
 
 bool TabStrip::ShouldHighlightCloseButtonAfterRemove() {
   return in_tab_close_;
 }
 
@@ skipping 218 matching lines @@
 
 void TabStrip::RemoveTabFromViewModel(int index) {
   // We still need to paint the tab until we actually remove it. Put it
   // in tabs_closing_map_ so we can find it.
   tabs_closing_map_[index].push_back(tab_at(index));
   UpdateTabsClosingMap(index + 1, -1);
   tabs_.Remove(index);
 }
 
 void TabStrip::RemoveAndDeleteTab(Tab* tab) {
-  scoped_ptr<Tab> deleter(tab);
+  std::unique_ptr<Tab> deleter(tab);
   FindClosingTabResult res(FindClosingTab(tab));
   res.first->second.erase(res.second);
   if (res.first->second.empty())
     tabs_closing_map_.erase(res.first);
 }
 
 void TabStrip::UpdateTabsClosingMap(int index, int delta) {
   if (tabs_closing_map_.empty())
     return;
 
@@ skipping 87 matching lines @@
     PrepareForAnimation();
 
     // Animate the view back to its correct position.
     GenerateIdealBounds();
     AnimateToIdealBounds();
   }
   bounds_animator_.AnimateViewTo(tab, ideal_bounds(tab_data_index));
   // Install a delegate to reset the dragging state when done. We have to leave
   // dragging true for the tab otherwise it'll draw beneath the new tab button.
   bounds_animator_.SetAnimationDelegate(
-      tab,
-      scoped_ptr<gfx::AnimationDelegate>(
-          new ResetDraggingStateDelegate(this, tab)));
+      tab, std::unique_ptr<gfx::AnimationDelegate>(
+               new ResetDraggingStateDelegate(this, tab)));
 }
 
 void TabStrip::OwnDragController(TabDragController* controller) {
   // Typically, ReleaseDragController() and OwnDragController() calls are paired
   // via corresponding calls to TabDragController::Detach() and
   // TabDragController::Attach(). There is one exception to that rule: when a
   // drag might start, we create a TabDragController that is owned by the
   // potential source tabstrip in MaybeStartDrag(). If a drag actually starts,
   // we then call Attach() on the source tabstrip, but since the source tabstrip
   // already owns the TabDragController, so we don't need to do anything.
@@ skipping 431 matching lines @@
 
   AnimateToIdealBounds();
 
   gfx::Rect tab_bounds = tab_closing->bounds();
   tab_bounds.set_width(0);
   bounds_animator_.AnimateViewTo(tab_closing, tab_bounds);
 
   // Register delegate to do cleanup when done, BoundsAnimator takes
   // ownership of RemoveTabDelegate.
   bounds_animator_.SetAnimationDelegate(
-      tab_closing,
-      scoped_ptr<gfx::AnimationDelegate>(
-          new RemoveTabDelegate(this, tab_closing)));
+      tab_closing, std::unique_ptr<gfx::AnimationDelegate>(
+                       new RemoveTabDelegate(this, tab_closing)));
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToTarget(this, tab, &point_in_tab_coords);
   return tab->HitTestPoint(point_in_tab_coords);
 }
 
 int TabStrip::GetStartXForNormalTabs() const {
@@ skipping 273 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }