Convert //ash from scoped_ptr to std::unique_ptr

ash/accelerators/accelerator_controller.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/accelerators/accelerator_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <utility>
@@ skipping 143 matching lines @@
 
   return l10n_util::GetStringFUTF16(message_id, new_shortcut, old_shortcut);
 }
 
 void ShowDeprecatedAcceleratorNotification(const char* const notification_id,
                                            int message_id,
                                            int old_shortcut_id,
                                            int new_shortcut_id) {
   const base::string16 message =
       GetNotificationText(message_id, old_shortcut_id, new_shortcut_id);
-  scoped_ptr<message_center::Notification> notification(
+  std::unique_ptr<message_center::Notification> notification(
       new message_center::Notification(
           message_center::NOTIFICATION_TYPE_SIMPLE, notification_id,
           base::string16(), message,
           Shell::GetInstance()->delegate()->GetDeprecatedAcceleratorImage(),
           base::string16(), GURL(),
           message_center::NotifierId(
               message_center::NotifierId::SYSTEM_COMPONENT,
               system_notifier::kNotifierDeprecatedAccelerator),
           message_center::RichNotificationData(),
           new DeprecatedAcceleratorNotificationDelegate));
@@ skipping 637 matching lines @@
   }
   return false;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetCurrentAcceleratorRestriction() {
   return GetAcceleratorProcessingRestriction(-1);
 }
 
 void AcceleratorController::SetBrightnessControlDelegate(
-    scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
+    std::unique_ptr<BrightnessControlDelegate> brightness_control_delegate) {
   brightness_control_delegate_ = std::move(brightness_control_delegate);
 }
 
 void AcceleratorController::SetImeControlDelegate(
-    scoped_ptr<ImeControlDelegate> ime_control_delegate) {
+    std::unique_ptr<ImeControlDelegate> ime_control_delegate) {
   ime_control_delegate_ = std::move(ime_control_delegate);
 }
 
 void AcceleratorController::SetScreenshotDelegate(
-    scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
+    std::unique_ptr<ScreenshotDelegate> screenshot_delegate) {
   screenshot_delegate_ = std::move(screenshot_delegate);
 }
 
 bool AcceleratorController::ShouldCloseMenuAndRepostAccelerator(
     const ui::Accelerator& accelerator) const {
   auto itr = accelerators_.find(accelerator);
   if (itr == accelerators_.end())
     return false;  // Menu shouldn't be closed for an invalid accelerator.
 
   AcceleratorAction action = itr->second;
@@ skipping 580 matching lines @@
   if (shell->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
         ui::A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
-    scoped_ptr<KeyboardBrightnessControlDelegate>
-    keyboard_brightness_control_delegate) {
+    std::unique_ptr<KeyboardBrightnessControlDelegate>
+        keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       std::move(keyboard_brightness_control_delegate);
 }
 
 }  // namespace ash