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

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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/extensions/extension_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 439 matching lines @@
   }
   for (const std::string& extension : extensions_to_enable) {
     EnableExtension(extension);
   }
 }
 
 void ExtensionService::MaybeFinishShutdownDelayed() {
   TRACE_EVENT0("browser,startup",
                "ExtensionService::MaybeFinishShutdownDelayed");
 
-  scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> delayed_info(
+  std::unique_ptr<extensions::ExtensionPrefs::ExtensionsInfo> delayed_info(
       extension_prefs_->GetAllDelayedInstallInfo());
   for (size_t i = 0; i < delayed_info->size(); ++i) {
     ExtensionInfo* info = delayed_info->at(i).get();
     scoped_refptr<const Extension> extension(nullptr);
     if (info->extension_manifest) {
       std::string error;
       extension = Extension::Create(
           info->extension_path, info->extension_location,
           *info->extension_manifest,
           extension_prefs_->GetDelayedInstallCreationFlags(info->extension_id),
           info->extension_id, &error);
       if (extension.get())
         delayed_installs_.Insert(extension);
     }
   }
   MaybeFinishDelayedInstallations();
-  scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> delayed_info2(
+  std::unique_ptr<extensions::ExtensionPrefs::ExtensionsInfo> delayed_info2(
       extension_prefs_->GetAllDelayedInstallInfo());
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateOnLoad",
                            delayed_info2->size() - delayed_info->size());
 }
 
 void ExtensionService::LoadGreylistFromPrefs() {
   TRACE_EVENT0("browser,startup", "ExtensionService::LoadGreylistFromPrefs");
 
-  scoped_ptr<ExtensionSet> all_extensions =
+  std::unique_ptr<ExtensionSet> all_extensions =
       registry_->GenerateInstalledExtensionsSet();
 
   for (const auto& extension : *all_extensions) {
     const extensions::BlacklistState state =
         extension_prefs_->GetExtensionBlacklistState(extension->id());
     if (state == extensions::BLACKLISTED_SECURITY_VULNERABILITY ||
         state == extensions::BLACKLISTED_POTENTIALLY_UNWANTED ||
         state == extensions::BLACKLISTED_CWS_POLICY_VIOLATION)
       greylist_.Insert(extension);
   }
@@ skipping 170 matching lines @@
 
   // If we're reloading a component extension, use the component extension
   // loader's reloader.
   if (component_loader_->Exists(extension_id)) {
     component_loader_->Reload(extension_id);
     return;
   }
 
   // Check the installed extensions to see if what we're reloading was already
   // installed.
-  scoped_ptr<ExtensionInfo> installed_extension(
+  std::unique_ptr<ExtensionInfo> installed_extension(
       extension_prefs_->GetInstalledExtensionInfo(extension_id));
   if (installed_extension.get() &&
       installed_extension->extension_manifest.get()) {
     extensions::InstalledLoader(this).Load(*installed_extension, false);
   } else {
     // Otherwise, the extension is unpacked (location LOAD).
     // We should always be able to remember the extension's path. If it's not in
     // the map, someone failed to update |unloaded_extension_paths_|.
     CHECK(!path.empty());
     scoped_refptr<extensions::UnpackedInstaller> unpacked_installer =
@@ skipping 246 matching lines @@
 
 // Extensions that are not locked, components or forced by policy should be
 // locked. Extensions are no longer considered enabled or disabled. Blacklisted
 // extensions are now considered both blacklisted and locked.
 void ExtensionService::BlockAllExtensions() {
   if (block_extensions_)
     return;
   block_extensions_ = true;
 
   // Blacklisted extensions are already unloaded, need not be blocked.
-  scoped_ptr<ExtensionSet> extensions =
+  std::unique_ptr<ExtensionSet> extensions =
       registry_->GenerateInstalledExtensionsSet(ExtensionRegistry::ENABLED |
                                                 ExtensionRegistry::DISABLED |
                                                 ExtensionRegistry::TERMINATED);
 
   for (const auto& extension : *extensions) {
     const std::string& id = extension->id();
 
     if (!CanBlockExtension(extension.get()))
       continue;
 
     registry_->RemoveEnabled(id);
     registry_->RemoveDisabled(id);
     registry_->RemoveTerminated(id);
 
     registry_->AddBlocked(extension.get());
     UnloadExtension(id, extensions::UnloadedExtensionInfo::REASON_LOCK_ALL);
   }
 }
 
 // All locked extensions should revert to being either enabled or disabled
 // as appropriate.
 void ExtensionService::UnblockAllExtensions() {
   block_extensions_ = false;
-  scoped_ptr<ExtensionSet> to_unblock =
+  std::unique_ptr<ExtensionSet> to_unblock =
       registry_->GenerateInstalledExtensionsSet(ExtensionRegistry::BLOCKED);
 
   for (const auto& extension : *to_unblock) {
     registry_->RemoveBlocked(extension->id());
     AddExtension(extension.get());
   }
 }
 
 void ExtensionService::GrantPermissionsAndEnableExtension(
     const Extension* extension) {
@@ skipping 334 matching lines @@
 
   // Install any pending extensions.
   if (update_once_all_providers_are_ready_ && updater()) {
     update_once_all_providers_are_ready_ = false;
     extensions::ExtensionUpdater::CheckParams params;
     params.callback = external_updates_finished_callback_;
     updater()->CheckNow(params);
   }
 
   // Uninstall all the unclaimed extensions.
-  scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> extensions_info(
+  std::unique_ptr<extensions::ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
     if (Manifest::IsExternalLocation(info->extension_location))
       CheckExternalUninstall(info->extension_id);
   }
 
   error_controller_->ShowErrorIfNeeded();
 
   external_install_manager_->UpdateExternalExtensionAlert();
@@ skipping 246 matching lines @@
   if (auto_grant_permission)
     GrantPermissions(extension);
 
   bool is_privilege_increase = false;
   // We only need to compare the granted permissions to the current permissions
   // if the extension has not been auto-granted its permissions above and is
   // installed internally.
   if (extension->location() == Manifest::INTERNAL && !auto_grant_permission) {
     // Add all the recognized permissions if the granted permissions list
     // hasn't been initialized yet.
-    scoped_ptr<const PermissionSet> granted_permissions =
+    std::unique_ptr<const PermissionSet> granted_permissions =
         extension_prefs_->GetGrantedPermissions(extension->id());
     CHECK(granted_permissions.get());
 
     // Here, we check if an extension's privileges have increased in a manner
     // that requires the user's approval. This could occur because the browser
     // upgraded and recognized additional privileges, or an extension upgrades
     // to a version that requires additional privileges.
     is_privilege_increase =
         extensions::PermissionMessageProvider::Get()->IsPrivilegeIncrease(
             *granted_permissions,
@@ skipping 220 matching lines @@
   }
 }
 
 void ExtensionService::OnExtensionManagementSettingsChanged() {
   error_controller_->ShowErrorIfNeeded();
 
   // Revokes blocked permissions from active_permissions for all extensions.
   extensions::ExtensionManagement* settings =
       extensions::ExtensionManagementFactory::GetForBrowserContext(profile());
   CHECK(settings);
-  scoped_ptr<ExtensionSet> all_extensions(
+  std::unique_ptr<ExtensionSet> all_extensions(
       registry_->GenerateInstalledExtensionsSet());
   for (const auto& extension : *all_extensions) {
     if (!settings->IsPermissionSetAllowed(
             extension.get(),
             extension->permissions_data()->active_permissions())) {
       extensions::PermissionsUpdater(profile()).RemovePermissionsUnsafe(
           extension.get(), *settings->GetBlockedPermissions(extension.get()));
     }
   }
 
@@ skipping 107 matching lines @@
     const std::string& id) const {
   return delayed_installs_.GetByID(id);
 }
 
 void ExtensionService::RegisterContentSettings(
     HostContentSettingsMap* host_content_settings_map) {
   TRACE_EVENT0("browser,startup", "ExtensionService::RegisterContentSettings");
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   host_content_settings_map->RegisterProvider(
       HostContentSettingsMap::INTERNAL_EXTENSION_PROVIDER,
-      scoped_ptr<content_settings::ObservableProvider>(
+      std::unique_ptr<content_settings::ObservableProvider>(
           new content_settings::InternalExtensionProvider(profile_)));
 
   host_content_settings_map->RegisterProvider(
       HostContentSettingsMap::CUSTOM_EXTENSION_PROVIDER,
-      scoped_ptr<content_settings::ObservableProvider>(
+      std::unique_ptr<content_settings::ObservableProvider>(
           new content_settings::CustomExtensionProvider(
-              extensions::ContentSettingsService::Get(
-                  profile_)->content_settings_store(),
+              extensions::ContentSettingsService::Get(profile_)
+                  ->content_settings_store(),
               profile_->GetOriginalProfile() != profile_)));
 }
 
 void ExtensionService::TrackTerminatedExtension(
     const std::string& extension_id) {
   extensions_being_terminated_.erase(extension_id);
 
   const Extension* extension = GetInstalledExtension(extension_id);
   if (!extension) {
     return;
@@ skipping 473 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }