Convert //ash from scoped_ptr to std::unique_ptr

ash/shell.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/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 65 matching lines @@
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/toplevel_window_event_handler.h"
 #include "ash/wm/video_detector.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 490 matching lines @@
   return GetPrimaryRootWindowController()->GetSystemTray();
 }
 
 ShelfDelegate* Shell::GetShelfDelegate() {
   if (!shelf_delegate_) {
     // Creates ShelfItemDelegateManager before ShelfDelegate.
     shelf_item_delegate_manager_.reset(
         new ShelfItemDelegateManager(shelf_model_.get()));
 
     shelf_delegate_.reset(delegate_->CreateShelfDelegate(shelf_model_.get()));
-    scoped_ptr<ShelfItemDelegate> controller(new AppListShelfItemDelegate);
+    std::unique_ptr<ShelfItemDelegate> controller(new AppListShelfItemDelegate);
 
     // Finding the shelf model's location of the app list and setting its
     // ShelfItemDelegate.
     int app_list_index = shelf_model_->GetItemIndexForType(TYPE_APP_LIST);
     DCHECK_GE(app_list_index, 0);
     ShelfID app_list_id = shelf_model_->items()[app_list_index].id;
     DCHECK(app_list_id);
     shelf_item_delegate_manager_->SetShelfItemDelegate(app_list_id,
                                                        std::move(controller));
     shelf_window_watcher_.reset(new ShelfWindowWatcher(
@@ skipping 245 matching lines @@
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   in_mus_ = init_params.in_mus;
   if (!in_mus_) {
     native_cursor_manager_ = new AshNativeCursorManager;
 #if defined(OS_CHROMEOS)
     cursor_manager_.reset(
-        new CursorManager(make_scoped_ptr(native_cursor_manager_)));
+        new CursorManager(base::WrapUnique(native_cursor_manager_)));
 #else
     cursor_manager_.reset(
-        new ::wm::CursorManager(make_scoped_ptr(native_cursor_manager_)));
+        new ::wm::CursorManager(base::WrapUnique(native_cursor_manager_)));
 #endif
   }
 
   delegate_->PreInit();
   bool display_initialized = display_manager_->InitFromCommandLine();
 
   display_configuration_controller_.reset(new DisplayConfigurationController(
       display_manager_.get(), window_tree_host_manager_.get()));
 
 #if defined(OS_CHROMEOS)
@@ skipping 91 matching lines @@
 
   // ui::UserActivityDetector passes events to observers, so let them get
   // rewritten first.
   user_activity_detector_.reset(new ui::UserActivityDetector);
 
   overlay_filter_.reset(new OverlayEventFilter);
   AddPreTargetHandler(overlay_filter_.get());
   AddShellObserver(overlay_filter_.get());
 
   accelerator_filter_.reset(new ::wm::AcceleratorFilter(
-      scoped_ptr<::wm::AcceleratorDelegate>(new AcceleratorDelegate),
+      std::unique_ptr<::wm::AcceleratorDelegate>(new AcceleratorDelegate),
       accelerator_controller_->accelerator_history()));
   AddPreTargetHandler(accelerator_filter_.get());
 
   event_transformation_handler_.reset(new EventTransformationHandler);
   AddPreTargetHandler(event_transformation_handler_.get());
 
   toplevel_window_event_handler_.reset(new ToplevelWindowEventHandler);
 
   system_gesture_filter_.reset(new SystemGestureEventFilter);
   AddPreTargetHandler(system_gesture_filter_.get());
@@ skipping 38 matching lines @@
       new PartialMagnificationController());
 
   autoclick_controller_.reset(AutoclickController::CreateInstance());
 
   high_contrast_controller_.reset(new HighContrastController);
   video_detector_.reset(new VideoDetector);
   window_selector_controller_.reset(new WindowSelectorController());
   window_cycle_controller_.reset(new WindowCycleController());
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
-      scoped_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
+      std::unique_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
   AddPreTargetHandler(tooltip_controller_.get());
 
   event_client_.reset(new EventClientImpl);
 
   // This controller needs to be set before SetupManagedWindowMode.
   desktop_background_controller_.reset(
       new DesktopBackgroundController(blocking_pool_));
   user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate());
 
   session_state_delegate_.reset(delegate_->CreateSessionStateDelegate());
@@ skipping 54 matching lines @@
 
   if (cursor_manager_) {
     if (initially_hide_cursor_)
       cursor_manager_->HideCursor();
     cursor_manager_->SetCursor(ui::kCursorPointer);
   }
 
 #if defined(OS_CHROMEOS)
   // Set accelerator controller delegates.
   accelerator_controller_->SetBrightnessControlDelegate(
-      scoped_ptr<BrightnessControlDelegate>(
+      std::unique_ptr<BrightnessControlDelegate>(
           new system::BrightnessControllerChromeos));
 
   power_event_observer_.reset(new PowerEventObserver());
   user_activity_notifier_.reset(
       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
   video_activity_notifier_.reset(
       new VideoActivityNotifier(video_detector_.get()));
   bluetooth_notification_controller_.reset(new BluetoothNotificationController);
   last_window_closed_logout_reminder_.reset(new LastWindowClosedLogoutReminder);
   screen_orientation_controller_.reset(new ScreenOrientationController());
@@ skipping 71 matching lines @@
 // Shell, ui::EventTarget overrides:
 
 bool Shell::CanAcceptEvent(const ui::Event& event) {
   return true;
 }
 
 ui::EventTarget* Shell::GetParentTarget() {
   return aura::Env::GetInstance();
 }
 
-scoped_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
-  return scoped_ptr<ui::EventTargetIterator>();
+std::unique_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
+  return std::unique_ptr<ui::EventTargetIterator>();
 }
 
 ui::EventTargeter* Shell::GetEventTargeter() {
   NOTREACHED();
   return nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, aura::client::ActivationChangeObserver implementation:
 
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash