Remove most ScopedVector usage from c/b/extensions.

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 104 matching lines @@
 void ExternalProviderImpl::SetPrefs(base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the service is still alive. It is possible that it went
   // away while |loader_| was working on the FILE thread.
   if (!service_) return;
 
   prefs_.reset(prefs);
   ready_ = true;  // Queries for extensions are allowed from this point.
 
-  ScopedVector<ExternalInstallInfoUpdateUrl> external_update_url_extensions;
-  ScopedVector<ExternalInstallInfoFile> external_file_extensions;
+  std::vector<std::unique_ptr<ExternalInstallInfoUpdateUrl>>
+      external_update_url_extensions;
+  std::vector<std::unique_ptr<ExternalInstallInfoFile>>
+      external_file_extensions;
 
   RetrieveExtensionsFromPrefs(&external_update_url_extensions,
                               &external_file_extensions);
-  for (auto* extension : external_update_url_extensions)
+  for (const auto& extension : external_update_url_extensions)
     service_->OnExternalExtensionUpdateUrlFound(*extension, true);
 
-  for (auto* extension : external_file_extensions)
+  for (const auto& extension : external_file_extensions)
     service_->OnExternalExtensionFileFound(*extension);
 
   service_->OnExternalProviderReady(this);
 }
 
 void ExternalProviderImpl::UpdatePrefs(base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // We only expect updates from windows registry.
   CHECK(crx_location_ == Manifest::EXTERNAL_REGISTRY);
 
   // Check if the service is still alive. It is possible that it went
   // away while |loader_| was working on the FILE thread.
   if (!service_)
     return;
 
   std::set<std::string> removed_extensions;
   // Find extensions that were removed by this ExternalProvider.
   for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) {
     const std::string& extension_id = i.key();
     // Don't bother about invalid ids.
     if (!crx_file::id_util::IdIsValid(extension_id))
       continue;
     if (!prefs->HasKey(extension_id))
       removed_extensions.insert(extension_id);
   }
 
   prefs_.reset(prefs);
 
-  ScopedVector<ExternalInstallInfoUpdateUrl> external_update_url_extensions;
-  ScopedVector<ExternalInstallInfoFile> external_file_extensions;
+  std::vector<std::unique_ptr<ExternalInstallInfoUpdateUrl>>
+      external_update_url_extensions;
+  std::vector<std::unique_ptr<ExternalInstallInfoFile>>
+      external_file_extensions;
   RetrieveExtensionsFromPrefs(&external_update_url_extensions,
                               &external_file_extensions);
 
   // Notify ExtensionService about completion of finding incremental updates
   // from this provider.
   // Provide the list of added and removed extensions.
   service_->OnExternalProviderUpdateComplete(
       this, external_update_url_extensions, external_file_extensions,
       removed_extensions);
 }
 
 void ExternalProviderImpl::RetrieveExtensionsFromPrefs(
-    ScopedVector<ExternalInstallInfoUpdateUrl>* external_update_url_extensions,
-    ScopedVector<ExternalInstallInfoFile>* external_file_extensions) {
+    std::vector<std::unique_ptr<ExternalInstallInfoUpdateUrl>>*
+        external_update_url_extensions,
+    std::vector<std::unique_ptr<ExternalInstallInfoFile>>*
+        external_file_extensions) {
   // Set of unsupported extensions that need to be deleted from prefs_.
   std::set<std::string> unsupported_extensions;
 
   // Discover all the extensions this provider has.
   for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) {
     const std::string& extension_id = i.key();
     const base::DictionaryValue* extension = NULL;
 
     if (!crx_file::id_util::IdIsValid(extension_id)) {
       LOG(WARNING) << "Malformed extension dictionary: key "
@@ skipping 156 matching lines @@
       }
 
       std::unique_ptr<base::Version> version(
           new base::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_));
+      external_file_extensions->push_back(
+          base::MakeUnique<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;
       }
       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(
+          base::MakeUnique<ExternalInstallInfoUpdateUrl>(
               extension_id, install_parameter, std::move(update_url),
               download_location_, creation_flags, auto_acknowledge_));
     }
   }
 
   for (std::set<std::string>::iterator it = unsupported_extensions.begin();
        it != unsupported_extensions.end(); ++it) {
     // Remove extension for the list of know external extensions. The extension
     // will be uninstalled later because provider doesn't provide it anymore.
     prefs_->Remove(*it, NULL);
@@ skipping 304 matching lines @@
     provider_list->push_back(std::move(drive_migration_provider));
   }
 
   provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
       service, new ExternalComponentLoader(profile), profile,
       Manifest::INVALID_LOCATION, Manifest::EXTERNAL_COMPONENT,
       Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT));
 }
 
 }  // namespace extensions