Remove use of stl_util in search_engines.

chrome/browser/search_engines/template_url_service_sync_unittest.cc

Index: chrome/browser/search_engines/template_url_service_sync_unittest.cc
diff --git a/chrome/browser/search_engines/template_url_service_sync_unittest.cc b/chrome/browser/search_engines/template_url_service_sync_unittest.cc
index 997744be7762c63e666112eed9fcd1792a28b0bc..5761a9734781b76043c0211137e1553cc33387d1 100644
--- a/chrome/browser/search_engines/template_url_service_sync_unittest.cc
+++ b/chrome/browser/search_engines/template_url_service_sync_unittest.cc
@@ -206,13 +206,14 @@ class TemplateURLServiceSyncTest : public testing::Test {
 
   // Creates a TemplateURL with some test values. The caller owns the returned
   // TemplateURL*.
-  TemplateURL* CreateTestTemplateURL(const base::string16& keyword,
-                                     const std::string& url,
-                                     const std::string& guid = std::string(),
-                                     time_t last_mod = 100,
-                                     bool safe_for_autoreplace = false,
-                                     bool created_by_policy = false,
-                                     int prepopulate_id = 999999) const;
+  std::unique_ptr<TemplateURL> CreateTestTemplateURL(
+      const base::string16& keyword,
+      const std::string& url,
+      const std::string& guid = std::string(),
+      time_t last_mod = 100,
+      bool safe_for_autoreplace = false,
+      bool created_by_policy = false,
+      int prepopulate_id = 999999) const;
 
   // Verifies the two TemplateURLs are equal.
   // TODO(stevet): Share this with TemplateURLServiceTest.
@@ -227,7 +228,7 @@ class TemplateURLServiceSyncTest : public testing::Test {
   // Convenience helper for creating SyncChanges. Takes ownership of |turl|.
   syncer::SyncChange CreateTestSyncChange(
       syncer::SyncChange::SyncChangeType type,
-      TemplateURL* turl) const;
+      std::unique_ptr<TemplateURL> turl) const;
 
   // Helper that creates some initial sync data. We cheat a little by specifying
   // GUIDs for easy identification later. We also make the last_modified times
@@ -240,11 +241,10 @@ class TemplateURLServiceSyncTest : public testing::Test {
 
   // Creates a new TemplateURL copying the fields of |turl| but replacing
   // the |url| and |guid| and initializing the date_created and last_modified
-  // timestamps to a default value of 100. The caller owns the returned
-  // TemplateURL*.
-  TemplateURL* CopyTemplateURL(const TemplateURLData* turl,
-                               const std::string& url,
-                               const std::string& guid);
+  // timestamps to a default value of 100.
+  std::unique_ptr<TemplateURL> CopyTemplateURL(const TemplateURLData* turl,
+                                               const std::string& url,
+                                               const std::string& guid);
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
@@ -293,7 +293,7 @@ TemplateURLServiceSyncTest::CreateAndPassSyncErrorFactory() {
       new syncer::SyncErrorFactoryMock());
 }
 
-TemplateURL* TemplateURLServiceSyncTest::CreateTestTemplateURL(
+std::unique_ptr<TemplateURL> TemplateURLServiceSyncTest::CreateTestTemplateURL(
     const base::string16& keyword,
     const std::string& url,
     const std::string& guid,
@@ -313,7 +313,7 @@ TemplateURL* TemplateURLServiceSyncTest::CreateTestTemplateURL(
   data.prepopulate_id = prepopulate_id;
   if (!guid.empty())
     data.sync_guid = guid;
-  return new TemplateURL(data);
+  return base::MakeUnique<TemplateURL>(data);
 }
 
 void TemplateURLServiceSyncTest::AssertEquals(const TemplateURL& expected,
@@ -350,28 +350,27 @@ void TemplateURLServiceSyncTest::AssertEquals(
 
 syncer::SyncChange TemplateURLServiceSyncTest::CreateTestSyncChange(
     syncer::SyncChange::SyncChangeType type,
-    TemplateURL* turl) const {
-  // We take control of the TemplateURL so make sure it's cleaned up after
-  // we create data out of it.
-  std::unique_ptr<TemplateURL> scoped_turl(turl);
+    std::unique_ptr<TemplateURL> turl) const {
   return syncer::SyncChange(
-      FROM_HERE,
-      type,
-      TemplateURLService::CreateSyncDataFromTemplateURL(*scoped_turl));
+      FROM_HERE, type,
+      TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 }
 
 syncer::SyncDataList TemplateURLServiceSyncTest::CreateInitialSyncData() const {
   syncer::SyncDataList list;
 
-  std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
-      ASCIIToUTF16("key1"), "http://key1.com", "key1", 90));
-  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
-                                   "key2", 90));
-  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
-                                   "key3", 90));
-  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
+  std::unique_ptr<TemplateURL> turl = CreateTestTemplateURL(
+      ASCIIToUTF16("key1"), "http://key1.com", "key1", 90);
+  list.push_back(
+      TemplateURLService::CreateSyncDataFromTemplateURL(*turl.get()));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com", "key2",
+                               90);
+  list.push_back(
+      TemplateURLService::CreateSyncDataFromTemplateURL(*turl.get()));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3",
+                               90);
+  list.push_back(
+      TemplateURLService::CreateSyncDataFromTemplateURL(*turl.get()));
 
   return list;
 }
@@ -384,7 +383,7 @@ std::unique_ptr<TemplateURL> TemplateURLServiceSyncTest::Deserialize(
       &client, NULL, SearchTermsData(), NULL, sync_data, &dummy);
 }
 
-TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
+std::unique_ptr<TemplateURL> TemplateURLServiceSyncTest::CopyTemplateURL(
     const TemplateURLData* turl,
     const std::string& url,
     const std::string& guid) {
@@ -393,7 +392,7 @@ TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.sync_guid = guid;
-  return new TemplateURL(data);
+  return base::MakeUnique<TemplateURL>(data);
 }
 
 // Actual tests ---------------------------------------------------------------
@@ -452,9 +451,8 @@ TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataWithExtension) {
 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoManagedEngines) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
-  TemplateURL* managed_turl = CreateTestTemplateURL(ASCIIToUTF16("key3"),
-      "http://key3.com", std::string(), 100, false, true);
-  model()->Add(managed_turl);
+  model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
+                                     std::string(), 100, false, true));
   syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncer::SEARCH_ENGINES);
 
@@ -473,8 +471,8 @@ TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoManagedEngines) {
 TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   // Create a key that conflicts with something in the model.
-  std::unique_ptr<TemplateURL> turl(
-      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com", "xyz"));
+  std::unique_ptr<TemplateURL> turl =
+      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com", "xyz");
   base::string16 new_keyword = model()->UniquifyKeyword(*turl, false);
   EXPECT_EQ(ASCIIToUTF16("new.com"), new_keyword);
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
@@ -484,7 +482,7 @@ TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
   // Test a second collision. This time it should be resolved by actually
   // modifying the original keyword, since the autogenerated keyword is already
   // used.
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com"));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com");
   new_keyword = model()->UniquifyKeyword(*turl, false);
   EXPECT_EQ(ASCIIToUTF16("key1_"), new_keyword);
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
@@ -492,15 +490,14 @@ TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
 
   // Test a third collision. This should collide on both the autogenerated
   // keyword and the first uniquification attempt.
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com"));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com");
   new_keyword = model()->UniquifyKeyword(*turl, false);
   EXPECT_EQ(ASCIIToUTF16("key1__"), new_keyword);
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 
   // If we force the method, it should uniquify the keyword even if it is
   // currently unique, and skip the host-based autogenerated keyword.
-  turl.reset(
-      CreateTestTemplateURL(ASCIIToUTF16("unique"), "http://unique.com"));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("unique"), "http://unique.com");
   new_keyword = model()->UniquifyKeyword(*turl, true);
   EXPECT_EQ(ASCIIToUTF16("unique_"), new_keyword);
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
@@ -524,10 +521,11 @@ TEST_F(TemplateURLServiceSyncTest, IsLocalTemplateURLBetter) {
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    TemplateURL* local_turl = CreateTestTemplateURL(
+    std::unique_ptr<TemplateURL> local_turl_ptr = CreateTestTemplateURL(

[Peter Kasting, 2016/08/31 04:12:55]

Nit: It's not a big deal, but in places like this, I'd have expected the "_ptr"
to go on the other variable:

  std::unique_ptr<TemplateURL> local_turl = ...;
  TemplateURL* local_turl_ptr = local_turl.get();

An argument could be made for each direction, I suppose.

[Avi (use Gerrit), 2016/09/01 00:34:26]

Fixed.

         ASCIIToUTF16("localkey"), "www.local.com", "localguid",
         test_cases[i].local_time, true, test_cases[i].local_created_by_policy);
-    model()->Add(local_turl);
+    TemplateURL* local_turl = local_turl_ptr.get();
+    model()->Add(std::move(local_turl_ptr));
     if (test_cases[i].local_is_default)
       model()->SetUserSelectedDefaultSearchProvider(local_turl);
 
@@ -551,9 +549,10 @@ TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
   // Create a keyword that conflicts, and make it older.  Sync keyword is
   // uniquified, and a syncer::SyncChange is added.
   base::string16 original_turl_keyword = ASCIIToUTF16("key1");
-  TemplateURL* original_turl = CreateTestTemplateURL(original_turl_keyword,
-      "http://key1.com", std::string(), 9000);
-  model()->Add(original_turl);
+  std::unique_ptr<TemplateURL> original_turl_ptr = CreateTestTemplateURL(
+      original_turl_keyword, "http://key1.com", std::string(), 9000);
+  TemplateURL* original_turl = original_turl_ptr.get();
+  model()->Add(std::move(original_turl_ptr));
   std::unique_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(
       original_turl_keyword, "http://new.com", "remote", 8999));
   syncer::SyncChangeList changes;
@@ -571,12 +570,13 @@ TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
   // the local GUID doesn't appear in the sync GUID list).  Also ensure that
   // this does not change the safe_for_autoreplace flag or the TemplateURLID in
   // the original.
-  original_turl = CreateTestTemplateURL(original_turl_keyword,
-                                        "http://key1.com", "local", 9000);
-  model()->Add(original_turl);
+  original_turl_ptr = CreateTestTemplateURL(original_turl_keyword,
+                                            "http://key1.com", "local", 9000);
+  original_turl = original_turl_ptr.get();
+  model()->Add(std::move(original_turl_ptr));
   TemplateURLID original_id = original_turl->id();
-  sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
-                                        std::string(), 9001));
+  sync_turl = CreateTestTemplateURL(original_turl_keyword, "http://new.com",
+                                    std::string(), 9001);
   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_NE(original_turl_keyword, original_turl->keyword());
@@ -591,11 +591,12 @@ TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
 
   // Equal times. Same result as above. Sync left alone, original uniquified so
   // sync_turl can fit.
-  original_turl = CreateTestTemplateURL(original_turl_keyword,
-                                        "http://key1.com", "local2", 9000);
-  model()->Add(original_turl);
-  sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
-                                        std::string(), 9000));
+  original_turl_ptr = CreateTestTemplateURL(original_turl_keyword,
+                                            "http://key1.com", "local2", 9000);
+  original_turl = original_turl_ptr.get();
+  model()->Add(std::move(original_turl_ptr));
+  sync_turl = CreateTestTemplateURL(original_turl_keyword, "http://new.com",
+                                    std::string(), 9000);
   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_NE(original_turl_keyword, original_turl->keyword());
@@ -608,11 +609,13 @@ TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
 
   // Sync is newer, but original TemplateURL is created by policy, so it wins.
   // Sync keyword is uniquified, and a syncer::SyncChange is added.
-  original_turl = CreateTestTemplateURL(original_turl_keyword,
-      "http://key1.com", std::string(), 9000, false, true);
-  model()->Add(original_turl);
-  sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
-                                        "remote2", 9999));
+  original_turl_ptr =
+      CreateTestTemplateURL(original_turl_keyword, "http://key1.com",
+                            std::string(), 9000, false, true);
+  original_turl = original_turl_ptr.get();
+  model()->Add(std::move(original_turl_ptr));
+  sync_turl = CreateTestTemplateURL(original_turl_keyword, "http://new.com",
+                                    "remote2", 9999);
   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
@@ -710,8 +713,7 @@ TEST_F(TemplateURLServiceSyncTest, MergeSyncIsTheSame) {
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
-    std::unique_ptr<TemplateURL> converted(Deserialize(*iter));
-    model()->Add(converted.release());
+    model()->Add(Deserialize(*iter));
   }
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
@@ -738,20 +740,21 @@ TEST_F(TemplateURLServiceSyncTest, MergeUpdateFromSync) {
   // The local data is the same as the sync data merged in, but timestamps have
   // changed. Ensure the right fields are merged in.
   syncer::SyncDataList initial_data;
-  TemplateURL* turl1 = CreateTestTemplateURL(ASCIIToUTF16("abc.com"),
-                                             "http://abc.com", "abc", 9000);
-  model()->Add(turl1);
-  TemplateURL* turl2 = CreateTestTemplateURL(ASCIIToUTF16("xyz.com"),
-                                             "http://xyz.com", "xyz", 9000);
-  model()->Add(turl2);
-
-  std::unique_ptr<TemplateURL> turl1_newer(CreateTestTemplateURL(
-      ASCIIToUTF16("abc.com"), "http://abc.ca", "abc", 9999));
+  std::unique_ptr<TemplateURL> turl1_ptr = CreateTestTemplateURL(
+      ASCIIToUTF16("abc.com"), "http://abc.com", "abc", 9000);
+  TemplateURL* turl1 = turl1_ptr.get();
+  model()->Add(std::move(turl1_ptr));
+  std::unique_ptr<TemplateURL> turl2_ptr = CreateTestTemplateURL(
+      ASCIIToUTF16("xyz.com"), "http://xyz.com", "xyz", 9000);
+  model()->Add(std::move(turl2_ptr));

[Peter Kasting, 2016/08/31 04:12:55]

Nit: Can just call Add() on the result of CreateTestTemplateURL directly and
omit the move() (as you have done below).

The argument against this is that without naming this "turl2", the meaning of
the subsequent "turl2_older" variable is unclear, but I think it's still
sufficiently clear.

[Avi (use Gerrit), 2016/09/01 00:34:26]

Done.

+
+  std::unique_ptr<TemplateURL> turl1_newer = CreateTestTemplateURL(
+      ASCIIToUTF16("abc.com"), "http://abc.ca", "abc", 9999);
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl1_newer));
 
-  std::unique_ptr<TemplateURL> turl2_older(CreateTestTemplateURL(
-      ASCIIToUTF16("xyz.com"), "http://xyz.ca", "xyz", 8888));
+  std::unique_ptr<TemplateURL> turl2_older = CreateTestTemplateURL(
+      ASCIIToUTF16("xyz.com"), "http://xyz.ca", "xyz", 8888);
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl2_older));
 
@@ -1066,9 +1069,8 @@ TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
                                     CreateAndPassSyncErrorFactory());
 
   // Add a new search engine.
-  TemplateURL* new_turl =
-      CreateTestTemplateURL(ASCIIToUTF16("baidu"), "http://baidu.cn", "new");
-  model()->Add(new_turl);
+  model()->Add(
+      CreateTestTemplateURL(ASCIIToUTF16("baidu"), "http://baidu.cn", "new"));
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("new"));
   syncer::SyncChange change = processor()->change_for_guid("new");
@@ -1141,12 +1143,12 @@ TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithLocalExtensions) {
 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordMigrated) {
   // Create a couple of sync entries with autogenerated keywords.
   syncer::SyncDataList initial_data;
-  std::unique_ptr<TemplateURL> turl(
-      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
+  std::unique_ptr<TemplateURL> turl =
+      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1");
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
-      "{google:baseURL}search?q={searchTerms}", "key2"));
+  turl = CreateTestTemplateURL(
+      ASCIIToUTF16("key2"), "{google:baseURL}search?q={searchTerms}", "key2");
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid(), 99));
 
@@ -1183,21 +1185,24 @@ TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordConflicts) {
       model()->search_terms_data().GoogleBaseURLValue())));
   const std::string local_google_url =
       "{google:baseURL}1/search?q={searchTerms}";
-  TemplateURL* google = CreateTestTemplateURL(google_keyword, local_google_url);
-  model()->Add(google);
-  TemplateURL* other =
+  std::unique_ptr<TemplateURL> google_ptr =
+      CreateTestTemplateURL(google_keyword, local_google_url);
+  TemplateURL* google = google_ptr.get();
+  model()->Add(std::move(google_ptr));
+  std::unique_ptr<TemplateURL> other_ptr =
       CreateTestTemplateURL(ASCIIToUTF16("other.com"), "http://other.com/foo");
-  model()->Add(other);
+  TemplateURL* other = other_ptr.get();
+  model()->Add(std::move(other_ptr));
   syncer::SyncDataList initial_data;
-  std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
+  std::unique_ptr<TemplateURL> turl = CreateTestTemplateURL(
       ASCIIToUTF16("sync1"), "{google:baseURL}2/search?q={searchTerms}",
-      "sync1", 50));
+      "sync1", 50);
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   const std::string synced_other_url =
       "http://other.com/search?q={searchTerms}";
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("sync2"),
-      synced_other_url, "sync2", 150));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("sync2"), synced_other_url, "sync2",
+                               150);
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
 
@@ -1241,13 +1246,13 @@ TEST_F(TemplateURLServiceSyncTest, TwoAutogeneratedKeywordsUsingGoogleBaseURL) {
   // We make the first older so that it will get renamed once before the second
   // and then again once after (when we resolve conflicts for the second).
   syncer::SyncDataList initial_data;
-  std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
+  std::unique_ptr<TemplateURL> turl = CreateTestTemplateURL(
       ASCIIToUTF16("key1"), "{google:baseURL}1/search?q={searchTerms}", "key1",
-      50));
+      50);
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
-      "{google:baseURL}2/search?q={searchTerms}", "key2"));
+  turl = CreateTestTemplateURL(
+      ASCIIToUTF16("key2"), "{google:baseURL}2/search?q={searchTerms}", "key2");
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
@@ -1535,8 +1540,8 @@ TEST_F(TemplateURLServiceSyncTest, SyncedDefaultGUIDArrivesFirst) {
 TEST_F(TemplateURLServiceSyncTest, DefaultGuidDeletedBeforeNewDSPArrives) {
   syncer::SyncDataList initial_data;
   // The default search provider should support replacement.
-  std::unique_ptr<TemplateURL> turl1(CreateTestTemplateURL(
-      ASCIIToUTF16("key1"), "http://key1.com/{searchTerms}", "key1", 90));
+  std::unique_ptr<TemplateURL> turl1 = CreateTestTemplateURL(
+      ASCIIToUTF16("key1"), "http://key1.com/{searchTerms}", "key1", 90);
   // Create a second default search provider for the
   // FindNewDefaultSearchProvider method to find.
   TemplateURLData data;
@@ -1583,7 +1588,7 @@ TEST_F(TemplateURLServiceSyncTest, DefaultGuidDeletedBeforeNewDSPArrives) {
   // arrives, it can still be set as the default.
   syncer::SyncChangeList changes1;
   changes1.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_DELETE,
-                                          turl1.release()));
+                                          std::move(turl1)));
   model()->ProcessSyncChanges(FROM_HERE, changes1);
 
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1_")));
@@ -1736,9 +1741,11 @@ TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
 TEST_F(TemplateURLServiceSyncTest, SyncMergeDeletesDefault) {
   // If the value from Sync is a duplicate of the local default and is newer, it
   // should safely replace the local value and set as the new default.
-  TemplateURL* default_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
-      "http://key1.com/{searchTerms}", "whateverguid", 10);
-  model()->Add(default_turl);
+  std::unique_ptr<TemplateURL> default_turl_ptr = CreateTestTemplateURL(
+      ASCIIToUTF16("key1"), "http://key1.com/{searchTerms}", "whateverguid",
+      10);
+  TemplateURL* default_turl = default_turl_ptr.get();
+  model()->Add(std::move(default_turl_ptr));
   model()->SetUserSelectedDefaultSearchProvider(default_turl);
 
   syncer::SyncDataList initial_data = CreateInitialSyncData();
@@ -1760,18 +1767,17 @@ TEST_F(TemplateURLServiceSyncTest, LocalDefaultWinsConflict) {
   // We expect that the local default always wins keyword conflict resolution.
   const base::string16 keyword(ASCIIToUTF16("key1"));
   const std::string url("http://whatever.com/{searchTerms}");
-  TemplateURL* default_turl = CreateTestTemplateURL(keyword,
-                                                    url,
-                                                    "whateverguid",
-                                                    10);
-  model()->Add(default_turl);
+  std::unique_ptr<TemplateURL> default_turl_ptr =
+      CreateTestTemplateURL(keyword, url, "whateverguid", 10);
+  TemplateURL* default_turl = default_turl_ptr.get();
+  model()->Add(std::move(default_turl_ptr));
   model()->SetUserSelectedDefaultSearchProvider(default_turl);
 
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The key1 entry should be different from the default but conflict in the
   // keyword.
-  std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
-      keyword, "http://key1.com/{searchTerms}", "key1", 90));
+  std::unique_ptr<TemplateURL> turl = CreateTestTemplateURL(
+      keyword, "http://key1.com/{searchTerms}", "key1", 90);
   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
@@ -1800,11 +1806,11 @@ TEST_F(TemplateURLServiceSyncTest, LocalDefaultWinsConflict) {
 TEST_F(TemplateURLServiceSyncTest, DeleteBogusData) {
   // Create a couple of bogus entries to sync.
   syncer::SyncDataList initial_data;
-  std::unique_ptr<TemplateURL> turl(
-      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
+  std::unique_ptr<TemplateURL> turl =
+      CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1");
   initial_data.push_back(
       CreateCustomSyncData(*turl, false, std::string(), turl->sync_guid()));
-  turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
+  turl = CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com");
   initial_data.push_back(
       CreateCustomSyncData(*turl, false, turl->url(), std::string()));
 
@@ -1877,7 +1883,7 @@ TEST_F(TemplateURLServiceSyncTest, PreSyncUpdates) {
   data_copy.SetKeyword(ASCIIToUTF16(kNewKeyword));
   // Set safe_for_autoreplace to false so our keyword survives.
   data_copy.safe_for_autoreplace = false;
-  model()->Add(new TemplateURL(data_copy));
+  model()->Add(base::MakeUnique<TemplateURL>(data_copy));
 
   // Merge the prepopulate search engines.
   base::Time pre_merge_time = base::Time::Now();
@@ -2041,9 +2047,10 @@ TEST_F(TemplateURLServiceSyncTest, MergeInSyncTemplateURL) {
     base::string16 expected_sync_keyword = sync_keyword;
 
     // Create the data and run the actual test.
-    TemplateURL* local_turl = CreateTestTemplateURL(
+    std::unique_ptr<TemplateURL> local_turl_ptr = CreateTestTemplateURL(
         local_keyword, local_url, local_guid, local_last_modified);
-    model()->Add(local_turl);
+    TemplateURL* local_turl = local_turl_ptr.get();
+    model()->Add(std::move(local_turl_ptr));
     std::unique_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(
         sync_keyword, sync_url, sync_guid, sync_last_modified));
 
@@ -2130,8 +2137,8 @@ TEST_F(TemplateURLServiceSyncTest, MergePrepopulatedEngine) {
   // Merge with an initial list containing a prepopulated engine with a wrong
   // URL.
   syncer::SyncDataList list;
-  std::unique_ptr<TemplateURL> sync_turl(CopyTemplateURL(
-      default_turl.get(), "http://wrong.url.com?q={searchTerms}", "default"));
+  std::unique_ptr<TemplateURL> sync_turl = CopyTemplateURL(
+      default_turl.get(), "http://wrong.url.com?q={searchTerms}", "default");
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
@@ -2151,13 +2158,13 @@ TEST_F(TemplateURLServiceSyncTest, AddPrepopulatedEngine) {
 
   std::unique_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
-  TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
-      "http://wrong.url.com?q={searchTerms}", "default");
+  std::unique_ptr<TemplateURL> sync_turl = CopyTemplateURL(
+      default_turl.get(), "http://wrong.url.com?q={searchTerms}", "default");
 
   // Add a prepopulated engine with a wrong URL.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
-                                         sync_turl));
+                                         std::move(sync_turl)));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
@@ -2174,20 +2181,21 @@ TEST_F(TemplateURLServiceSyncTest, UpdatePrepopulatedEngine) {
   TemplateURLData data = *default_turl;
   data.SetURL("http://old.wrong.url.com?q={searchTerms}");
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(data));
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
-  TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
-      "http://new.wrong.url.com?q={searchTerms}", "default");
+  std::unique_ptr<TemplateURL> sync_turl =
+      CopyTemplateURL(default_turl.get(),
+                      "http://new.wrong.url.com?q={searchTerms}", "default");
 
   // Update the engine in the model, which is prepopulated, with a new one.
   // Both have wrong URLs, but it should still get corrected.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
-                                         sync_turl));
+                                         std::move(sync_turl)));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
@@ -2209,7 +2217,7 @@ TEST_F(TemplateURLServiceSyncTest, MergeEditedPrepopulatedEngine) {
   data.date_created = Time::FromTimeT(50);
   data.last_modified = Time::FromTimeT(50);
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(data));
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
@@ -2240,7 +2248,7 @@ TEST_F(TemplateURLServiceSyncTest, MergeConflictingPrepopulatedEngine) {
   data.last_modified = Time::FromTimeT(50);
   data.prepopulate_id = 1;
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(data));
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   TemplateURLData new_data(*default_turl);
   new_data.SetKeyword(ASCIIToUTF16("new_kw"));
@@ -2277,7 +2285,7 @@ TEST_F(TemplateURLServiceSyncTest, MergeConflictingPrepopulatedEngine) {
   // Now test that a remote TemplateURL can override the attributes of the local
   // default search provider.
   TemplateURL* existing_default = new TemplateURL(data);
-  model()->Add(existing_default);
+  model()->Add(base::WrapUnique(existing_default));
   model()->SetUserSelectedDefaultSearchProvider(existing_default);
 
   merge_result = model()->MergeDataAndStartSyncing(
@@ -2303,7 +2311,7 @@ TEST_F(TemplateURLServiceSyncTest, MergeNonEditedPrepopulatedEngine) {
   data.date_created = Time::FromTimeT(50);
   data.last_modified = Time::FromTimeT(50);
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(data));
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);