Remove ScopedVector from search_engines.

components/search_engines/template_url_prepopulate_data.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 "components/search_engines/template_url_prepopulate_data.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include <locale.h>
 #endif
 
@@ skipping 998 matching lines @@
   for (size_t i = 0; i < alternate_urls.GetSize(); ++i) {
     std::string alternate_url;
     alternate_urls.GetString(i, &alternate_url);
     DCHECK(!alternate_url.empty());
     data->alternate_urls.push_back(alternate_url);
   }
   data->search_terms_replacement_key = search_terms_replacement_key.as_string();
   return data;
 }
 
-ScopedVector<TemplateURLData> GetPrepopulatedTemplateURLData(
+std::vector<std::unique_ptr<TemplateURLData>> GetPrepopulatedTemplateURLData(
     PrefService* prefs) {
-  ScopedVector<TemplateURLData> t_urls;
+  std::vector<std::unique_ptr<TemplateURLData>> t_urls;
   if (!prefs)
     return t_urls;
 
   const base::ListValue* list = prefs->GetList(prefs::kSearchProviderOverrides);
   if (!list)
     return t_urls;
 
   size_t num_engines = list->GetSize();
   for (size_t i = 0; i != num_engines; ++i) {
     const base::DictionaryValue* engine;
@@ skipping 30 matching lines @@
       engine->GetString("image_url", &image_url);
       engine->GetString("new_tab_url", &new_tab_url);
       engine->GetString("contextual_search_url", &contextual_search_url);
       engine->GetString("search_url_post_params", &search_url_post_params);
       engine->GetString("suggest_url_post_params", &suggest_url_post_params);
       engine->GetString("instant_url_post_params", &instant_url_post_params);
       engine->GetString("image_url_post_params", &image_url_post_params);
       engine->GetList("alternate_urls", &alternate_urls);
       engine->GetString("search_terms_replacement_key",
           &search_terms_replacement_key);
-      t_urls.push_back(MakePrepopulatedTemplateURLData(name, keyword,
-          search_url, suggest_url, instant_url, image_url, new_tab_url,
-          contextual_search_url, search_url_post_params,
+      t_urls.push_back(MakePrepopulatedTemplateURLData(
+          name, keyword, search_url, suggest_url, instant_url, image_url,
+          new_tab_url, contextual_search_url, search_url_post_params,
           suggest_url_post_params, instant_url_post_params,
           image_url_post_params, favicon_url, encoding, *alternate_urls,
-          search_terms_replacement_key, id).release());
+          search_terms_replacement_key, id));
     }
   }
   return t_urls;
 }
 
 bool SameDomain(const GURL& given_url, const GURL& prepopulated_url) {
   return prepopulated_url.is_valid() &&
       net::registry_controlled_domains::SameDomainOrHost(
           given_url, prepopulated_url,
           net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
 }
 
 }  // namespace
 
 // Global functions -----------------------------------------------------------
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(prefs::kCountryIDAtInstall, kCountryIDUnknown);
   registry->RegisterListPref(prefs::kSearchProviderOverrides);
   registry->RegisterIntegerPref(prefs::kSearchProviderOverridesVersion, -1);
 }
 
 int GetDataVersion(PrefService* prefs) {
   // Allow tests to override the local version.
   return (prefs && prefs->HasPrefPath(prefs::kSearchProviderOverridesVersion)) ?
       prefs->GetInteger(prefs::kSearchProviderOverridesVersion) :
       kCurrentDataVersion;
 }
 
-ScopedVector<TemplateURLData> GetPrepopulatedEngines(
+std::vector<std::unique_ptr<TemplateURLData>> GetPrepopulatedEngines(
     PrefService* prefs,
     size_t* default_search_provider_index) {
   // If there is a set of search engines in the preferences file, it overrides
   // the built-in set.
   *default_search_provider_index = 0;
-  ScopedVector<TemplateURLData> t_urls = GetPrepopulatedTemplateURLData(prefs);
+  std::vector<std::unique_ptr<TemplateURLData>> t_urls =
+      GetPrepopulatedTemplateURLData(prefs);
   if (!t_urls.empty())
     return t_urls;
 
   const PrepopulatedEngine** engines;
   size_t num_engines;
   GetPrepopulationSetFromCountryID(prefs, &engines, &num_engines);
   for (size_t i = 0; i != num_engines; ++i) {
-    t_urls.push_back(
-        MakeTemplateURLDataFromPrepopulatedEngine(*engines[i]).release());
+    t_urls.push_back(MakeTemplateURLDataFromPrepopulatedEngine(*engines[i]));
   }
   return t_urls;
 }
 
 std::vector<const PrepopulatedEngine*> GetAllPrepopulatedEngines() {
   return std::vector<const PrepopulatedEngine*>(std::begin(kAllEngines),
                                                 std::end(kAllEngines));
 }
 
 std::unique_ptr<TemplateURLData> MakeTemplateURLDataFromPrepopulatedEngine(
@@ skipping 17 matching lines @@
 void ClearPrepopulatedEnginesInPrefs(PrefService* prefs) {
   if (!prefs)
     return;
 
   prefs->ClearPref(prefs::kSearchProviderOverrides);
   prefs->ClearPref(prefs::kSearchProviderOverridesVersion);
 }
 
 std::unique_ptr<TemplateURLData> GetPrepopulatedDefaultSearch(
     PrefService* prefs) {
-  std::unique_ptr<TemplateURLData> default_search_provider;
   size_t default_search_index;
   // This could be more efficient.  We are loading all the URLs to only keep
   // the first one.
-  ScopedVector<TemplateURLData> loaded_urls =
+  std::vector<std::unique_ptr<TemplateURLData>> loaded_urls =
       GetPrepopulatedEngines(prefs, &default_search_index);
-  if (default_search_index < loaded_urls.size()) {
-    default_search_provider.reset(loaded_urls[default_search_index]);
-    loaded_urls.weak_erase(loaded_urls.begin() + default_search_index);
-  }
-  return default_search_provider;
+
+  return (default_search_index < loaded_urls.size())
+             ? std::move(loaded_urls[default_search_index])
+             : nullptr;
 }
 
 SearchEngineType GetEngineType(const GURL& url) {
   DCHECK(url.is_valid());
 
   // Check using TLD+1s, in order to more aggressively match search engine types
   // for data imported from other browsers.
   //
   // First special-case Google, because the prepopulate URL for it will not
   // convert to a GURL and thus won't have an origin.  Instead see if the
@@ skipping 79 matching lines @@
         base::ToUpperASCII(locale_str[begin]),
         base::ToUpperASCII(locale_str[begin + 1]));
   }
 
   return kCountryIDUnknown;
 }
 
 #endif  // OS_*
 
 }  // namespace TemplateURLPrepopulateData