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

chrome/browser/extensions/external_provider_impl.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 "chrome/browser/extensions/external_provider_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 325 matching lines @@
       if (!path.IsAbsolute()) {
         base::FilePath base_path = loader_->GetBaseCrxFilePath();
         if (base_path.empty()) {
           LOG(WARNING) << "File path " << external_crx.c_str()
                        << " is relative.  An absolute path is required.";
           continue;
         }
         path = base_path.Append(external_crx);
       }
 
-      scoped_ptr<Version> version(new Version(external_version));
+      std::unique_ptr<Version> version(new Version(external_version));
       if (!version->IsValid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Invalid version string \""
                      << external_version << "\".";
         continue;
       }
       external_file_extensions->push_back(new ExternalInstallInfoFile(
           extension_id, std::move(version), path, crx_location_, creation_flags,
           auto_acknowledge_, install_immediately_));
     } else {  // if (has_external_update_url)
       CHECK(has_external_update_url);  // Checking of keys above ensures this.
       if (download_location_ == Manifest::INVALID_LOCATION) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from update URLs.";
         continue;
       }
-      scoped_ptr<GURL> update_url(new GURL(external_update_url));
+      std::unique_ptr<GURL> update_url(new GURL(external_update_url));
       if (!update_url->is_valid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Key " << kExternalUpdateUrl
                      << " has value \"" << external_update_url
                      << "\", which is not a valid URL.";
         continue;
       }
       external_update_url_extensions->push_back(
           new ExternalInstallInfoUpdateUrl(
               extension_id, install_parameter, std::move(update_url),
@@ skipping 19 matching lines @@
 
 bool ExternalProviderImpl::HasExtension(
     const std::string& id) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   return prefs_->HasKey(id);
 }
 
 bool ExternalProviderImpl::GetExtensionDetails(
-    const std::string& id, Manifest::Location* location,
-    scoped_ptr<Version>* version) const {
+    const std::string& id,
+    Manifest::Location* location,
+    std::unique_ptr<Version>* version) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   base::DictionaryValue* extension = NULL;
   if (!prefs_->GetDictionary(id, &extension))
     return false;
 
   Manifest::Location loc = Manifest::INVALID_LOCATION;
   if (extension->HasKey(kExternalUpdateUrl)) {
     loc = download_location_;
@@ skipping 135 matching lines @@
     if (!kiosk_app_manager->external_loader_created()) {
       // For enterprise managed kiosk apps, change the location to
       // "force-installed by policy".
       policy::BrowserPolicyConnectorChromeOS* const connector =
           g_browser_process->platform_part()
               ->browser_policy_connector_chromeos();
       Manifest::Location location = Manifest::EXTERNAL_PREF;
       if (connector && connector->IsEnterpriseManaged())
         location = Manifest::EXTERNAL_POLICY;
 
-      scoped_ptr<ExternalProviderImpl> kiosk_app_provider(
+      std::unique_ptr<ExternalProviderImpl> kiosk_app_provider(
           new ExternalProviderImpl(
               service, kiosk_app_manager->CreateExternalLoader(), profile,
               location, Manifest::INVALID_LOCATION, Extension::NO_FLAGS));
       kiosk_app_provider->set_auto_acknowledge(true);
       kiosk_app_provider->set_install_immediately(true);
       provider_list->push_back(
           linked_ptr<ExternalProviderInterface>(kiosk_app_provider.release()));
     }
 
     // Kiosk secondary app external provider.
     if (!kiosk_app_manager->secondary_app_external_loader_created()) {
-      scoped_ptr<ExternalProviderImpl> secondary_kiosk_app_provider(
+      std::unique_ptr<ExternalProviderImpl> secondary_kiosk_app_provider(
           new ExternalProviderImpl(
               service, kiosk_app_manager->CreateSecondaryAppExternalLoader(),
               profile, Manifest::EXTERNAL_PREF,
               Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS));
       secondary_kiosk_app_provider->set_auto_acknowledge(true);
       secondary_kiosk_app_provider->set_install_immediately(true);
       provider_list->push_back(linked_ptr<ExternalProviderInterface>(
           secondary_kiosk_app_provider.release()));
     }
 #endif
@@ skipping 129 matching lines @@
                 service,
                 new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS,
                                        ExternalPrefLoader::NONE,
                                        NULL),
                 Manifest::INTERNAL,
                 Manifest::INTERNAL,
                 Extension::FROM_WEBSTORE |
                     Extension::WAS_INSTALLED_BY_DEFAULT)));
 #endif
 
-    scoped_ptr<ExternalProviderImpl> drive_migration_provider(
+    std::unique_ptr<ExternalProviderImpl> drive_migration_provider(
         new ExternalProviderImpl(
             service,
-            new ExtensionMigrator(profile,
-                                  extension_misc::kDriveHostedAppId,
+            new ExtensionMigrator(profile, extension_misc::kDriveHostedAppId,
                                   extension_misc::kDriveExtensionId),
-            profile,
-            Manifest::EXTERNAL_PREF,
-            Manifest::EXTERNAL_PREF_DOWNLOAD,
-            Extension::FROM_WEBSTORE |
-                Extension::WAS_INSTALLED_BY_DEFAULT));
+            profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+            Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT));
     drive_migration_provider->set_auto_acknowledge(true);
     provider_list->push_back(linked_ptr<ExternalProviderInterface>(
         drive_migration_provider.release()));
   }
 
   provider_list->push_back(
     linked_ptr<ExternalProviderInterface>(
       new ExternalProviderImpl(
           service,
           new ExternalComponentLoader(profile),
           profile,
           Manifest::INVALID_LOCATION,
           Manifest::EXTERNAL_COMPONENT,
           Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
 }
 
 }  // namespace extensions