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

chrome/browser/chromeos/app_mode/kiosk_app_manager.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/chromeos/app_mode/kiosk_app_manager.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/app_session.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_external_loader.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager_observer.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_external_updater.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
@@ skipping 483 matching lines @@
   secondary_app_external_loader_created_ = true;
   KioskAppExternalLoader* secondary_loader = new KioskAppExternalLoader();
   secondary_app_external_loader_ = secondary_loader->AsWeakPtr();
 
   return secondary_loader;
 }
 
 void KioskAppManager::InstallFromCache(const std::string& id) {
   const base::DictionaryValue* extension = nullptr;
   if (external_cache_->cached_extensions()->GetDictionary(id, &extension)) {
-    scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
     base::DictionaryValue* extension_copy = extension->DeepCopy();
     prefs->Set(id, extension_copy);
     external_loader_->SetCurrentAppExtensions(std::move(prefs));
   } else {
     LOG(ERROR) << "Can't find app in the cached externsions"
                << " id = " << id;
   }
 }
 
 void KioskAppManager::InstallSecondaryApps(
     const std::vector<std::string>& ids) {
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   for (const std::string& id : ids) {
-    scoped_ptr<base::DictionaryValue> extension_entry(
+    std::unique_ptr<base::DictionaryValue> extension_entry(
         new base::DictionaryValue);
     extension_entry->SetStringWithoutPathExpansion(
         extensions::ExternalProviderImpl::kExternalUpdateUrl,
         extension_urls::GetWebstoreUpdateUrl().spec());
     extension_entry->SetBoolean(
         extensions::ExternalProviderImpl::kIsFromWebstore, true);
     prefs->Set(id, std::move(extension_entry));
   }
   secondary_app_external_loader_->SetCurrentAppExtensions(std::move(prefs));
 }
@@ skipping 74 matching lines @@
 
   return nullptr;
 }
 
 KioskAppData* KioskAppManager::GetAppDataMutable(const std::string& app_id) {
   return const_cast<KioskAppData*>(GetAppData(app_id));
 }
 
 void KioskAppManager::UpdateAppData() {
   // Gets app id to data mapping for existing apps.
-  std::map<std::string, scoped_ptr<KioskAppData>> old_apps;
+  std::map<std::string, std::unique_ptr<KioskAppData>> old_apps;
   for (auto& app : apps_)
     old_apps[app->app_id()] = std::move(app);
   apps_.clear();
 
   auto_launch_app_id_.clear();
   std::string auto_login_account_id;
   CrosSettings::Get()->GetString(kAccountsPrefDeviceLocalAccountAutoLoginId,
                                  &auto_login_account_id);
 
   // Re-populates |apps_| and reuses existing KioskAppData when possible.
@@ skipping 13 matching lines @@
     const AccountId account_id(AccountId::FromUserEmail(it->user_id));
     auto old_it = old_apps.find(it->kiosk_app_id);
     if (old_it != old_apps.end()) {
       apps_.push_back(std::move(old_it->second));
       old_apps.erase(old_it);
     } else {
       base::FilePath cached_crx;
       std::string version;
       GetCachedCrx(it->kiosk_app_id, &cached_crx, &version);
 
-      apps_.push_back(make_scoped_ptr(
+      apps_.push_back(base::WrapUnique(
           new KioskAppData(this, it->kiosk_app_id, account_id,
                            GURL(it->kiosk_app_update_url), cached_crx)));
       apps_.back()->Load();
     }
     CancelDelayedCryptohomeRemoval(cryptohome::Identification(account_id));
   }
 
   ClearRemovedApps(old_apps);
   UpdateExternalCachePrefs();
   RetryFailedAppDataFetch();
 
   FOR_EACH_OBSERVER(KioskAppManagerObserver, observers_,
                     OnKioskAppsSettingsChanged());
 }
 
 void KioskAppManager::ClearRemovedApps(
-    const std::map<std::string, scoped_ptr<KioskAppData>>& old_apps) {
+    const std::map<std::string, std::unique_ptr<KioskAppData>>& old_apps) {
   base::Closure cryptohomes_barrier_closure;
 
   const user_manager::User* active_user =
       user_manager::UserManager::Get()->GetActiveUser();
   if (active_user) {
     const AccountId active_account_id = active_user->GetAccountId();
     for (const auto& it : old_apps) {
       if (it.second->account_id() == active_account_id) {
         VLOG(1) << "Currently running kiosk app removed from policy, exiting";
         cryptohomes_barrier_closure = BarrierClosure(
@@ skipping 11 matching lines @@
     cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
         cryptohome_id, base::Bind(&OnRemoveAppCryptohomeComplete, cryptohome_id,
                                   entry.first, cryptohomes_barrier_closure));
     apps_to_remove.push_back(entry.second->app_id());
   }
   external_cache_->RemoveExtensions(apps_to_remove);
 }
 
 void KioskAppManager::UpdateExternalCachePrefs() {
   // Request external_cache_ to download new apps and update the existing apps.
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   for (size_t i = 0; i < apps_.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
 
     if (apps_[i]->update_url().is_valid()) {
       entry->SetString(extensions::ExternalProviderImpl::kExternalUpdateUrl,
                        apps_[i]->update_url().spec());
     } else {
       entry->SetString(extensions::ExternalProviderImpl::kExternalUpdateUrl,
                        extension_urls::GetWebstoreUpdateUrl().spec());
     }
 
     prefs->Set(apps_[i]->app_id(), entry.release());
@@ skipping 84 matching lines @@
 base::TimeDelta KioskAppManager::GetAutoLaunchDelay() const {
   int delay;
   if (!CrosSettings::Get()->GetInteger(
           kAccountsPrefDeviceLocalAccountAutoLoginDelay, &delay)) {
     return base::TimeDelta();  // Default delay is 0ms.
   }
   return base::TimeDelta::FromMilliseconds(delay);
 }
 
 }  // namespace chromeos