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

chrome/browser/extensions/extension_management.cc

 // Copyright 2014 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/extensions/extension_management.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 87 matching lines @@
   if (extension->manifest()->GetString(manifest_keys::kUpdateURL,
                                        &update_url)) {
     auto iter_update_url = settings_by_update_url_.find(update_url);
     if (iter_update_url != settings_by_update_url_.end())
       return iter_update_url->second->installation_mode;
   }
   // Fall back to default installation mode setting.
   return default_settings_->installation_mode;
 }
 
-scoped_ptr<base::DictionaryValue> ExtensionManagement::GetForceInstallList()
-    const {
-  scoped_ptr<base::DictionaryValue> install_list(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue>
+ExtensionManagement::GetForceInstallList() const {
+  std::unique_ptr<base::DictionaryValue> install_list(
+      new base::DictionaryValue());
   for (SettingsIdMap::const_iterator it = settings_by_id_.begin();
        it != settings_by_id_.end();
        ++it) {
     if (it->second->installation_mode == INSTALLATION_FORCED) {
       ExternalPolicyLoader::AddExtension(
           install_list.get(), it->first, it->second->update_url);
     }
   }
   return install_list;
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ExtensionManagement::GetRecommendedInstallList() const {
-  scoped_ptr<base::DictionaryValue> install_list(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> install_list(
+      new base::DictionaryValue());
   for (SettingsIdMap::const_iterator it = settings_by_id_.begin();
        it != settings_by_id_.end();
        ++it) {
     if (it->second->installation_mode == INSTALLATION_RECOMMENDED) {
       ExternalPolicyLoader::AddExtension(
           install_list.get(), it->first, it->second->update_url);
     }
   }
   return install_list;
 }
@@ skipping 63 matching lines @@
   }
   // Check whether if in one of them, setting is specified.
   if (iter_id != settings_by_id_.end())
     return iter_id->second->blocked_permissions;
   if (iter_update_url != settings_by_update_url_.end())
     return iter_update_url->second->blocked_permissions;
   // Fall back to the default blocked permissions setting.
   return default_settings_->blocked_permissions;
 }
 
-scoped_ptr<const PermissionSet> ExtensionManagement::GetBlockedPermissions(
+std::unique_ptr<const PermissionSet> ExtensionManagement::GetBlockedPermissions(
     const Extension* extension) const {
   // Only api permissions are supported currently.
-  return scoped_ptr<const PermissionSet>(new PermissionSet(
+  return std::unique_ptr<const PermissionSet>(new PermissionSet(
       GetBlockedAPIPermissions(extension), ManifestPermissionSet(),
       URLPatternSet(), URLPatternSet()));
 }
 
 bool ExtensionManagement::IsPermissionSetAllowed(
     const Extension* extension,
     const PermissionSet& perms) const {
   for (const auto& blocked_api : GetBlockedAPIPermissions(extension)) {
     if (perms.HasAPIPermission(blocked_api->id()))
       return false;
@@ skipping 212 matching lines @@
 void ExtensionManagement::NotifyExtensionManagementPrefChanged() {
   FOR_EACH_OBSERVER(
       Observer, observer_list_, OnExtensionManagementSettingsChanged());
 }
 
 internal::IndividualSettings* ExtensionManagement::AccessById(
     const ExtensionId& id) {
   DCHECK(crx_file::id_util::IdIsValid(id)) << "Invalid ID: " << id;
   SettingsIdMap::iterator it = settings_by_id_.find(id);
   if (it == settings_by_id_.end()) {
-    scoped_ptr<internal::IndividualSettings> settings(
+    std::unique_ptr<internal::IndividualSettings> settings(
         new internal::IndividualSettings(default_settings_.get()));
     it = settings_by_id_.add(id, std::move(settings)).first;
   }
   return it->second;
 }
 
 internal::IndividualSettings* ExtensionManagement::AccessByUpdateUrl(
     const std::string& update_url) {
   DCHECK(GURL(update_url).is_valid()) << "Invalid update URL: " << update_url;
   SettingsUpdateUrlMap::iterator it = settings_by_update_url_.find(update_url);
   if (it == settings_by_update_url_.end()) {
-    scoped_ptr<internal::IndividualSettings> settings(
+    std::unique_ptr<internal::IndividualSettings> settings(
         new internal::IndividualSettings(default_settings_.get()));
     it = settings_by_update_url_.add(update_url, std::move(settings)).first;
   }
   return it->second;
 }
 
 ExtensionManagement* ExtensionManagementFactory::GetForBrowserContext(
     content::BrowserContext* context) {
   return static_cast<ExtensionManagement*>(
       GetInstance()->GetServiceForBrowserContext(context, true));
@@ skipping 24 matching lines @@
     content::BrowserContext* context) const {
   return chrome::GetBrowserContextRedirectedInIncognito(context);
 }
 
 void ExtensionManagementFactory::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterDictionaryPref(pref_names::kExtensionManagement);
 }
 
 }  // namespace extensions