Remove use of stl_util in 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 =
@@ skipping 18 matching lines @@
   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,
     TemplateURL* default_search_provider,
-    TemplateURLService::TemplateURLVector* template_urls,
+    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|.
-  typedef std::map<int, TemplateURLData*> PrepopulatedURLMap;
-  PrepopulatedURLMap prepopulated_url_map;
+  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;
 
   // Separate |template_urls| into prepopulated and non-prepopulated groups.
-  typedef std::multimap<int, TemplateURL*> UncheckedURLMap;
-  UncheckedURLMap unchecked_urls;
-  TemplateURLService::TemplateURLVector checked_urls;
-  for (TemplateURLService::TemplateURLVector::iterator i(
-       template_urls->begin()); i != template_urls->end(); ++i) {
-    TemplateURL* turl = *i;
+  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, turl));
+      unchecked_urls.insert(std::make_pair(prepopulate_id, std::move(turl)));
     else
-      checked_urls.push_back(turl);
+      checked_urls.push_back(std::move(turl));
   }
 
   // For each group of prepopulated URLs with one ID, find the best URL to use
   // and add it to the (initially all non-prepopulated) URLs we've already OKed.
   // Delete the others from the service and from memory.
   while (!unchecked_urls.empty()) {
     // Find the best URL.
     int prepopulate_id = unchecked_urls.begin()->first;
-    PrepopulatedURLMap::const_iterator prepopulated_url =
-        prepopulated_url_map.find(prepopulate_id);
-    UncheckedURLMap::iterator end = unchecked_urls.upper_bound(prepopulate_id);
-    UncheckedURLMap::iterator best = unchecked_urls.begin();
+    auto prepopulated_url = prepopulated_url_map.find(prepopulate_id);
+    auto end = unchecked_urls.upper_bound(prepopulate_id);
+    auto best = unchecked_urls.begin();
     bool matched_keyword = false;
-    for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) {
+    for (auto i = unchecked_urls.begin(); i != end; ++i) {
       // If the user-selected DSE is a prepopulated engine its properties will
       // either come from the prepopulation origin or from the user preferences
       // file (see DefaultSearchManager). Those properties will end up
       // overwriting whatever we load now anyway. If we are eliminating
       // duplicates, then, we err on the side of keeping the thing that looks
       // more like the value we will end up with in the end.
       if (default_search_provider &&
           (default_search_provider->prepopulate_id() ==
               i->second->prepopulate_id()) &&
           default_search_provider->HasSameKeywordAs(i->second->data(),
@@ skipping 10 matching lines @@
           i->second->HasSameKeywordAs(*prepopulated_url->second,
                                       search_terms_data)) {
         best = i;
         matched_keyword = true;
       } else if (i->second->id() < best->second->id()) {
         best = i;
       }
     }
 
     // Add the best URL to the checked group and delete the rest.
-    checked_urls.push_back(best->second);
-    for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) {
+    checked_urls.push_back(std::move(best->second));
+    for (auto i = unchecked_urls.begin(); i != end; ++i) {
       if (i == best)
         continue;
       if (service) {
         service->RemoveKeyword(i->second->id());
         if (removed_keyword_guids)
           removed_keyword_guids->insert(i->second->sync_guid());
       }
-      delete i->second;
     }
 
     // Done with this group.
     unchecked_urls.erase(unchecked_urls.begin(), end);
   }
 
   // Return the checked URLs.
   template_urls->swap(checked_urls);
 }
 
@@ skipping 44 matching lines @@
 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,
     size_t default_search_index,
-    TemplateURLService::TemplateURLVector* template_urls,
+    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));
 
   // Remove items.
-  for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
-       i < actions.removed_engines.end(); ++i) {
-    std::unique_ptr<TemplateURL> template_url(*i);
-    TemplateURLService::TemplateURLVector::iterator j = std::find(
-        template_urls->begin(), template_urls->end(), template_url.get());
+  for (const auto* removed_engine : actions.removed_engines) {
+    auto j = FindTemplateURL(template_urls, removed_engine);
     DCHECK(j != template_urls->end());
+    std::unique_ptr<TemplateURL> template_url = std::move(*j);
     DCHECK(!default_search_provider ||
            (*j)->prepopulate_id() != default_search_provider->prepopulate_id());
     template_urls->erase(j);
     if (service) {
       service->RemoveKeyword(template_url->id());
       if (removed_keyword_guids)
         removed_keyword_guids->insert(template_url->sync_guid());
     }
   }
 
   // Edit items.
-  for (EditedEngines::iterator i(actions.edited_engines.begin());
-       i < actions.edited_engines.end(); ++i) {
-    TemplateURLData& data = i->second;
-    std::unique_ptr<TemplateURL> existing_url(i->first);
+  for (const auto& edited_engine : actions.edited_engines) {
+    const TemplateURLData& data = edited_engine.second;
     if (service)
       service->UpdateKeyword(data);
 
     // Replace the entry in |template_urls| with the updated one.
-    TemplateURLService::TemplateURLVector::iterator j = std::find(
-        template_urls->begin(), template_urls->end(), existing_url.get());
-    *j = new TemplateURL(data);
+    auto j = FindTemplateURL(template_urls, edited_engine.first);
+    *j = base::MakeUnique<TemplateURL>(data);
   }
 
   // Add items.
-  for (std::vector<TemplateURLData>::const_iterator it =
-           actions.added_engines.begin();
-       it != actions.added_engines.end();
-       ++it) {
-    template_urls->push_back(new TemplateURL(*it));
-  }
+  for (const auto& added_engine : actions.added_engines)
+    template_urls->push_back(base::MakeUnique<TemplateURL>(added_engine));
 }
 
 ActionsFromPrepopulateData CreateActionsFromCurrentPrepopulateData(
     ScopedVector<TemplateURLData>* prepopulated_urls,
-    const TemplateURLService::TemplateURLVector& existing_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;
-  for (TemplateURLService::TemplateURLVector::const_iterator i(
-       existing_urls.begin()); i != existing_urls.end(); ++i) {
-    int prepopulate_id = (*i)->prepopulate_id();
+  for (auto& turl : existing_urls) {
+    int prepopulate_id = turl->prepopulate_id();
     if (prepopulate_id > 0)
-      id_to_turl[prepopulate_id] = *i;
+      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]);
@@ skipping 38 matching lines @@
       actions.removed_engines.push_back(template_url);
   }
 
   return actions;
 }
 
 void GetSearchProvidersUsingKeywordResult(
     const WDTypedResult& result,
     KeywordWebDataService* service,
     PrefService* prefs,
-    TemplateURLService::TemplateURLVector* template_urls,
+    TemplateURLService::OwnedTemplateURLVector* template_urls,
     TemplateURL* default_search_provider,
     const SearchTermsData& search_terms_data,
     int* new_resource_keyword_version,
     std::set<std::string>* removed_keyword_guids) {
   DCHECK(template_urls);
   DCHECK(template_urls->empty());
   DCHECK_EQ(KEYWORDS_RESULT, result.GetType());
   DCHECK(new_resource_keyword_version);
 
   WDKeywordsResult keyword_result = reinterpret_cast<
       const WDResult<WDKeywordsResult>*>(&result)->GetValue();
 
-  for (KeywordTable::Keywords::iterator i(keyword_result.keywords.begin());
-       i != keyword_result.keywords.end(); ++i) {
+  for (auto& keyword : keyword_result.keywords) {
     // Fix any duplicate encodings in the local database.  Note that we don't
     // adjust the last_modified time of this keyword; this way, we won't later
     // overwrite any changes on the sync server that happened to this keyword
     // since the last time we synced.  Instead, we also run a de-duping pass on
     // the server-provided data in
     // TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData() and
     // update the server with the merged, de-duped results at that time.  We
     // still fix here, though, to correct problems in clients that have disabled
     // search engine sync, since in that case that code will never be reached.
-    if (DeDupeEncodings(&i->input_encodings) && service)
-      service->UpdateKeyword(*i);
-    template_urls->push_back(new TemplateURL(*i));
+    if (DeDupeEncodings(&keyword.input_encodings) && service)
+      service->UpdateKeyword(keyword);
+    template_urls->push_back(base::MakeUnique<TemplateURL>(keyword));
   }
 
   *new_resource_keyword_version = keyword_result.builtin_keyword_version;
   GetSearchProvidersUsingLoadedEngines(service, prefs, template_urls,
                                        default_search_provider,
                                        search_terms_data,
                                        new_resource_keyword_version,
                                        removed_keyword_guids);
 }
 
 void GetSearchProvidersUsingLoadedEngines(
     KeywordWebDataService* service,
     PrefService* prefs,
-    TemplateURLService::TemplateURLVector* template_urls,
+    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 =
       TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs,
                                                          &default_search_index);
@@ skipping 17 matching lines @@
   std::vector<std::string> deduped_encodings;
   std::set<std::string> encoding_set;
   for (std::vector<std::string>::const_iterator i(encodings->begin());
        i != encodings->end(); ++i) {
     if (encoding_set.insert(*i).second)
       deduped_encodings.push_back(*i);
   }
   encodings->swap(deduped_encodings);
   return encodings->size() != deduped_encodings.size();
 }
+
+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;
+                      });
+}