Remove use of stl_util in search_engines.

chrome/browser/search_engines/template_url_service_sync_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 188 matching lines @@
   // involve syncing two models.
   TemplateURLService* model_a() { return test_util_a_->model(); }
   TemplateURLService* model_b() { return test_util_b_->model(); }
   TestingProfile* profile_a() { return test_util_a_->profile(); }
   TestChangeProcessor* processor() { return sync_processor_.get(); }
   std::unique_ptr<syncer::SyncChangeProcessor> PassProcessor();
   std::unique_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 
   // 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.
   void AssertEquals(const TemplateURL& expected,
                     const TemplateURL& actual) const;
 
   // Expect that two syncer::SyncDataLists have equal contents, in terms of the
   // sync_guid, keyword, and url fields.
   void AssertEquals(const syncer::SyncDataList& data1,
                     const syncer::SyncDataList& data2) const;
 
   // 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
   // slightly older than CreateTestTemplateURL's default, to test conflict
   // resolution.
   syncer::SyncDataList CreateInitialSyncData() const;
 
   // Syntactic sugar.
   std::unique_ptr<TemplateURL> Deserialize(const syncer::SyncData& sync_data);
 
   // 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_;
   // We keep two TemplateURLServices to test syncing between them.
   std::unique_ptr<TemplateURLServiceTestUtil> test_util_a_;
   std::unique_ptr<TemplateURLServiceTestUtil> test_util_b_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
   std::unique_ptr<TestChangeProcessor> sync_processor_;
   std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
@@ skipping 28 matching lines @@
 TemplateURLServiceSyncTest::PassProcessor() {
   return std::move(sync_processor_wrapper_);
 }
 
 std::unique_ptr<syncer::SyncErrorFactory>
 TemplateURLServiceSyncTest::CreateAndPassSyncErrorFactory() {
   return std::unique_ptr<syncer::SyncErrorFactory>(
       new syncer::SyncErrorFactoryMock());
 }
 
-TemplateURL* TemplateURLServiceSyncTest::CreateTestTemplateURL(
+std::unique_ptr<TemplateURL> TemplateURLServiceSyncTest::CreateTestTemplateURL(
     const base::string16& keyword,
     const std::string& url,
     const std::string& guid,
     time_t last_mod,
     bool safe_for_autoreplace,
     bool created_by_policy,
     int prepopulate_id) const {
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("unittest"));
   data.SetKeyword(keyword);
   data.SetURL(url);
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(last_mod);
   data.created_by_policy = created_by_policy;
   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,
                                               const TemplateURL& actual) const {
   ASSERT_EQ(expected.short_name(), actual.short_name());
   ASSERT_EQ(expected.keyword(), actual.keyword());
   ASSERT_EQ(expected.url(), actual.url());
   ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url());
   ASSERT_EQ(expected.favicon_url(), actual.favicon_url());
   ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
@@ skipping 16 matching lines @@
       ASSERT_EQ(GetKeyword(iter1->second), GetKeyword(iter2->second));
       ASSERT_EQ(GetURL(iter1->second), GetURL(iter2->second));
       map2.erase(iter2);
     }
   }
   EXPECT_EQ(0U, map2.size());
 }
 
 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;
 }
 
 std::unique_ptr<TemplateURL> TemplateURLServiceSyncTest::Deserialize(
     const syncer::SyncData& sync_data) {
   syncer::SyncChangeList dummy;
   TestTemplateURLServiceClient client;
   return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
       &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) {
   TemplateURLData data = *turl;
   data.SetURL(url);
   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 ---------------------------------------------------------------
 
 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
   // Create a TemplateURL and convert it into a sync specific type.
   std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
       ASCIIToUTF16("unittest"), "http://www.unittest.com/"));
   syncer::SyncData sync_data =
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
@@ skipping 38 matching lines @@
     std::string guid = GetGUID(*iter);
     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     std::unique_ptr<TemplateURL> deserialized(Deserialize(*iter));
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 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);
 
   EXPECT_EQ(2U, all_sync_data.size());
 
   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
       iter != all_sync_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     std::unique_ptr<TemplateURL> deserialized(Deserialize(*iter));
     ASSERT_FALSE(service_turl->created_by_policy());
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 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));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("new.com"), "http://new.com",
                                      "xyz"));
 
   // 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));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1_"), "http://new.com"));
 
   // 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));
 }
 
 TEST_F(TemplateURLServiceSyncTest, IsLocalTemplateURLBetter) {
   // Test some edge cases of this function.
   const struct {
     time_t local_time;
     time_t sync_time;
     bool local_is_default;
     bool local_created_by_policy;
     bool expected_result;
   } test_cases[] = {
     // Sync is better by timestamp but local is Default.
     {10, 100, true, false, true},
     // Sync is better by timestamp but local is Create by Policy.
     {10, 100, false, true, true},
     // Tie. Sync wins.
     {100, 100, false, false, false},
   };
 
   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);
 
     std::unique_ptr<TemplateURL> sync_turl(
         CreateTestTemplateURL(ASCIIToUTF16("synckey"), "www.sync.com",
                               "syncguid", test_cases[i].sync_time));
     EXPECT_EQ(test_cases[i].expected_result,
               model()->IsLocalTemplateURLBetter(local_turl, sync_turl.get()));
 
     // Undo the changes.
     if (test_cases[i].local_is_default)
       model()->SetUserSelectedDefaultSearchProvider(NULL);
     model()->Remove(local_turl);
   }
 }
 
 TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
   // This tests cases where neither the sync nor the local TemplateURL are
   // marked safe_for_autoreplace.
 
   // 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;
   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote", GetGUID(changes[0].sync_data()));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Sync is newer.  Original TemplateURL keyword is uniquified.  A SyncChange
   // is added (which in a normal run would be deleted by PruneSyncChanges() when
   // 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());
   EXPECT_FALSE(original_turl->safe_for_autoreplace());
   EXPECT_EQ(original_id, original_turl->id());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local", GetGUID(changes[0].sync_data()));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // 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());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local2", GetGUID(changes[0].sync_data()));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // 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());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote2", GetGUID(changes[0].sync_data()));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 }
@@ skipping 77 matching lines @@
   EXPECT_EQ(6, merge_result.num_items_after_association());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeSyncIsTheSame) {
   // The local data is the same as the sync data merged in. i.e. - There have
   // been no changes since the last time we synced. Even the last_modified
   // timestamps are the same.
   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(
       syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // Locally everything should remain the same.
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(3, merge_result.num_items_before_association());
   EXPECT_EQ(3, merge_result.num_items_after_association());
 }
 
 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_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));
+  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));
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Both were local updates, so we expect the same count.
   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 
@@ skipping 294 matching lines @@
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
   // Ensure that ProcessTemplateURLChange is called and pushes the correct
   // changes to Sync whenever local changes are made to TemplateURLs.
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     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");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
   EXPECT_EQ("baidu", GetKeyword(change.sync_data()));
   EXPECT_EQ("http://baidu.cn", GetURL(change.sync_data()));
 
   // Change a keyword.
   TemplateURL* existing_turl = model()->GetTemplateURLForGUID("key1");
   model()->ResetTemplateURL(existing_turl, existing_turl->short_name(),
@@ skipping 52 matching lines @@
 
   EXPECT_EQ(extension1,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
   EXPECT_EQ(model()->GetTemplateURLForHost("bbb.com"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2")));
 }
 
 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));
 
   // Now try to sync the data locally.
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Both entries should have been added, with explicit keywords.
   TemplateURL* key1 = model()->GetTemplateURLForHost("key1.com");
   ASSERT_FALSE(key1 == NULL);
@@ skipping 16 matching lines @@
   EXPECT_EQ(google_keyword, UTF8ToUTF16(GetKeyword(key2_change.sync_data())));
 }
 
 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordConflicts) {
   // Sync brings in some autogenerated keywords, but the generated keywords we
   // try to create conflict with ones in the model.
   base::string16 google_keyword(url_formatter::StripWWWFromHost(GURL(
       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()));
 
   // Before we merge the data, grab the local sync_guids so we can ensure that
   // they've been replaced.
   const std::string local_google_guid = google->sync_guid();
   const std::string local_other_guid = other->sync_guid();
 
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
@@ skipping 23 matching lines @@
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, sync2_change.change_type());
   EXPECT_EQ("other.com", GetKeyword(sync2_change.sync_data()));
   EXPECT_EQ(synced_other_url, GetURL(sync2_change.sync_data()));
 }
 
 TEST_F(TemplateURLServiceSyncTest, TwoAutogeneratedKeywordsUsingGoogleBaseURL) {
   // Sync brings in two autogenerated keywords and both use Google base URLs.
   // 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,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // We should still have coalesced the updates to one each.
   base::string16 google_keyword(url_formatter::StripWWWFromHost(GURL(
       model()->search_terms_data().GoogleBaseURLValue())));
   TemplateURL* keyword1 =
       model()->GetTemplateURLForKeyword(google_keyword + ASCIIToUTF16("_"));
@@ skipping 267 matching lines @@
   model()->ProcessSyncChanges(FROM_HERE, changes2);
 
   EXPECT_EQ(5U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   ASSERT_NE(default_search, model()->GetDefaultSearchProvider());
   ASSERT_EQ("newdefault", model()->GetDefaultSearchProvider()->sync_guid());
 }
 
 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;
   data.SetShortName(ASCIIToUTF16("unittest"));
   data.SetKeyword(ASCIIToUTF16("key2"));
   data.SetURL("http://key2.com/{searchTerms}");
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = false;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
@@ skipping 26 matching lines @@
       prefs::kSyncedDefaultSearchProviderGUID));
 
   // Simulate a situation where an ACTION_DELETE on the default arrives before
   // the new default search provider entry. This should fail to delete the
   // target entry, and instead send up an "undelete" to the server, after
   // further uniquifying the keyword to avoid infinite sync loops. The synced
   // default GUID should not be changed so that when the expected default entry
   // 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_")));
   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   EXPECT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
   syncer::SyncChange undelete = processor()->change_for_guid("key1");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, undelete.change_type());
   EXPECT_EQ("key1_",
@@ skipping 132 matching lines @@
   const TemplateURL* expected_default =
       model()->GetTemplateURLForGUID("newdefault");
   test_util_a_->RemoveManagedDefaultSearchPreferences();
 
   EXPECT_EQ(expected_default, model()->GetDefaultSearchProvider());
 }
 
 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();
   // The key1 entry should be a duplicate of the default.
   std::unique_ptr<TemplateURL> turl(CreateTestTemplateURL(
       ASCIIToUTF16("key1"), "http://key1.com/{searchTerms}", "key1", 90));
   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("whateverguid"));
   EXPECT_EQ(model()->GetDefaultSearchProvider(),
             model()->GetTemplateURLForGUID("key1"));
 }
 
 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,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Since the local default was not yet synced, it should be merged with the
   // conflicting TemplateURL. However, its values should have been preserved
   // since it would have won conflict resolution due to being the default.
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   const TemplateURL* winner = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(winner);
   EXPECT_EQ(model()->GetDefaultSearchProvider(), winner);
   EXPECT_EQ(keyword, winner->keyword());
   EXPECT_EQ(url, winner->url());
   ASSERT_TRUE(processor()->contains_guid("key1"));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             processor()->change_for_guid("key1").change_type());
   EXPECT_EQ(url, GetURL(processor()->change_for_guid("key1").sync_data()));
 
   // There is no loser, as the two were merged together. The local sync_guid
   // should no longer be found in the model.
   const TemplateURL* loser = model()->GetTemplateURLForGUID("whateverguid");
   ASSERT_FALSE(loser);
 }
 
 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()));
 
   // Now try to sync the data locally.
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Nothing should have been added, and both bogus entries should be marked for
   // deletion.
   EXPECT_EQ(0U, model()->GetTemplateURLs().size());
@@ skipping 52 matching lines @@
   ASSERT_FALSE(prepop_turls.empty());
 
   // Create a copy of the first TemplateURL with a really old timestamp and a
   // new keyword. Add it to the model.
   TemplateURLData data_copy(*prepop_turls[0]);
   data_copy.last_modified = Time::FromTimeT(10);
   base::string16 original_keyword = data_copy.keyword();
   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();
   base::RunLoop().RunUntilIdle();
   test_util_a_->ResetModel(true);
 
   // The newly added search engine should have been safely merged, with an
   // updated time.
   TemplateURL* added_turl = model()->GetTemplateURLForKeyword(
       ASCIIToUTF16(kNewKeyword));
@@ skipping 143 matching lines @@
     const time_t sync_last_modified =
         test_cases[i].conflict_winner == SYNC ? 110 : 90;
     const std::string local_guid = "local_guid";
     const std::string sync_guid = "sync_guid";
 
     // Initialize expectations.
     base::string16 expected_local_keyword = local_keyword;
     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));
 
     SyncDataMap sync_data;
     if (test_cases[i].synced_at_start == SYNC ||
         test_cases[i].synced_at_start == BOTH) {
       sync_data[sync_turl->sync_guid()] =
           TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl);
     }
     if (test_cases[i].synced_at_start == BOTH) {
@@ skipping 66 matching lines @@
   }  // for
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergePrepopulatedEngine) {
   std::unique_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   // 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(),
       CreateAndPassSyncErrorFactory());
 
   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
   EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, AddPrepopulatedEngine) {
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   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");
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
   EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, UpdatePrepopulatedEngine) {
   std::unique_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   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");
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
   EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeEditedPrepopulatedEngine) {
   std::unique_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   TemplateURLData data(*default_turl);
   data.safe_for_autoreplace = false;
   data.SetKeyword(ASCIIToUTF16("new_kw"));
   data.SetShortName(ASCIIToUTF16("my name"));
   data.SetURL("http://wrong.url.com?q={searchTerms}");
   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);
   std::unique_ptr<TemplateURL> sync_turl(new TemplateURL(data));
   syncer::SyncDataList list;
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
@@ skipping 10 matching lines @@
 
   TemplateURLData data(*default_turl);
   data.SetKeyword(ASCIIToUTF16("old_kw"));
   data.SetShortName(ASCIIToUTF16("my name"));
   data.SetURL("http://wrong.url.com?q={searchTerms}");
   data.safe_for_autoreplace = true;
   data.date_created = Time::FromTimeT(50);
   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"));
   new_data.SetShortName(ASCIIToUTF16("my name"));
   new_data.SetURL("http://wrong.url.com?q={searchTerms}");
   new_data.safe_for_autoreplace = false;
   new_data.date_created = Time::FromTimeT(100);
   new_data.last_modified = Time::FromTimeT(100);
   new_data.prepopulate_id = 1;
   new_data.sync_guid = "different_guid";
@@ skipping 16 matching lines @@
 
   // Reset the state of the service.
   model()->Remove(result_turl);
   model()->StopSyncing(syncer::SEARCH_ENGINES);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
 
   // 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(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   result_turl = model()->GetDefaultSearchProvider();
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(ASCIIToUTF16("new_kw"), result_turl->keyword());
   EXPECT_EQ(ASCIIToUTF16("my name"), result_turl->short_name());
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeNonEditedPrepopulatedEngine) {
   std::unique_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   TemplateURLData data(*default_turl);
   data.safe_for_autoreplace = true;  // Can be replaced with built-in values.
   data.SetKeyword(ASCIIToUTF16("new_kw"));
   data.SetShortName(ASCIIToUTF16("my name"));
   data.SetURL("http://wrong.url.com?q={searchTerms}");
   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);
   std::unique_ptr<TemplateURL> sync_turl(new TemplateURL(data));
   syncer::SyncDataList list;
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
@@ skipping 28 matching lines @@
 
 TEST_F(TemplateURLServiceSyncTest, NonAsciiKeywordDoesNotCrash) {
   model()->Add(CreateTestTemplateURL(UTF8ToUTF16("\xf0\xaf\xa6\x8d"),
                                      "http://key1.com"));
   syncer::SyncDataList initial_data = CreateInitialSyncData();
 
   model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, initial_data, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 }