Remove ScopedVector from search_engines.

components/search_engines/util.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/util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 
 base::string16 GetDefaultSearchEngineName(TemplateURLService* service) {
   DCHECK(service);
   const TemplateURL* const default_provider =
       service->GetDefaultSearchProvider();
@@ skipping 15 matching lines @@
   const TemplateURLRef& search_url = default_provider->url_ref();
   DCHECK(search_url.SupportsReplacement(service->search_terms_data()));
   TemplateURLRef::SearchTermsArgs search_terms_args(terms);
   search_terms_args.append_extra_query_params = true;
   return GURL(search_url.ReplaceSearchTerms(search_terms_args,
                                             service->search_terms_data()));
 }
 
 void RemoveDuplicatePrepopulateIDs(
     KeywordWebDataService* service,
-    const ScopedVector<TemplateURLData>& prepopulated_urls,
+    const std::vector<std::unique_ptr<TemplateURLData>>& prepopulated_urls,
     TemplateURL* default_search_provider,
     TemplateURLService::OwnedTemplateURLVector* template_urls,
     const SearchTermsData& search_terms_data,
     std::set<std::string>* removed_keyword_guids) {
   DCHECK(template_urls);
 
   // For convenience construct an ID->TemplateURL* map from |prepopulated_urls|.
   std::map<int, TemplateURLData*> prepopulated_url_map;
-  for (std::vector<TemplateURLData*>::const_iterator i(
-           prepopulated_urls.begin());
-       i != prepopulated_urls.end();
-       ++i)
-    prepopulated_url_map[(*i)->prepopulate_id] = *i;
+  for (const auto& url : prepopulated_urls)
+    prepopulated_url_map[url->prepopulate_id] = url.get();
 
   // Separate |template_urls| into prepopulated and non-prepopulated groups.
   std::multimap<int, std::unique_ptr<TemplateURL>> unchecked_urls;
   TemplateURLService::OwnedTemplateURLVector checked_urls;
   for (auto& turl : *template_urls) {
     int prepopulate_id = turl->prepopulate_id();
     if (prepopulate_id)
       unchecked_urls.insert(std::make_pair(prepopulate_id, std::move(turl)));
     else
       checked_urls.push_back(std::move(turl));
@@ skipping 104 matching lines @@
     const ActionsFromPrepopulateData& other) = default;
 
 ActionsFromPrepopulateData::~ActionsFromPrepopulateData() {}
 
 // This is invoked when the version of the prepopulate data changes.
 // If |removed_keyword_guids| is not NULL, the Sync GUID of each item removed
 // from the DB will be added to it.  Note that this function will take
 // ownership of |prepopulated_urls| and will clear the vector.
 void MergeEnginesFromPrepopulateData(
     KeywordWebDataService* service,
-    ScopedVector<TemplateURLData>* prepopulated_urls,
+    std::vector<std::unique_ptr<TemplateURLData>>* prepopulated_urls,
     size_t default_search_index,
     TemplateURLService::OwnedTemplateURLVector* template_urls,
     TemplateURL* default_search_provider,
     std::set<std::string>* removed_keyword_guids) {
   DCHECK(prepopulated_urls);
   DCHECK(template_urls);
 
   ActionsFromPrepopulateData actions(CreateActionsFromCurrentPrepopulateData(
       prepopulated_urls, *template_urls, default_search_provider));
 
@@ skipping 22 matching lines @@
     auto j = FindTemplateURL(template_urls, edited_engine.first);
     *j = base::MakeUnique<TemplateURL>(data);
   }
 
   // Add items.
   for (const auto& added_engine : actions.added_engines)
     template_urls->push_back(base::MakeUnique<TemplateURL>(added_engine));
 }
 
 ActionsFromPrepopulateData CreateActionsFromCurrentPrepopulateData(
-    ScopedVector<TemplateURLData>* prepopulated_urls,
+    std::vector<std::unique_ptr<TemplateURLData>>* prepopulated_urls,
     const TemplateURLService::OwnedTemplateURLVector& existing_urls,
     const TemplateURL* default_search_provider) {
   // Create a map to hold all provided |template_urls| that originally came from
   // prepopulate data (i.e. have a non-zero prepopulate_id()).
-  typedef std::map<int, TemplateURL*> IDMap;
-  IDMap id_to_turl;
+  std::map<int, TemplateURL*> id_to_turl;
   for (auto& turl : existing_urls) {
     int prepopulate_id = turl->prepopulate_id();
     if (prepopulate_id > 0)
       id_to_turl[prepopulate_id] = turl.get();
   }
 
   // For each current prepopulated URL, check whether |template_urls| contained
   // a matching prepopulated URL.  If so, update the passed-in URL to match the
   // current data.  (If the passed-in URL was user-edited, we persist the user's
   // name and keyword.)  If not, add the prepopulated URL.
   ActionsFromPrepopulateData actions;
-  for (size_t i = 0; i < prepopulated_urls->size(); ++i) {
-    // We take ownership of |prepopulated_urls[i]|.
-    std::unique_ptr<TemplateURLData> prepopulated_url((*prepopulated_urls)[i]);
+  for (auto& prepopulated_url : *prepopulated_urls) {
     const int prepopulated_id = prepopulated_url->prepopulate_id;
     DCHECK_NE(0, prepopulated_id);
 
-    IDMap::iterator existing_url_iter(id_to_turl.find(prepopulated_id));
+    auto existing_url_iter = id_to_turl.find(prepopulated_id);
     if (existing_url_iter != id_to_turl.end()) {
       // Update the data store with the new prepopulated data. Preserve user
       // edits to the name and keyword.
       TemplateURL* existing_url(existing_url_iter->second);
       id_to_turl.erase(existing_url_iter);
       MergeIntoPrepopulatedEngineData(existing_url, prepopulated_url.get());
       // Update last_modified to ensure that if this entry is later merged with
       // entries from Sync, the conflict resolution logic knows that this was
       // updated and propagates the new values to the server.
       prepopulated_url->last_modified = base::Time::Now();
       actions.edited_engines.push_back(
           std::make_pair(existing_url, *prepopulated_url));
     } else {
       actions.added_engines.push_back(*prepopulated_url);
     }
   }
-  // The above loop takes ownership of all the contents of prepopulated_urls.
-  // Clear the pointers.
-  prepopulated_urls->weak_erase(prepopulated_urls->begin(),
-                                prepopulated_urls->end());
 
   // The block above removed all the URLs from the |id_to_turl| map that were
   // found in the prepopulate data.  Any remaining URLs that haven't been
   // user-edited or made default can be removed from the data store.
   // We assume that this entry is equivalent to the DSE if its prepopulate ID
   // and keyword both match. If the prepopulate ID _does_ match all properties
   // will be replaced with those from |default_search_provider| anyway.
-  for (IDMap::iterator i(id_to_turl.begin()); i != id_to_turl.end(); ++i) {
+  for (auto i = id_to_turl.begin(); i != id_to_turl.end(); ++i) {
     TemplateURL* template_url = i->second;
     if ((template_url->safe_for_autoreplace()) &&
         (!default_search_provider ||
          (template_url->prepopulate_id() !=
              default_search_provider->prepopulate_id()) ||
          (template_url->keyword() != default_search_provider->keyword())))
       actions.removed_engines.push_back(template_url);
   }
 
   return actions;
@@ skipping 43 matching lines @@
     KeywordWebDataService* service,
     PrefService* prefs,
     TemplateURLService::OwnedTemplateURLVector* template_urls,
     TemplateURL* default_search_provider,
     const SearchTermsData& search_terms_data,
     int* resource_keyword_version,
     std::set<std::string>* removed_keyword_guids) {
   DCHECK(template_urls);
   DCHECK(resource_keyword_version);
   size_t default_search_index;
-  ScopedVector<TemplateURLData> prepopulated_urls =
+  std::vector<std::unique_ptr<TemplateURLData>> prepopulated_urls =
       TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs,
                                                          &default_search_index);
   RemoveDuplicatePrepopulateIDs(service, prepopulated_urls,
                                 default_search_provider, template_urls,
                                 search_terms_data, removed_keyword_guids);
 
   const int prepopulate_resource_keyword_version =
       TemplateURLPrepopulateData::GetDataVersion(prefs);
   if (*resource_keyword_version < prepopulate_resource_keyword_version) {
     MergeEnginesFromPrepopulateData(
@@ skipping 18 matching lines @@
 }
 
 TemplateURLService::OwnedTemplateURLVector::iterator FindTemplateURL(
     TemplateURLService::OwnedTemplateURLVector* urls,
     const TemplateURL* url) {
   return std::find_if(urls->begin(), urls->end(),
                       [url](const std::unique_ptr<TemplateURL>& ptr) {
                         return ptr.get() == url;
                       });
 }