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

chrome/browser/ui/ash/launcher/chrome_launcher_controller.cc

 // Copyright 2013 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/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 441 matching lines @@
 
 #if defined(OS_CHROMEOS)
   // On Chrome OS using multi profile we want to switch the content of the shelf
   // with a user change. Note that for unit tests the instance can be NULL.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() !=
           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_OFF) {
     user_switch_observer_.reset(
         new ChromeLauncherControllerUserSwitchObserver(this));
   }
 
-  scoped_ptr<AppWindowLauncherController> extension_app_window_controller;
+  std::unique_ptr<AppWindowLauncherController> extension_app_window_controller;
   // Create our v1/v2 application / browser monitors which will inform the
   // launcher of status changes.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED) {
     // If running in separated destkop mode, we create the multi profile version
     // of status monitor.
     browser_status_monitor_.reset(new MultiProfileBrowserStatusMonitor(this));
     extension_app_window_controller.reset(
         new MultiProfileAppWindowLauncherController(this));
   } else {
     // Create our v1/v2 application / browser monitors which will inform the
     // launcher of status changes.
     browser_status_monitor_.reset(new BrowserStatusMonitor(this));
     extension_app_window_controller.reset(
         new ExtensionAppWindowLauncherController(this));
   }
   app_window_controllers_.push_back(std::move(extension_app_window_controller));
 
-  scoped_ptr<AppWindowLauncherController> arc_app_window_controller;
+  std::unique_ptr<AppWindowLauncherController> arc_app_window_controller;
   arc_app_window_controller.reset(new ArcAppWindowLauncherController(this));
   app_window_controllers_.push_back(std::move(arc_app_window_controller));
 #else
   // Create our v1/v2 application / browser monitors which will inform the
   // launcher of status changes.
   browser_status_monitor_.reset(new BrowserStatusMonitor(this));
-  scoped_ptr<AppWindowLauncherController> extension_app_window_controller;
+  std::unique_ptr<AppWindowLauncherController> extension_app_window_controller;
   extension_app_window_controller.reset(
       new ExtensionAppWindowLauncherController(this));
   app_window_controllers_.push_back(std::move(extension_app_window_controller));
 #endif
 
   // Right now ash::Shell isn't created for tests.
   // TODO(mukai): Allows it to observe display change and write tests.
   if (ash::Shell::HasInstance()) {
     ash::Shell::GetInstance()->window_tree_host_manager()->AddObserver(this);
     // If it got already set, we remove the observer first again and swap the
@@ skipping 312 matching lines @@
   // If there is an existing non-shortcut controller for this app, open it.
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (id) {
     LauncherItemController* controller = GetLauncherItemController(id);
     controller->Activate(source);
     return;
   }
 
   // Create a temporary application launcher item and use it to see if there are
   // running instances.
-  scoped_ptr<AppShortcutLauncherItemController> app_controller(
+  std::unique_ptr<AppShortcutLauncherItemController> app_controller(
       new AppShortcutLauncherItemController(app_id, this));
   if (!app_controller->GetRunningApplications().empty())
     app_controller->Activate(source);
   else
     LaunchApp(app_id, source, event_flags);
 }
 
 extensions::LaunchType ChromeLauncherController::GetLaunchType(
     ash::ShelfID id) {
   const Extension* extension = GetExtensionForAppID(GetAppIDForShelfID(id));
@@ skipping 136 matching lines @@
   if (ignore_persist_pinned_state_change_)
     return;
   // It is a coding error to call PersistPinnedState() if the pinned apps are
   // not user-editable. The code should check earlier and not perform any
   // modification actions that trigger persisting the state.
   // Mutating kPinnedLauncherApps is going to notify us and trigger us to
   // process the change. We don't want that to happen so remove ourselves as a
   // listener.
   pref_change_registrar_.Remove(prefs::kPinnedLauncherApps);
   {
-    scoped_ptr<const base::ListValue> pinned_apps_pref =
+    std::unique_ptr<const base::ListValue> pinned_apps_pref =
         profile_->GetPrefs()
             ->GetList(prefs::kPinnedLauncherApps)
             ->CreateDeepCopy();
 
     const base::ListValue* policy_pinned_apps_pref =
         profile_->GetPrefs()->GetList(prefs::kPolicyPinnedLauncherApps);
 
     ListPrefUpdate updater(profile_->GetPrefs(), prefs::kPinnedLauncherApps);
     updater->Clear();
     for (size_t i = 0; i < model_->items().size(); ++i) {
@@ skipping 469 matching lines @@
   return CreateAppShortcutLauncherItemWithType(app_id,
                                                index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
 void ChromeLauncherController::SetAppTabHelperForTest(AppTabHelper* helper) {
   app_tab_helper_.reset(helper);
 }
 
 void ChromeLauncherController::SetAppIconLoadersForTest(
-    std::vector<scoped_ptr<AppIconLoader>>& loaders) {
+    std::vector<std::unique_ptr<AppIconLoader>>& loaders) {
   app_icon_loaders_.clear();
   for (auto& loader : loaders)
     app_icon_loaders_.push_back(std::move(loader));
 }
 
 const std::string& ChromeLauncherController::GetAppIdFromShelfIdForTest(
     ash::ShelfID id) {
   return id_to_item_controller_map_[id]->app_id();
 }
 
@@ skipping 662 matching lines @@
   }
 }
 
 void ChromeLauncherController::SetShelfItemDelegate(
     ash::ShelfID id,
     ash::ShelfItemDelegate* item_delegate) {
   DCHECK_GT(id, 0);
   DCHECK(item_delegate);
   DCHECK(item_delegate_manager_);
   item_delegate_manager_->SetShelfItemDelegate(
-      id, scoped_ptr<ash::ShelfItemDelegate>(item_delegate));
+      id, std::unique_ptr<ash::ShelfItemDelegate>(item_delegate));
 }
 
 void ChromeLauncherController::AttachProfile(Profile* profile) {
   profile_ = profile;
   // Either add the profile to the list of known profiles and make it the active
   // one for some functions of AppTabHelper or create a new one.
   if (!app_tab_helper_.get())
     app_tab_helper_.reset(new LauncherAppTabHelper(profile_));
   else
     app_tab_helper_->SetCurrentUser(profile_);
   // TODO(skuhne): The AppIconLoaderImpl has the same problem. Each loaded
   // image is associated with a profile (it's loader requires the profile).
   // Since icon size changes are possible, the icon could be requested to be
   // reloaded. However - having it not multi profile aware would cause problems
   // if the icon cache gets deleted upon user switch.
-  scoped_ptr<AppIconLoader> extension_app_icon_loader(
+  std::unique_ptr<AppIconLoader> extension_app_icon_loader(
       new extensions::ExtensionAppIconLoader(
           profile_, extension_misc::EXTENSION_ICON_SMALL, this));
   app_icon_loaders_.push_back(std::move(extension_app_icon_loader));
 
 #if defined(OS_CHROMEOS)
-  scoped_ptr<AppIconLoader> arc_app_icon_loader(new ArcAppIconLoader(
+  std::unique_ptr<AppIconLoader> arc_app_icon_loader(new ArcAppIconLoader(
       profile_, extension_misc::EXTENSION_ICON_SMALL, this));
   app_icon_loaders_.push_back(std::move(arc_app_icon_loader));
 #endif
 
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kPinnedLauncherApps,
       base::Bind(&ChromeLauncherController::UpdateAppLaunchersFromPref,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
@@ skipping 13 matching lines @@
       prefs::kShelfPreferences,
       base::Bind(&ChromeLauncherController::SetShelfBehaviorsFromPrefs,
                  base::Unretained(this)));
 #if defined(OS_CHROMEOS)
   pref_change_registrar_.Add(
       prefs::kTouchVirtualKeyboardEnabled,
       base::Bind(&ChromeLauncherController::SetVirtualKeyboardBehaviorFromPrefs,
                  base::Unretained(this)));
 #endif  // defined(OS_CHROMEOS)
 
-  scoped_ptr<LauncherAppUpdater> extension_app_updater(
+  std::unique_ptr<LauncherAppUpdater> extension_app_updater(
       new LauncherExtensionAppUpdater(this, profile_));
   app_updaters_.push_back(std::move(extension_app_updater));
 
 #if defined(OS_CHROMEOS)
-  scoped_ptr<LauncherAppUpdater> arc_app_updater(
+  std::unique_ptr<LauncherAppUpdater> arc_app_updater(
       new LauncherArcAppUpdater(this, profile_));
   app_updaters_.push_back(std::move(arc_app_updater));
 #endif
 }
 
 void ChromeLauncherController::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   app_updaters_.clear();
 
   PrefServiceSyncableFromProfile(profile_)->RemoveObserver(this);
 
   pref_change_registrar_.RemoveAll();
 }
 
 AppIconLoader* ChromeLauncherController::GetAppIconLoaderForApp(
     const std::string& app_id) {
   for (const auto& app_icon_loader : app_icon_loaders_) {
     if (app_icon_loader->CanLoadImageForApp(app_id))
       return app_icon_loader.get();
   }
 
   return nullptr;
 }