Convert //ash from scoped_ptr to std::unique_ptr

ash/shelf/shelf_widget.cc

 // Copyright 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_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
@@ skipping 109 matching lines @@
   // True if someone forces us not to be dimmed (e.g. a menu is open).
   bool force_hovered_;
 
   // True if animations should be suppressed for a test.
   bool disable_dimming_animations_for_test_;
 
   // The animator for the background transitions.
   ash::BackgroundAnimator background_animator_;
 
   // Notification of entering / exiting of the shelf area by mouse.
-  scoped_ptr<DimmerEventFilter> event_filter_;
+  std::unique_ptr<DimmerEventFilter> event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(DimmerView);
 };
 
 DimmerView::DimmerView(ash::ShelfWidget* shelf_widget,
                        bool disable_dimming_animations_for_test)
     : shelf_(shelf_widget),
       alpha_(kDimAlpha),
       is_hovered_(false),
       force_hovered_(false),
@@ skipping 231 matching lines @@
   gfx::Rect GetDimmerBoundsForTest();
 
   // Disable dimming animations for running tests. This needs to be called
   // prior to the creation of of the |dimmer_|.
   void disable_dimming_animations_for_test() {
     disable_dimming_animations_for_test_ = true;
   }
 
  private:
   ShelfWidget* shelf_;
-  scoped_ptr<views::Widget> dimmer_;
+  std::unique_ptr<views::Widget> dimmer_;
   FocusCycler* focus_cycler_;
   int alpha_;
   // A black background layer which is shown when a maximized window is visible.
   ui::Layer opaque_background_;
   // A black foreground layer which is shown while transitioning between users.
   // Note: Since the back- and foreground layers have different functions they
   // can be used simultaneously - so no repurposing possible.
   ui::Layer opaque_foreground_;
 
   // The view which does the dimming.
@@ skipping 231 matching lines @@
   status_area_widget_->CreateTrayViews();
   if (Shell::GetInstance()->session_state_delegate()->
           IsActiveUserSessionStarted()) {
     status_area_widget_->Show();
   }
   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
 
   status_container->SetLayoutManager(
       new StatusAreaLayoutManager(status_container, this));
 
-  shelf_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
-      ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
-  status_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
-      ShelfWindowTargeter(status_container, shelf_layout_manager_)));
+  shelf_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
+      new ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
+  status_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
+      new ShelfWindowTargeter(status_container, shelf_layout_manager_)));
 
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   Shell::GetInstance()->focus_cycler()->RemoveWidget(this);
   SetFocusCycler(nullptr);
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
   ui::Layer* opaque_background = delegate_view_->opaque_background();
   float target_opacity =
       (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
-  scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
+  std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
   if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
     opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
         opaque_background->GetAnimator()));
     opaque_background_animation->SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
   }
   opaque_background->SetOpacity(target_opacity);
 
   // TODO(mukai): use ui::Layer on both opaque_background and normal background
   // retire background_animator_ at all. It would be simpler.
@@ skipping 12 matching lines @@
 
   return SHELF_BACKGROUND_DEFAULT;
 }
 
 void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
   if (IsShelfHiddenBehindBlackBar() == hide)
     return;
 
   ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
   float target_opacity = hide ? 1.0f : 0.0f;
-  scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
+  std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
   opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
       opaque_foreground->GetAnimator()));
   opaque_foreground_animation->SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(animation_time_ms));
   opaque_foreground_animation->SetPreemptionStrategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   opaque_foreground->SetOpacity(target_opacity);
 }
 
@@ skipping 128 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash