Remove use of stl_util in search_engines.

components/search_engines/template_url_service.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_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
-#include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "components/omnibox/browser/omnibox_field_trial.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/rappor_service.h"
 #include "components/search_engines/search_engines_pref_names.h"
@@ skipping 146 matching lines @@
                                   const TemplateURL* turl) {
   if (OmniboxFieldTrial::KeywordRequiresRegistry())
     return keyword.length();
   const size_t registry_length = GetRegistryLength(keyword);
   if (registry_length == std::string::npos)
     return keyword.length();
   DCHECK_LT(registry_length, keyword.length());
   // The meaningful keyword length is the length of any portion before the
   // registry ("co.uk") and its preceding dot.
   return keyword.length() - (registry_length ? (registry_length + 1) : 0);
+}
 
+bool Contains(TemplateURLService::OwnedTemplateURLVector* template_urls,
+              TemplateURL* turl) {
+  return FindTemplateURL(template_urls, turl) != template_urls->end();
 }
 
 }  // namespace
 
 // TemplateURLService::LessWithPrefix -----------------------------------------
 
 class TemplateURLService::LessWithPrefix {
  public:
   // We want to find the set of keywords that begin with a prefix.  The STL
   // algorithms will return the set of elements that are "equal to" the
   // prefix, where "equal(x, y)" means "!(cmp(x, y) || cmp(y, x))".  When
   // cmp() is the typical std::less<>, this results in lexicographic equality;
   // we need to extend this to mark a prefix as "not less than" a keyword it
   // begins, which will cause the desired elements to be considered "equal to"
   // the prefix.  Note: this is still a strict weak ordering, as required by
   // equal_range() (though I will not prove that here).
   //
   // Unfortunately the calling convention is not "prefix and element" but
   // rather "two elements", so we pass the prefix as a fake "element" which has
   // a NULL KeywordDataElement pointer.
   bool operator()(
       const KeywordToTURLAndMeaningfulLength::value_type& elem1,
       const KeywordToTURLAndMeaningfulLength::value_type& elem2) const {
-    return (elem1.second.first == NULL) ?
-        (elem2.first.compare(0, elem1.first.length(), elem1.first) > 0) :
-        (elem1.first < elem2.first);
+    return (elem1.second.first == nullptr)
+               ? (elem2.first.compare(0, elem1.first.length(), elem1.first) > 0)
+               : (elem1.first < elem2.first);
   }
 };
 
 
 // TemplateURLService ---------------------------------------------------------
 
 TemplateURLService::TemplateURLService(
     PrefService* prefs,
     std::unique_ptr<SearchTermsData> search_terms_data,
     const scoped_refptr<KeywordWebDataService>& web_data_service,
     std::unique_ptr<TemplateURLServiceClient> client,
     GoogleURLTracker* google_url_tracker,
     rappor::RapporService* rappor_service,
     const base::Closure& dsp_change_callback)
     : prefs_(prefs),
       search_terms_data_(std::move(search_terms_data)),
       web_data_service_(web_data_service),
       client_(std::move(client)),
       google_url_tracker_(google_url_tracker),
       rappor_service_(rappor_service),
       dsp_change_callback_(dsp_change_callback),
       provider_map_(new SearchHostToURLsMap),
       loaded_(false),
       load_failed_(false),
       disable_load_(false),
       load_handle_(0),
-      default_search_provider_(NULL),
+      default_search_provider_(nullptr),
       next_id_(kInvalidTemplateURLID + 1),
       clock_(new base::DefaultClock),
       models_associated_(false),
       processing_syncer_changes_(false),
       dsp_change_origin_(DSP_CHANGE_OTHER),
       default_search_manager_(
           prefs_,
           base::Bind(&TemplateURLService::OnDefaultSearchChange,
                      base::Unretained(this))) {
   DCHECK(search_terms_data_);
-  Init(NULL, 0);
+  Init(nullptr, 0);
 }
 
 TemplateURLService::TemplateURLService(const Initializer* initializers,
                                        const int count)
-    : prefs_(NULL),
+    : prefs_(nullptr),
       search_terms_data_(new SearchTermsData),
-      web_data_service_(NULL),
-      google_url_tracker_(NULL),
-      rappor_service_(NULL),
+      web_data_service_(nullptr),
+      google_url_tracker_(nullptr),
+      rappor_service_(nullptr),
       provider_map_(new SearchHostToURLsMap),
       loaded_(false),
       load_failed_(false),
       disable_load_(false),
       load_handle_(0),
-      default_search_provider_(NULL),
+      default_search_provider_(nullptr),
       next_id_(kInvalidTemplateURLID + 1),
       clock_(new base::DefaultClock),
       models_associated_(false),
       processing_syncer_changes_(false),
       dsp_change_origin_(DSP_CHANGE_OTHER),
       default_search_manager_(
           prefs_,
           base::Bind(&TemplateURLService::OnDefaultSearchChange,
                      base::Unretained(this))) {
   Init(initializers, count);
 }
 
 TemplateURLService::~TemplateURLService() {
   // |web_data_service_| should be deleted during Shutdown().
   DCHECK(!web_data_service_.get());
-  base::STLDeleteElements(&template_urls_);
 }
 
 // static
 void TemplateURLService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
 #if defined(OS_IOS) || defined(OS_ANDROID)
   uint32_t flags = PrefRegistry::NO_REGISTRATION_FLAGS;
 #else
   uint32_t flags = user_prefs::PrefRegistrySyncable::SYNCABLE_PREF;
 #endif
@@ skipping 112 matching lines @@
       keyword_domain_to_turl_and_length_, prefix, supports_replacement_only,
       matches);
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForKeyword(
     const base::string16& keyword) {
   KeywordToTURLAndMeaningfulLength::const_iterator elem(
       keyword_to_turl_and_length_.find(keyword));
   if (elem != keyword_to_turl_and_length_.end())
     return elem->second.first;
-  return (!loaded_ &&
-      initial_default_search_provider_.get() &&
-      (initial_default_search_provider_->keyword() == keyword)) ?
-      initial_default_search_provider_.get() : NULL;
+  return (!loaded_ && initial_default_search_provider_ &&
+          (initial_default_search_provider_->keyword() == keyword))
+             ? initial_default_search_provider_.get()
+             : nullptr;
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForGUID(
     const std::string& sync_guid) {
   GUIDToTURL::const_iterator elem(guid_to_turl_.find(sync_guid));
   if (elem != guid_to_turl_.end())
     return elem->second;
-  return (!loaded_ &&
-      initial_default_search_provider_.get() &&
-      (initial_default_search_provider_->sync_guid() == sync_guid)) ?
-      initial_default_search_provider_.get() : NULL;
+  return (!loaded_ && initial_default_search_provider_ &&
+          (initial_default_search_provider_->sync_guid() == sync_guid))
+             ? initial_default_search_provider_.get()
+             : nullptr;
 }
 
 TemplateURL* TemplateURLService::GetTemplateURLForHost(
     const std::string& host) {
   if (loaded_)
     return provider_map_->GetTemplateURLForHost(host);
   TemplateURL* initial_dsp = initial_default_search_provider_.get();
-  if (!initial_dsp)
-    return NULL;
-  return (initial_dsp->GenerateSearchURL(search_terms_data()).host() == host) ?
-      initial_dsp : NULL;
+  return (initial_dsp &&
+          (initial_dsp->GenerateSearchURL(search_terms_data()).host() == host))
+             ? initial_dsp
+             : nullptr;
 }
 
-bool TemplateURLService::Add(TemplateURL* template_url) {
+TemplateURL* TemplateURLService::Add(
+    std::unique_ptr<TemplateURL> template_url) {
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
-  if (!AddNoNotify(template_url, true))
-    return false;
-  NotifyObservers();
-  return true;
+  TemplateURL* template_url_ptr = AddNoNotify(std::move(template_url), true);
+  if (template_url_ptr)
+    NotifyObservers();
+  return template_url_ptr;
 }
 
-void TemplateURLService::AddWithOverrides(TemplateURL* template_url,
-                                          const base::string16& short_name,
-                                          const base::string16& keyword,
-                                          const std::string& url) {
+TemplateURL* TemplateURLService::AddWithOverrides(
+    std::unique_ptr<TemplateURL> template_url,
+    const base::string16& short_name,
+    const base::string16& keyword,
+    const std::string& url) {
   DCHECK(!short_name.empty());
   DCHECK(!keyword.empty());
   DCHECK(!url.empty());
   template_url->data_.SetShortName(short_name);
   template_url->data_.SetKeyword(keyword);
   template_url->SetURL(url);
-  Add(template_url);
+  return Add(std::move(template_url));
 }
 
-void TemplateURLService::AddExtensionControlledTURL(
-    TemplateURL* template_url,
+TemplateURL* TemplateURLService::AddExtensionControlledTURL(
+    std::unique_ptr<TemplateURL> template_url,
     std::unique_ptr<TemplateURL::AssociatedExtensionInfo> info) {
   DCHECK(loaded_);
   DCHECK(template_url);
   DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
   DCHECK(info);
   DCHECK_NE(TemplateURL::NORMAL, info->type);
   DCHECK_EQ(info->wants_to_be_default_engine,
             template_url->show_in_default_list());
   DCHECK(!FindTemplateURLForExtension(info->extension_id, info->type));
   template_url->extension_info_.swap(info);
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
-  if (AddNoNotify(template_url, true)) {
-    if (template_url->extension_info_->wants_to_be_default_engine)
+  TemplateURL* template_url_ptr = AddNoNotify(std::move(template_url), true);
+  if (template_url_ptr) {
+    if (template_url_ptr->extension_info_->wants_to_be_default_engine) {
       UpdateExtensionDefaultSearchEngine();
+    }
     NotifyObservers();
   }
+
+  return template_url_ptr;
 }
 
 void TemplateURLService::Remove(TemplateURL* template_url) {
   RemoveNoNotify(template_url);
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveExtensionControlledTURL(
     const std::string& extension_id,
     TemplateURL::Type type) {
   DCHECK(loaded_);
   TemplateURL* url = FindTemplateURLForExtension(extension_id, type);
   if (!url)
     return;
   // NULL this out so that we can call RemoveNoNotify.
   // UpdateExtensionDefaultSearchEngine will cause it to be reset.
   if (default_search_provider_ == url)
-    default_search_provider_ = NULL;
+    default_search_provider_ = nullptr;
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   RemoveNoNotify(url);
   UpdateExtensionDefaultSearchEngine();
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveAutoGeneratedSince(base::Time created_after) {
   RemoveAutoGeneratedBetween(created_after, base::Time());
 }
 
 void TemplateURLService::RemoveAutoGeneratedBetween(base::Time created_after,
                                                     base::Time created_before) {
   RemoveAutoGeneratedForUrlsBetween(base::Callback<bool(const GURL&)>(),
                                     created_after, created_before);
 }
 
 void TemplateURLService::RemoveAutoGeneratedForUrlsBetween(
     const base::Callback<bool(const GURL&)>& url_filter,
     base::Time created_after,
     base::Time created_before) {
   bool should_notify = false;
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   for (size_t i = 0; i < template_urls_.size();) {
     if (template_urls_[i]->date_created() >= created_after &&
         (created_before.is_null() ||
          template_urls_[i]->date_created() < created_before) &&
-        CanReplace(template_urls_[i]) &&
+        CanReplace(template_urls_[i].get()) &&
         (url_filter.is_null() ||
          url_filter.Run(
              template_urls_[i]->GenerateSearchURL(search_terms_data())))) {
-      RemoveNoNotify(template_urls_[i]);
+      RemoveNoNotify(template_urls_[i].get());
       should_notify = true;
     } else {
       ++i;
     }
   }
   if (should_notify)
     NotifyObservers();
 }
 
 void TemplateURLService::RegisterOmniboxKeyword(
      const std::string& extension_id,
      const std::string& extension_name,
      const std::string& keyword,
      const std::string& template_url_string) {
   DCHECK(loaded_);
 
   if (FindTemplateURLForExtension(extension_id,
                                   TemplateURL::OMNIBOX_API_EXTENSION))
     return;
 
   TemplateURLData data;
   data.SetShortName(base::UTF8ToUTF16(extension_name));
   data.SetKeyword(base::UTF8ToUTF16(keyword));
   data.SetURL(template_url_string);
-  TemplateURL* url = new TemplateURL(data);
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> info(
       new TemplateURL::AssociatedExtensionInfo(
           TemplateURL::OMNIBOX_API_EXTENSION, extension_id));
-  AddExtensionControlledTURL(url, std::move(info));
+  AddExtensionControlledTURL(base::MakeUnique<TemplateURL>(data),
+                             std::move(info));
 }
 
 TemplateURLService::TemplateURLVector TemplateURLService::GetTemplateURLs() {
-  return template_urls_;
+  TemplateURLVector result;
+  for (const auto& turl : template_urls_)
+    result.push_back(turl.get());
+  return result;
 }
 
 void TemplateURLService::IncrementUsageCount(TemplateURL* url) {
   DCHECK(url);
   // Extension-controlled search engines are not persisted.
   if (url->GetType() != TemplateURL::NORMAL)
     return;
-  if (std::find(template_urls_.begin(), template_urls_.end(), url) ==
-      template_urls_.end())
+  if (!Contains(&template_urls_, url))
     return;
   ++url->data_.usage_count;
 
   if (web_data_service_.get())
     web_data_service_->UpdateKeyword(url->data());
 }
 
 void TemplateURLService::ResetTemplateURL(TemplateURL* url,
                                           const base::string16& title,
                                           const base::string16& keyword,
@@ skipping 16 matching lines @@
     TemplateURL* url) {
   // Omnibox keywords cannot be made default. Extension-controlled search
   // engines can be made default only by the extension itself because they
   // aren't persisted.
   DCHECK(!url || (url->GetType() == TemplateURL::NORMAL));
   if (load_failed_) {
     // Skip the DefaultSearchManager, which will persist to user preferences.
     if ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
         (default_search_provider_source_ ==
          DefaultSearchManager::FROM_FALLBACK)) {
-      ApplyDefaultSearchChange(url ? &url->data() : NULL,
+      ApplyDefaultSearchChange(url ? &url->data() : nullptr,
                                DefaultSearchManager::FROM_USER);
     }
   } else {
     // We rely on the DefaultSearchManager to call OnDefaultSearchChange if, in
     // fact, the effective DSE changes.
     if (url)
       default_search_manager_.SetUserSelectedDefaultSearchEngine(url->data());
     else
       default_search_manager_.ClearUserSelectedDefaultSearchEngine();
   }
@@ skipping 23 matching lines @@
 
 void TemplateURLService::RepairPrepopulatedSearchEngines() {
   // Can't clean DB if it hasn't been loaded.
   DCHECK(loaded());
 
   if ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
       (default_search_provider_source_ ==
           DefaultSearchManager::FROM_FALLBACK)) {
     // Clear |default_search_provider_| in case we want to remove the engine it
     // points to. This will get reset at the end of the function anyway.
-    default_search_provider_ = NULL;
+    default_search_provider_ = nullptr;
   }
 
   size_t default_search_provider_index = 0;
   ScopedVector<TemplateURLData> prepopulated_urls =
       TemplateURLPrepopulateData::GetPrepopulatedEngines(
           prefs_, &default_search_provider_index);
   DCHECK(!prepopulated_urls.empty());
   ActionsFromPrepopulateData actions(CreateActionsFromCurrentPrepopulateData(
       &prepopulated_urls, template_urls_, default_search_provider_));
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   // Remove items.
   for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
        i < actions.removed_engines.end(); ++i)
     RemoveNoNotify(*i);
 
   // Edit items.
   for (EditedEngines::iterator i(actions.edited_engines.begin());
        i < actions.edited_engines.end(); ++i) {
     TemplateURL new_values(i->second);
     UpdateNoNotify(i->first, new_values);
   }
 
   // Add items.
   for (std::vector<TemplateURLData>::const_iterator i =
            actions.added_engines.begin();
        i < actions.added_engines.end();
        ++i) {
-    AddNoNotify(new TemplateURL(*i), true);
+    AddNoNotify(base::MakeUnique<TemplateURL>(*i), true);
   }
 
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(
       &dsp_change_origin_, DSP_CHANGE_PROFILE_RESET);
 
   default_search_manager_.ClearUserSelectedDefaultSearchEngine();
 
   if (!default_search_provider_) {
     // If the default search provider came from a user pref we would have been
     // notified of the new (fallback-provided) value in
@@ skipping 50 matching lines @@
   if (!result) {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile1(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 TemplateURLService::OnWebDataServiceRequestDone 1"));
 
     // Results are null if the database went away or (most likely) wasn't
     // loaded.
     load_failed_ = true;
-    web_data_service_ = NULL;
+    web_data_service_ = nullptr;
     ChangeToLoadedState();
     return;
   }
 
-  TemplateURLVector template_urls;
+  std::unique_ptr<OwnedTemplateURLVector> template_urls =
+      base::MakeUnique<OwnedTemplateURLVector>();
   int new_resource_keyword_version = 0;
   {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile2(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 TemplateURLService::OnWebDataServiceRequestDone 2"));
 
     GetSearchProvidersUsingKeywordResult(
-        *result, web_data_service_.get(), prefs_, &template_urls,
+        *result, web_data_service_.get(), prefs_, template_urls.get(),
         (default_search_provider_source_ == DefaultSearchManager::FROM_USER)
             ? initial_default_search_provider_.get()
-            : NULL,
+            : nullptr,
         search_terms_data(), &new_resource_keyword_version, &pre_sync_deletes_);
   }
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile4(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 TemplateURLService::OnWebDataServiceRequestDone 4"));
 
-    PatchMissingSyncGUIDs(&template_urls);
+    PatchMissingSyncGUIDs(template_urls.get());
 
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile41(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 TemplateURLService::OnWebDataServiceRequestDone 41"));
 
-    SetTemplateURLs(&template_urls);
+    SetTemplateURLs(std::move(template_urls));
 
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile42(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 TemplateURLService::OnWebDataServiceRequestDone 42"));
 
     // This initializes provider_map_ which should be done before
     // calling UpdateKeywordSearchTermsForURL.
     // This also calls NotifyObservers.
@@ skipping 69 matching lines @@
 void TemplateURLService::Shutdown() {
   if (client_)
     client_->Shutdown();
   // This check has to be done at Shutdown() instead of in the dtor to ensure
   // that no clients of KeywordWebDataService are holding ptrs to it after the
   // first phase of the KeyedService Shutdown() process.
   if (load_handle_) {
     DCHECK(web_data_service_.get());
     web_data_service_->CancelRequest(load_handle_);
   }
-  web_data_service_ = NULL;
+  web_data_service_ = nullptr;
 }
 
 syncer::SyncDataList TemplateURLService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::SEARCH_ENGINES, type);
 
   syncer::SyncDataList current_data;
-  for (TemplateURLVector::const_iterator iter = template_urls_.begin();
-      iter != template_urls_.end(); ++iter) {
+  for (const auto& turl : template_urls_) {
     // We don't sync keywords managed by policy.
-    if ((*iter)->created_by_policy())
+    if (turl->created_by_policy())
       continue;
     // We don't sync extension-controlled search engines.
-    if ((*iter)->GetType() != TemplateURL::NORMAL)
+    if (turl->GetType() != TemplateURL::NORMAL)
       continue;
-    current_data.push_back(CreateSyncDataFromTemplateURL(**iter));
+    current_data.push_back(CreateSyncDataFromTemplateURL(*turl));
   }
 
   return current_data;
 }
 
 syncer::SyncError TemplateURLService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   if (!models_associated_) {
     syncer::SyncError error(FROM_HERE,
@@ skipping 87 matching lines @@
       if (existing_keyword_turl) {
         // Resolve any conflicts so we can safely add the new entry.
         ResolveSyncKeywordConflict(turl.get(), existing_keyword_turl,
                                    &new_changes);
       }
       base::AutoReset<DefaultSearchChangeOrigin> change_origin(
           &dsp_change_origin_, DSP_CHANGE_SYNC_ADD);
       // Force the local ID to kInvalidTemplateURLID so we can add it.
       TemplateURLData data(turl->data());
       data.id = kInvalidTemplateURLID;
-      TemplateURL* added = new TemplateURL(data);
-      if (Add(added))
+      std::unique_ptr<TemplateURL> added_ptr =
+          base::MakeUnique<TemplateURL>(data);
+      TemplateURL* added = added_ptr.get();
+      if (Add(std::move(added_ptr)))
         MaybeUpdateDSEAfterSync(added);
     } else if (iter->change_type() == syncer::SyncChange::ACTION_UPDATE) {
       if (!existing_turl) {
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_UPDATE");
         continue;
       }
       if (existing_keyword_turl && (existing_keyword_turl != existing_turl)) {
         // Resolve any conflicts with other entries so we can safely update the
@@ skipping 252 matching lines @@
 
   // Past bugs might have caused either of these fields to be empty.  Just
   // delete this data off the server.
   if (specifics.url().empty() || specifics.sync_guid().empty()) {
     change_list->push_back(
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_DELETE,
                            sync_data));
     UMA_HISTOGRAM_ENUMERATION(kDeleteSyncedEngineHistogramName,
         DELETE_ENGINE_EMPTY_FIELD, DELETE_ENGINE_MAX);
-    return NULL;
+    return nullptr;
   }
 
   TemplateURLData data(existing_turl ?
       existing_turl->data() : TemplateURLData());
   data.SetShortName(base::UTF8ToUTF16(specifics.short_name()));
   data.originating_url = GURL(specifics.originating_url());
   base::string16 keyword(base::UTF8ToUTF16(specifics.keyword()));
   // NOTE: Once this code has shipped in a couple of stable releases, we can
   // probably remove the migration portion, comment out the
   // "autogenerate_keyword" field entirely in the .proto file, and fold the
@@ skipping 41 matching lines @@
 
   // We used to sync keywords associated with omnibox extensions, but no longer
   // want to.  However, if we delete these keywords from sync, we'll break any
   // synced old versions of Chrome which were relying on them.  Instead, for now
   // we simply ignore these.
   // TODO(vasilii): After a few Chrome versions, change this to go ahead and
   // delete these from sync.
   DCHECK(client);
   client->RestoreExtensionInfoIfNecessary(turl.get());
   if (turl->GetType() == TemplateURL::OMNIBOX_API_EXTENSION)
-    return NULL;
+    return nullptr;
 
   DCHECK_EQ(TemplateURL::NORMAL, turl->GetType());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(search_terms_data, true);
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
     change_list->push_back(syncer::SyncChange(FROM_HERE,
                                               syncer::SyncChange::ACTION_UPDATE,
                                               sync_data));
   } else if (turl->IsGoogleSearchURLWithReplaceableKeyword(search_terms_data)) {
@@ skipping 63 matching lines @@
       DCHECK(initializers[i].keyword);
       DCHECK(initializers[i].url);
       DCHECK(initializers[i].content);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
       TemplateURLData data;
       data.SetShortName(base::UTF8ToUTF16(initializers[i].content));
       data.SetKeyword(base::UTF8ToUTF16(initializers[i].keyword));
       data.SetURL(initializers[i].url);
-      TemplateURL* template_url = new TemplateURL(data);
-      AddNoNotify(template_url, true);
+      AddNoNotify(base::MakeUnique<TemplateURL>(data), true);
 
       // Set the first provided identifier to be the default.
       if (i == 0)
         default_search_manager_.SetUserSelectedDefaultSearchEngine(data);
     }
   }
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine.
   RequestGoogleURLTrackerServerCheckIfNecessary();
 }
 
 void TemplateURLService::RemoveFromMaps(TemplateURL* template_url) {
   const base::string16& keyword = template_url->keyword();
   DCHECK_NE(0U, keyword_to_turl_and_length_.count(keyword));
   if (keyword_to_turl_and_length_[keyword].first == template_url) {
     // We need to check whether the keyword can now be provided by another
     // TemplateURL.  See the comments in AddToMaps() for more information on
     // extension keywords and how they can coexist with non-extension keywords.
     // In the case of more than one extension, we use the most recently
     // installed (which will be the most recently added, which will have the
     // highest ID).
-    TemplateURL* best_fallback = NULL;
-    for (TemplateURLVector::const_iterator i(template_urls_.begin());
-         i != template_urls_.end(); ++i) {
-      TemplateURL* turl = *i;
+    TemplateURL* best_fallback = nullptr;
+    for (const auto& turl : template_urls_) {
       // This next statement relies on the fact that there can only be one
       // non-Omnibox API TemplateURL with a given keyword.
-      if ((turl != template_url) && (turl->keyword() == keyword) &&
+      if ((turl.get() != template_url) && (turl->keyword() == keyword) &&
           (!best_fallback ||
            (best_fallback->GetType() != TemplateURL::OMNIBOX_API_EXTENSION) ||
            ((turl->GetType() == TemplateURL::OMNIBOX_API_EXTENSION) &&
             (turl->id() > best_fallback->id()))))
-        best_fallback = turl;
+        best_fallback = turl.get();
     }
     RemoveFromDomainMap(template_url);
     if (best_fallback) {
       AddToMap(best_fallback);
       AddToDomainMap(best_fallback);
     } else {
       keyword_to_turl_and_length_.erase(keyword);
     }
   }
 
@@ skipping 71 matching lines @@
   }
 }
 
 void TemplateURLService::AddToMap(TemplateURL* template_url) {
   const base::string16& keyword = template_url->keyword();
   keyword_to_turl_and_length_[keyword] =
       TURLAndMeaningfulLength(
           template_url, GetMeaningfulKeywordLength(keyword, template_url));
 }
 
-// Helper for partition() call in next function.
-bool HasValidID(TemplateURL* t_url) {
-  return t_url->id() != kInvalidTemplateURLID;
-}
-
-void TemplateURLService::SetTemplateURLs(TemplateURLVector* urls) {
+void TemplateURLService::SetTemplateURLs(
+    std::unique_ptr<OwnedTemplateURLVector> urls) {
   // Partition the URLs first, instead of implementing the loops below by simply
   // scanning the input twice.  While it's not supposed to happen normally, it's
   // possible for corrupt databases to return multiple entries with the same
   // keyword.  In this case, the first loop may delete the first entry when
   // adding the second.  If this happens, the second loop must not attempt to
   // access the deleted entry.  Partitioning ensures this constraint.
-  TemplateURLVector::iterator first_invalid(
-      std::partition(urls->begin(), urls->end(), HasValidID));
+  auto first_invalid = std::partition(
+      urls->begin(), urls->end(), [](const std::unique_ptr<TemplateURL>& turl) {
+        return turl->id() != kInvalidTemplateURLID;
+      });
 
   // First, add the items that already have id's, so that the next_id_ gets
   // properly set.
-  for (TemplateURLVector::const_iterator i = urls->begin(); i != first_invalid;
-       ++i) {
+  for (auto i = urls->begin(); i != first_invalid; ++i) {
     next_id_ = std::max(next_id_, (*i)->id());
-    AddNoNotify(*i, false);
+    AddNoNotify(std::move(*i), false);
   }
 
   // Next add the new items that don't have id's.
-  for (TemplateURLVector::const_iterator i = first_invalid; i != urls->end();
-       ++i)
-    AddNoNotify(*i, true);
-
-  // Clear the input vector to reduce the chance callers will try to use a
-  // (possibly deleted) entry.
-  urls->clear();
+  for (auto i = first_invalid; i != urls->end(); ++i)
+    AddNoNotify(std::move(*i), true);
 }
 
 void TemplateURLService::ChangeToLoadedState() {
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 TemplateURLService::ChangeToLoadedState 1"));
 
   DCHECK(!loaded_);
 
   provider_map_->Init(template_urls_, search_terms_data());
   loaded_ = true;
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 TemplateURLService::ChangeToLoadedState 2"));
 
   // This will cause a call to NotifyObservers().
   ApplyDefaultSearchChangeNoMetrics(
-      initial_default_search_provider_ ?
-          &initial_default_search_provider_->data() : NULL,
+      initial_default_search_provider_
+          ? &initial_default_search_provider_->data()
+          : nullptr,
       default_search_provider_source_);
   initial_default_search_provider_.reset();
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 TemplateURLService::ChangeToLoadedState 3"));
 
   on_loaded_callbacks_.Notify();
@@ skipping 16 matching lines @@
           t_url->safe_for_autoreplace());
 }
 
 TemplateURL* TemplateURLService::FindNonExtensionTemplateURLForKeyword(
     const base::string16& keyword) {
   TemplateURL* keyword_turl = GetTemplateURLForKeyword(keyword);
   if (!keyword_turl || (keyword_turl->GetType() == TemplateURL::NORMAL))
     return keyword_turl;
   // The extension keyword in the model may be hiding a replaceable
   // non-extension keyword.  Look for it.
-  for (TemplateURLVector::const_iterator i(template_urls_.begin());
-       i != template_urls_.end(); ++i) {
-    if (((*i)->GetType() == TemplateURL::NORMAL) &&
-        ((*i)->keyword() == keyword))
-      return *i;
+  for (const auto& turl : template_urls_) {
+    if ((turl->GetType() == TemplateURL::NORMAL) &&
+        (turl->keyword() == keyword))
+      return turl.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 bool TemplateURLService::UpdateNoNotify(TemplateURL* existing_turl,
                                         const TemplateURL& new_values) {
   DCHECK(existing_turl);
-  if (std::find(template_urls_.begin(), template_urls_.end(), existing_turl) ==
-      template_urls_.end())
+  if (!Contains(&template_urls_, existing_turl))
     return false;
 
   DCHECK_NE(TemplateURL::OMNIBOX_API_EXTENSION, existing_turl->GetType());
 
   base::string16 old_keyword(existing_turl->keyword());
   keyword_to_turl_and_length_.erase(old_keyword);
   RemoveFromDomainMap(existing_turl);
   if (!existing_turl->sync_guid().empty())
     guid_to_turl_.erase(existing_turl->sync_guid());
 
@@ skipping 152 matching lines @@
         initial_default_search_provider_->HasGoogleBaseURLs(
             search_terms_data()))
       initial_default_search_provider_->InvalidateCachedValues();
       initial_default_search_provider_->ResetKeywordIfNecessary(
           search_terms_data(), false);
     return;
   }
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   bool something_changed = false;
-  for (TemplateURLVector::iterator i(template_urls_.begin());
-       i != template_urls_.end(); ++i) {
-    TemplateURL* t_url = *i;
-    if (t_url->HasGoogleBaseURLs(search_terms_data())) {
-      TemplateURL updated_turl(t_url->data());
+  for (const auto& turl : template_urls_) {
+    if (turl->HasGoogleBaseURLs(search_terms_data())) {
+      TemplateURL updated_turl(turl->data());
       updated_turl.ResetKeywordIfNecessary(search_terms_data(), false);
       KeywordToTURLAndMeaningfulLength::const_iterator existing_entry =
           keyword_to_turl_and_length_.find(updated_turl.keyword());
       if ((existing_entry != keyword_to_turl_and_length_.end()) &&
-          (existing_entry->second.first != t_url)) {
+          (existing_entry->second.first != turl.get())) {
         // The new autogenerated keyword conflicts with another TemplateURL.
-        // Overwrite it if it's replaceable; otherwise, leave |t_url| using its
-        // current keyword.  (This will not prevent |t_url| from auto-updating
+        // Overwrite it if it's replaceable; otherwise, leave |turl| using its
+        // current keyword.  (This will not prevent |turl| from auto-updating
         // the keyword in the future if the conflicting TemplateURL disappears.)
-        // Note that we must still update |t_url| in this case, or the
+        // Note that we must still update |turl| in this case, or the
         // |provider_map_| will not be updated correctly.
         if (CanReplace(existing_entry->second.first))
           RemoveNoNotify(existing_entry->second.first);
         else
-          updated_turl.data_.SetKeyword(t_url->keyword());
+          updated_turl.data_.SetKeyword(turl->keyword());
       }
       something_changed = true;
       // This will send the keyword change to sync.  Note that other clients
       // need to reset the keyword to an appropriate local value when this
       // change arrives; see CreateTemplateURLFromTemplateURLAndSyncData().
-      UpdateNoNotify(t_url, updated_turl);
+      UpdateNoNotify(turl.get(), updated_turl);
     }
   }
   if (something_changed)
     NotifyObservers();
 }
 
 void TemplateURLService::OnDefaultSearchChange(
     const TemplateURLData* data,
     DefaultSearchManager::Source source) {
   if (prefs_ && (source == DefaultSearchManager::FROM_USER) &&
@@ skipping 22 matching lines @@
 bool TemplateURLService::ApplyDefaultSearchChangeNoMetrics(
     const TemplateURLData* data,
     DefaultSearchManager::Source source) {
   if (!loaded_) {
     // Set |initial_default_search_provider_| from the preferences. This is
     // mainly so we can hold ownership until we get to the point where the list
     // of keywords from Web Data is the owner of everything including the
     // default.
     bool changed = TemplateURL::MatchesData(
         initial_default_search_provider_.get(), data, search_terms_data());
-    initial_default_search_provider_.reset(
-        data ? new TemplateURL(*data) : NULL);
+    initial_default_search_provider_ =
+        data ? base::MakeUnique<TemplateURL>(*data) : nullptr;
     default_search_provider_source_ = source;
     return changed;
   }
 
   // Prevent recursion if we update the value stored in default_search_manager_.
   // Note that we exclude the case of data == NULL because that could cause a
   // false positive for recursion when the initial_default_search_provider_ is
   // NULL due to policy. We'll never actually get recursion with data == NULL.
-  if (source == default_search_provider_source_ && data != NULL &&
+  if (source == default_search_provider_source_ && data != nullptr &&
       TemplateURL::MatchesData(default_search_provider_, data,
                                search_terms_data()))
     return false;
 
   // This may be deleted later. Use exclusively for pointer comparison to detect
   // a change.
   TemplateURL* previous_default_search_engine = default_search_provider_;
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   if (default_search_provider_source_ == DefaultSearchManager::FROM_POLICY ||
       source == DefaultSearchManager::FROM_POLICY) {
     // We do this both to remove any no-longer-applicable policy-defined DSE as
     // well as to add the new one, if appropriate.
     UpdateProvidersCreatedByPolicy(
         &template_urls_,
-        source == DefaultSearchManager::FROM_POLICY ? data : NULL);
+        source == DefaultSearchManager::FROM_POLICY ? data : nullptr);
   }
 
   if (!data) {
-    default_search_provider_ = NULL;
+    default_search_provider_ = nullptr;
   } else if (source == DefaultSearchManager::FROM_EXTENSION) {
     default_search_provider_ = FindMatchingExtensionTemplateURL(
         *data, TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
   } else if (source == DefaultSearchManager::FROM_FALLBACK) {
     default_search_provider_ =
         FindPrepopulatedTemplateURL(data->prepopulate_id);
     if (default_search_provider_) {
       TemplateURLData update_data(*data);
       update_data.sync_guid = default_search_provider_->sync_guid();
       if (!default_search_provider_->safe_for_autoreplace()) {
         update_data.safe_for_autoreplace = false;
         update_data.SetKeyword(default_search_provider_->keyword());
         update_data.SetShortName(default_search_provider_->short_name());
       }
       UpdateNoNotify(default_search_provider_, TemplateURL(update_data));
     } else {
       // Normally the prepopulated fallback should be present in
       // |template_urls_|, but in a few cases it might not be:
       // (1) Tests that initialize the TemplateURLService in peculiar ways.
       // (2) If the user deleted the pre-populated default and we subsequently
       // lost their user-selected value.
-      TemplateURL* new_dse = new TemplateURL(*data);
-      if (AddNoNotify(new_dse, true))
+      std::unique_ptr<TemplateURL> new_dse_ptr =
+          base::MakeUnique<TemplateURL>(*data);
+      TemplateURL* new_dse = new_dse_ptr.get();
+      if (AddNoNotify(std::move(new_dse_ptr), true))
         default_search_provider_ = new_dse;
     }
   } else if (source == DefaultSearchManager::FROM_USER) {
     default_search_provider_ = GetTemplateURLForGUID(data->sync_guid);
     if (!default_search_provider_ && data->prepopulate_id) {
       default_search_provider_ =
           FindPrepopulatedTemplateURL(data->prepopulate_id);
     }
     TemplateURLData new_data(*data);
     new_data.show_in_default_list = true;
     if (default_search_provider_) {
       UpdateNoNotify(default_search_provider_, TemplateURL(new_data));
     } else {
       new_data.id = kInvalidTemplateURLID;
-      TemplateURL* new_dse = new TemplateURL(new_data);
-      if (AddNoNotify(new_dse, true))
+      std::unique_ptr<TemplateURL> new_dse_ptr =
+          base::MakeUnique<TemplateURL>(new_data);
+      TemplateURL* new_dse = new_dse_ptr.get();
+      if (AddNoNotify(std::move(new_dse_ptr), true))
         default_search_provider_ = new_dse;
     }
     if (default_search_provider_ && prefs_) {
       prefs_->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                         default_search_provider_->sync_guid());
     }
 
   }
 
   default_search_provider_source_ = source;
 
   bool changed = default_search_provider_ != previous_default_search_engine;
   if (changed)
     RequestGoogleURLTrackerServerCheckIfNecessary();
 
   NotifyObservers();
 
   return changed;
 }
 
-bool TemplateURLService::AddNoNotify(TemplateURL* template_url,
-                                     bool newly_adding) {
+TemplateURL* TemplateURLService::AddNoNotify(
+    std::unique_ptr<TemplateURL> template_url,
+    bool newly_adding) {
   DCHECK(template_url);
 
   if (newly_adding) {
     DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
-    DCHECK(std::find(template_urls_.begin(), template_urls_.end(),
-                     template_url) == template_urls_.end());
+    DCHECK(!Contains(&template_urls_, template_url.get()));
     template_url->data_.id = ++next_id_;
   }
 
   template_url->ResetKeywordIfNecessary(search_terms_data(), false);
   // Check whether |template_url|'s keyword conflicts with any already in the
   // model.
   TemplateURL* existing_keyword_turl =
       GetTemplateURLForKeyword(template_url->keyword());
 
   // Check whether |template_url|'s keyword conflicts with any already in the
   // model.  Note that we can reach here during the loading phase while
   // processing the template URLs from the web data service.  In this case,
   // GetTemplateURLForKeyword() will look not only at what's already in the
   // model, but at the |initial_default_search_provider_|.  Since this engine
   // will presumably also be present in the web data, we need to double-check
   // that any "pre-existing" entries we find are actually coming from
   // |template_urls_|, lest we detect a "conflict" between the
   // |initial_default_search_provider_| and the web data version of itself.
   if (template_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION &&
       existing_keyword_turl &&
       existing_keyword_turl->GetType() != TemplateURL::OMNIBOX_API_EXTENSION &&
-      (std::find(template_urls_.begin(), template_urls_.end(),
-                 existing_keyword_turl) != template_urls_.end())) {
-    DCHECK_NE(existing_keyword_turl, template_url);
+      Contains(&template_urls_, existing_keyword_turl)) {
+    DCHECK_NE(existing_keyword_turl, template_url.get());
     // Only replace one of the TemplateURLs if they are either both extensions,
     // or both not extensions.
     bool are_same_type = existing_keyword_turl->GetType() ==
         template_url->GetType();
     if (CanReplace(existing_keyword_turl) && are_same_type) {
       RemoveNoNotify(existing_keyword_turl);
-    } else if (CanReplace(template_url) && are_same_type) {
-      delete template_url;
-      return false;
+    } else if (CanReplace(template_url.get()) && are_same_type) {
+      return nullptr;
     } else {
       base::string16 new_keyword =
           UniquifyKeyword(*existing_keyword_turl, false);
       ResetTemplateURLNoNotify(existing_keyword_turl,
                                existing_keyword_turl->short_name(), new_keyword,
                                existing_keyword_turl->url());
     }
   }
-  template_urls_.push_back(template_url);
-  AddToMaps(template_url);
+  TemplateURL* template_url_ptr = template_url.get();
+  template_urls_.push_back(std::move(template_url));
+  AddToMaps(template_url_ptr);
 
-  if (newly_adding &&
-      (template_url->GetType() == TemplateURL::NORMAL)) {
+  if (newly_adding && (template_url_ptr->GetType() == TemplateURL::NORMAL)) {
     if (web_data_service_.get())
-      web_data_service_->AddKeyword(template_url->data());
+      web_data_service_->AddKeyword(template_url_ptr->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_turl_.
-    ProcessTemplateURLChange(FROM_HERE,
-                             template_url,
+    ProcessTemplateURLChange(FROM_HERE, template_url_ptr,
                              syncer::SyncChange::ACTION_ADD);
   }
 
-  return true;
+  return template_url_ptr;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   DCHECK(template_url != default_search_provider_);
 
-  TemplateURLVector::iterator i =
-      std::find(template_urls_.begin(), template_urls_.end(), template_url);
+  auto i = FindTemplateURL(&template_urls_, template_url);
   if (i == template_urls_.end())
     return;
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
+  std::unique_ptr<TemplateURL> scoped_turl = std::move(*i);
   template_urls_.erase(i);
 
   if (template_url->GetType() == TemplateURL::NORMAL) {
     if (web_data_service_.get())
       web_data_service_->RemoveKeyword(template_url->id());
 
     // Inform sync of the deletion.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_DELETE);
 
     UMA_HISTOGRAM_ENUMERATION(kDeleteSyncedEngineHistogramName,
                               DELETE_ENGINE_USER_ACTION, DELETE_ENGINE_MAX);
   }
 
   if (loaded_ && client_)
     client_->DeleteAllSearchTermsForKeyword(template_url->id());
-
-  // We own the TemplateURL and need to delete it.
-  delete template_url;
 }
 
 bool TemplateURLService::ResetTemplateURLNoNotify(
     TemplateURL* url,
     const base::string16& title,
     const base::string16& keyword,
     const std::string& search_url) {
   DCHECK(!keyword.empty());
   DCHECK(!search_url.empty());
   TemplateURLData data(url->data());
@@ skipping 18 matching lines @@
 }
 
 // |template_urls| are the TemplateURLs loaded from the database.
 // |default_from_prefs| is the default search provider from the preferences, or
 // NULL if the DSE is not policy-defined.
 //
 // This function removes from the vector and the database all the TemplateURLs
 // that were set by policy, unless it is the current default search provider, in
 // which case it is updated with the data from prefs.
 void TemplateURLService::UpdateProvidersCreatedByPolicy(
-    TemplateURLVector* template_urls,
+    OwnedTemplateURLVector* template_urls,
     const TemplateURLData* default_from_prefs) {
   DCHECK(template_urls);
 
-  for (TemplateURLVector::iterator i = template_urls->begin();
-       i != template_urls->end(); ) {
-    TemplateURL* template_url = *i;
+  for (auto i = template_urls->begin(); i != template_urls->end();) {
+    TemplateURL* template_url = i->get();
     if (template_url->created_by_policy()) {
       if (default_from_prefs &&
           TemplateURL::MatchesData(template_url, default_from_prefs,
                                    search_terms_data())) {
         // If the database specified a default search provider that was set
         // by policy, and the default search provider from the preferences
         // is also set by policy and they are the same, keep the entry in the
         // database and the |default_search_provider|.
         default_search_provider_ = template_url;
         // Prevent us from saving any other entries, or creating a new one.
-        default_from_prefs = NULL;
+        default_from_prefs = nullptr;
         ++i;
         continue;
       }
 
+      TemplateURLID id = template_url->id();
       RemoveFromMaps(template_url);
       i = template_urls->erase(i);
       if (web_data_service_.get())
-        web_data_service_->RemoveKeyword(template_url->id());
-      delete template_url;
+        web_data_service_->RemoveKeyword(id);
     } else {
       ++i;
     }
   }
 
   if (default_from_prefs) {
-    default_search_provider_ = NULL;
+    default_search_provider_ = nullptr;
     default_search_provider_source_ = DefaultSearchManager::FROM_POLICY;
     TemplateURLData new_data(*default_from_prefs);
     if (new_data.sync_guid.empty())
       new_data.sync_guid = base::GenerateGUID();
     new_data.created_by_policy = true;
-    TemplateURL* new_dse = new TemplateURL(new_data);
-    if (AddNoNotify(new_dse, true))
+    std::unique_ptr<TemplateURL> new_dse_ptr =
+        base::MakeUnique<TemplateURL>(new_data);
+    TemplateURL* new_dse = new_dse_ptr.get();
+    if (AddNoNotify(std::move(new_dse_ptr), true))
       default_search_provider_ = new_dse;
   }
 }
 
 void TemplateURLService::ResetTemplateURLGUID(TemplateURL* url,
                                               const std::string& guid) {
   DCHECK(loaded_);
   DCHECK(!guid.empty());
 
   TemplateURLData data(url->data());
@@ skipping 169 matching lines @@
       }
       // Remove the local data so it isn't written to sync.
       local_data->erase(guid);
     }
   }
 
   if (should_add_sync_turl) {
     // Force the local ID to kInvalidTemplateURLID so we can add it.
     TemplateURLData data(sync_turl->data());
     data.id = kInvalidTemplateURLID;
-    TemplateURL* added = new TemplateURL(data);
+    std::unique_ptr<TemplateURL> added_ptr =
+        base::MakeUnique<TemplateURL>(data);
+    TemplateURL* added = added_ptr.get();
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_SYNC_ADD);
-    if (Add(added))
+    if (Add(std::move(added_ptr)))
       MaybeUpdateDSEAfterSync(added);
-    merge_result->set_num_items_added(
-        merge_result->num_items_added() + 1);
+    merge_result->set_num_items_added(merge_result->num_items_added() + 1);
   }
 }
 
 void TemplateURLService::PatchMissingSyncGUIDs(
-    TemplateURLVector* template_urls) {
+    OwnedTemplateURLVector* template_urls) {
   DCHECK(template_urls);
-  for (TemplateURLVector::iterator i = template_urls->begin();
-       i != template_urls->end(); ++i) {
-    TemplateURL* template_url = *i;
+  for (auto& template_url : *template_urls) {
     DCHECK(template_url);
     if (template_url->sync_guid().empty() &&
         (template_url->GetType() == TemplateURL::NORMAL)) {
       template_url->data_.sync_guid = base::GenerateGUID();
       if (web_data_service_.get())
         web_data_service_->UpdateKeyword(template_url->data());
     }
   }
 }
 
@@ skipping 37 matching lines @@
   for (typename Container::const_iterator i(match_range.first);
     i != match_range.second; ++i) {
     if (!supports_replacement_only ||
         i->second.first->url_ref().SupportsReplacement(search_terms_data()))
       matches->push_back(i->second);
   }
 }
 
 TemplateURL* TemplateURLService::FindPrepopulatedTemplateURL(
     int prepopulated_id) {
-  for (TemplateURLVector::const_iterator i = template_urls_.begin();
-       i != template_urls_.end(); ++i) {
-    if ((*i)->prepopulate_id() == prepopulated_id)
-      return *i;
+  for (const auto& turl : template_urls_) {
+    if (turl->prepopulate_id() == prepopulated_id)
+      return turl.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindTemplateURLForExtension(
     const std::string& extension_id,
     TemplateURL::Type type) {
   DCHECK_NE(TemplateURL::NORMAL, type);
-  for (TemplateURLVector::const_iterator i = template_urls_.begin();
-       i != template_urls_.end(); ++i) {
-    if ((*i)->GetType() == type &&
-        (*i)->GetExtensionId() == extension_id)
-      return *i;
+  for (const auto& turl : template_urls_) {
+    if (turl->GetType() == type && turl->GetExtensionId() == extension_id)
+      return turl.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindMatchingExtensionTemplateURL(
     const TemplateURLData& data,
     TemplateURL::Type type) {
   DCHECK_NE(TemplateURL::NORMAL, type);
-  for (TemplateURLVector::const_iterator i = template_urls_.begin();
-       i != template_urls_.end(); ++i) {
-    if ((*i)->GetType() == type &&
-        TemplateURL::MatchesData(*i, &data, search_terms_data()))
-      return *i;
+  for (const auto& turl : template_urls_) {
+    if (turl->GetType() == type &&
+        TemplateURL::MatchesData(turl.get(), &data, search_terms_data()))
+      return turl.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 void TemplateURLService::UpdateExtensionDefaultSearchEngine() {
-  TemplateURL* most_recently_intalled_default = NULL;
-  for (TemplateURLVector::const_iterator i = template_urls_.begin();
-       i != template_urls_.end(); ++i) {
-    if (((*i)->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) &&
-        (*i)->extension_info_->wants_to_be_default_engine &&
-        (*i)->SupportsReplacement(search_terms_data()) &&
+  TemplateURL* most_recently_intalled_default = nullptr;
+  for (const auto& turl : template_urls_) {
+    if ((turl->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) &&
+        turl->extension_info_->wants_to_be_default_engine &&
+        turl->SupportsReplacement(search_terms_data()) &&
         (!most_recently_intalled_default ||
          (most_recently_intalled_default->extension_info_->install_time <
-             (*i)->extension_info_->install_time)))
-      most_recently_intalled_default = *i;
+          turl->extension_info_->install_time)))
+      most_recently_intalled_default = turl.get();
   }
 
   if (most_recently_intalled_default) {
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_OVERRIDE_SETTINGS_EXTENSION);
     default_search_manager_.SetExtensionControlledDefaultSearchEngine(
         most_recently_intalled_default->data());
   } else {
     default_search_manager_.ClearExtensionControlledDefaultSearchEngine();
   }
 }