Remove use of stl_util in search_engines.

chrome/browser/search_engines/template_url_service_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 "components/search_engines/template_url_service.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/history_service_factory.h"
@@ skipping 27 matching lines @@
       this->row = row;
       this->visits = visits;
     }
   }
 
   bool success;
   history::URLRow row;
   history::VisitVector visits;
 };
 
-TemplateURL* CreateKeywordWithDate(
+std::unique_ptr<TemplateURL> CreateKeywordWithDate(
     TemplateURLService* model,
     const std::string& short_name,
     const std::string& keyword,
     const std::string& url,
     const std::string& suggest_url,
     const std::string& alternate_url,
     const std::string& favicon_url,
     bool safe_for_autoreplace,
     bool show_in_default_list,
     const std::string& encodings,
     Time date_created,
     Time last_modified) {
   TemplateURLData data;
   data.SetShortName(base::UTF8ToUTF16(short_name));
   data.SetKeyword(base::UTF8ToUTF16(keyword));
   data.SetURL(url);
   data.suggestions_url = suggest_url;
   if (!alternate_url.empty())
     data.alternate_urls.push_back(alternate_url);
   data.favicon_url = GURL(favicon_url);
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.show_in_default_list = show_in_default_list;
   data.input_encodings = base::SplitString(
       encodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   data.date_created = date_created;
   data.last_modified = last_modified;
-  return new TemplateURL(data);
+  return base::MakeUnique<TemplateURL>(data);
 }
 
 TemplateURL* AddKeywordWithDate(
     TemplateURLService* model,
     const std::string& short_name,
     const std::string& keyword,
     const std::string& url,
     const std::string& suggest_url,
     const std::string& alternate_url,
     const std::string& favicon_url,
     bool safe_for_autoreplace,
     const std::string& encodings,
     Time date_created,
     Time last_modified) {
-  TemplateURL* t_url = CreateKeywordWithDate(
-      model, short_name, keyword, url, suggest_url, alternate_url,favicon_url,
-      safe_for_autoreplace, false, encodings, date_created, last_modified);
-  model->Add(t_url);
+  TemplateURL* t_url = model->Add(CreateKeywordWithDate(
+      model, short_name, keyword, url, suggest_url, alternate_url, favicon_url,
+      safe_for_autoreplace, false, encodings, date_created, last_modified));
   EXPECT_NE(0, t_url->id());
   return t_url;
 }
 
 // Checks that the two TemplateURLs are similar. It does not check the id, the
 // date_created or the last_modified time.  Neither pointer should be NULL.
 void ExpectSimilar(const TemplateURL* expected, const TemplateURL* actual) {
   ASSERT_TRUE(expected != NULL);
   ASSERT_TRUE(actual != NULL);
   EXPECT_EQ(expected->short_name(), actual->short_name());
@@ skipping 34 matching lines @@
                                   Time last_modified);
 
   // Verifies the two TemplateURLs are equal.
   void AssertEquals(const TemplateURL& expected, const TemplateURL& actual);
 
   // Verifies the two timestamps are equal, within the expected degree of
   // precision.
   void AssertTimesEqual(const base::Time& expected, const base::Time& actual);
 
   // Create an URL that appears to have been prepopulated, but won't be in the
-  // current data. The caller owns the returned TemplateURL*.
-  TemplateURL* CreatePreloadedTemplateURL(bool safe_for_autoreplace,
-                                          int prepopulate_id);
+  // current data.
+  std::unique_ptr<TemplateURL> CreatePreloadedTemplateURL(
+      bool safe_for_autoreplace,
+      int prepopulate_id);
 
   // Helper methods to make calling TemplateURLServiceTestUtil methods less
   // visually noisy in the test code.
   void VerifyObserverCount(int expected_changed_count);
   void VerifyObserverFired();
   TemplateURLServiceTestUtil* test_util() { return test_util_.get(); }
   TemplateURLService* model() { return test_util_->model(); }
   const SearchTermsData& search_terms_data() {
     return model()->search_terms_data();
   }
@@ skipping 67 matching lines @@
 }
 
 void TemplateURLServiceTest::AssertTimesEqual(const base::Time& expected,
                                               const base::Time& actual) {
   // Because times are stored with a granularity of one second, there is a loss
   // of precision when serializing and deserializing the timestamps. Hence, only
   // expect timestamps to be equal to within one second of one another.
   ASSERT_LT((expected - actual).magnitude(), base::TimeDelta::FromSeconds(1));
 }
 
-TemplateURL* TemplateURLServiceTest::CreatePreloadedTemplateURL(
+std::unique_ptr<TemplateURL> TemplateURLServiceTest::CreatePreloadedTemplateURL(
     bool safe_for_autoreplace,
     int prepopulate_id) {
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("unittest"));
   data.SetKeyword(ASCIIToUTF16("unittest"));
   data.SetURL("http://www.unittest.com/{searchTerms}");
   data.favicon_url = GURL("http://favicon.url");
   data.show_in_default_list = true;
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.input_encodings.push_back("UTF-8");
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.prepopulate_id = prepopulate_id;
-  return new TemplateURL(data);
+  return base::MakeUnique<TemplateURL>(data);
 }
 
 void TemplateURLServiceTest::VerifyObserverCount(int expected_changed_count) {
   EXPECT_EQ(expected_changed_count, test_util_->GetObserverCount());
   test_util_->ResetObserverCount();
 }
 
 void TemplateURLServiceTest::VerifyObserverFired() {
   EXPECT_LE(1, test_util_->GetObserverCount());
   test_util_->ResetObserverCount();
@@ skipping 13 matching lines @@
 
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("google"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = true;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.sync_guid = "00000000-0000-0000-0000-000000000001";
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(base::MakeUnique<TemplateURL>(data));
   ASSERT_TRUE(model()->CanAddAutogeneratedKeyword(ASCIIToUTF16("keyword"),
                                                   GURL(), NULL));
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(t_url->keyword()));
   // We need to make a second copy as the model takes ownership of |t_url| and
   // will delete it.  We have to do this after calling Add() since that gives
   // |t_url| its ID.
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url =
+      base::MakeUnique<TemplateURL>(t_url->data());
 
   // Reload the model to verify it was actually saved to the database.
   test_util()->ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   AssertEquals(*cloned_url, *loaded_url);
   ASSERT_TRUE(model()->CanAddAutogeneratedKeyword(ASCIIToUTF16("keyword"),
                                                   GURL(), NULL));
@@ skipping 43 matching lines @@
       std::string(), true, "UTF-8", Time(), Time());
   VerifyObserverCount(1);
 
   // Test what happens when we try to add a TemplateURL with the same keyword as
   // one in the model.
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("second"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test2");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(base::MakeUnique<TemplateURL>(data));
 
   // Because the old TemplateURL was replaceable and the new one wasn't, the new
   // one should have replaced the old.
   VerifyObserverCount(1);
   EXPECT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url->keyword());
   EXPECT_FALSE(t_url->safe_for_autoreplace());
 
   // Now try adding a replaceable TemplateURL.  This should just delete the
   // passed-in URL.
   data.SetShortName(ASCIIToUTF16("third"));
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
-  model()->Add(new TemplateURL(data));
+  model()->Add(base::MakeUnique<TemplateURL>(data));
   VerifyObserverCount(0);
   EXPECT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url->keyword());
   EXPECT_FALSE(t_url->safe_for_autoreplace());
 
   // Now try adding a non-replaceable TemplateURL again.  This should uniquify
   // the existing entry's keyword.
   data.SetShortName(ASCIIToUTF16("fourth"));
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url2 = new TemplateURL(data);
-  model()->Add(t_url2);
+  TemplateURL* t_url2 = model()->Add(base::MakeUnique<TemplateURL>(data));
   VerifyObserverCount(1);
   EXPECT_EQ(t_url2, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("fourth"), t_url2->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url2->keyword());
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("test2"), t_url->keyword());
 }
 
 TEST_F(TemplateURLServiceTest, AddExtensionKeyword) {
   test_util()->VerifyLoad();
@@ skipping 51 matching lines @@
       "replaceable", "keyword", "http://test1", std::string(),  std::string(),
       std::string(), true, "UTF-8", Time(), Time());
 
   // Adding another replaceable keyword should remove the existing one, but
   // leave the extension as is.
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("name1"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(base::MakeUnique<TemplateURL>(data));
   EXPECT_EQ(extension,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(t_url, model()->GetTemplateURLForHost("test3"));
 
   // Adding a nonreplaceable keyword should remove the existing replaceable
   // keyword and replace the extension as the associated URL for this keyword,
   // but not evict the extension from the service entirely.
   data.SetShortName(ASCIIToUTF16("name2"));
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url2 = new TemplateURL(data);
-  model()->Add(t_url2);
+  TemplateURL* t_url2 = model()->Add(base::MakeUnique<TemplateURL>(data));
   EXPECT_EQ(t_url2,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
 }
 
 TEST_F(TemplateURLServiceTest, NotPersistOmniboxExtensionKeyword) {
   test_util()->VerifyLoad();
 
   // Register an omnibox keyword.
   model()->RegisterOmniboxKeyword("test", "extension", "keyword",
                                   "chrome-extension://test");
@@ skipping 129 matching lines @@
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("google"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.favicon_url = GURL("http://favicon.url");
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(base::MakeUnique<TemplateURL>(data));
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
 
   base::Time now = base::Time::Now();
   std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
   clock->SetNow(now);
   model()->set_clock(std::move(clock));
 
   // Reset the short name, keyword, url and make sure it takes.
   const base::string16 new_short_name(ASCIIToUTF16("a"));
   const base::string16 new_keyword(ASCIIToUTF16("b"));
   const std::string new_url("c");
   model()->ResetTemplateURL(t_url, new_short_name, new_keyword, new_url);
   ASSERT_EQ(new_short_name, t_url->short_name());
   ASSERT_EQ(new_keyword, t_url->keyword());
   ASSERT_EQ(new_url, t_url->url());
 
   // Make sure the mappings in the model were updated.
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(new_keyword));
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")) == NULL);
 
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url(
+      base::MakeUnique<TemplateURL>(t_url->data()));
 
   // Reload the model from the database and make sure the change took.
   test_util()->ResetModel(true);
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* read_url = model()->GetTemplateURLForKeyword(new_keyword);
   ASSERT_TRUE(read_url);
   AssertEquals(*cloned_url, *read_url);
   AssertTimesEqual(now, read_url->last_modified());
 }
 
 TEST_F(TemplateURLServiceTest, DefaultSearchProvider) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURL* t_url = AddKeywordWithDate(
       "name1", "key1", "http://foo1/{searchTerms}", "http://sugg1",
       std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time());
   test_util()->ResetObserverCount();
 
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
   ASSERT_TRUE(t_url->safe_for_autoreplace());
   ASSERT_TRUE(t_url->show_in_default_list());
 
   // Setting the default search provider should have caused notification.
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
 
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url(
+      base::MakeUnique<TemplateURL>(t_url->data()));
 
   // Make sure when we reload we get a default search provider.
   test_util()->ResetModel(true);
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
   AssertEquals(*cloned_url, *model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, CantReplaceWithSameKeyword) {
   test_util()->ChangeModelToLoadState();
@@ skipping 51 matching lines @@
   test_util()->VerifyLoad();
 
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("a"));
   data.safe_for_autoreplace = true;
   data.SetURL("http://url/{searchTerms}");
   data.suggestions_url = "http://url2";
   data.instant_url = "http://instant";
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(base::MakeUnique<TemplateURL>(data));
   const TemplateURLID id = t_url->id();
 
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   base::RunLoop().RunUntilIdle();
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url(
+      base::MakeUnique<TemplateURL>(t_url->data()));
 
   // Reset the model and don't load it. The template url we set as the default
   // should be pulled from prefs now.
   test_util()->ResetModel(false);
 
   // NOTE: This doesn't use AssertEquals as only a subset of the TemplateURLs
   // value are persisted to prefs.
   const TemplateURL* default_turl = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_turl);
   EXPECT_EQ(ASCIIToUTF16("a"), default_turl->short_name());
@@ skipping 255 matching lines @@
   ASSERT_EQ(1U, callback.visits.size());
   EXPECT_TRUE(ui::PageTransitionCoreTypeIs(
       callback.visits[0].transition, ui::PAGE_TRANSITION_KEYWORD_GENERATED));
 }
 
 // Make sure that the load routine deletes prepopulated engines that no longer
 // exist in the prepopulate data.
 TEST_F(TemplateURLServiceTest, LoadDeletesUnusedProvider) {
   // Create a preloaded template url. Add it to a loaded model and wait for the
   // saves to finish.
-  TemplateURL* t_url = CreatePreloadedTemplateURL(true, 999999);
   test_util()->ChangeModelToLoadState();
-  model()->Add(t_url);
+  model()->Add(CreatePreloadedTemplateURL(true, 999999));
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")) != NULL);
   base::RunLoop().RunUntilIdle();
 
   // Ensure that merging clears this engine.
   test_util()->ResetModel(true);
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")) == NULL);
 
   // Wait for any saves to finish.
   base::RunLoop().RunUntilIdle();
 
   // Reload the model to verify that the database was updated as a result of the
   // merge.
   test_util()->ResetModel(true);
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")) == NULL);
 }
 
 // Make sure that load routine doesn't delete prepopulated engines that no
 // longer exist in the prepopulate data if it has been modified by the user.
 TEST_F(TemplateURLServiceTest, LoadRetainsModifiedProvider) {
   // Create a preloaded template url and add it to a loaded model.
-  TemplateURL* t_url = CreatePreloadedTemplateURL(false, 999999);
   test_util()->ChangeModelToLoadState();
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(CreatePreloadedTemplateURL(false, 999999));
 
   // Do the copy after t_url is added so that the id is set.
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url =
+      base::MakeUnique<TemplateURL>(t_url->data());
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")));
 
   // Wait for any saves to finish.
   base::RunLoop().RunUntilIdle();
 
   // Ensure that merging won't clear it if the user has edited it.
   test_util()->ResetModel(true);
   const TemplateURL* url_for_unittest =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
   ASSERT_TRUE(url_for_unittest != NULL);
@@ skipping 30 matching lines @@
   AssertEquals(*cloned_url, *default_search);
 }
 
 // Make sure that the load routine doesn't delete
 // prepopulated engines that no longer exist in the prepopulate data if
 // it is the default search provider.
 TEST_F(TemplateURLServiceTest, LoadRetainsDefaultProvider) {
   // Set the default search provider to a preloaded template url which
   // is not in the current set of preloaded template urls and save
   // the result.
-  TemplateURL* t_url = CreatePreloadedTemplateURL(true, 999999);
   test_util()->ChangeModelToLoadState();
-  model()->Add(t_url);
+  TemplateURL* t_url = model()->Add(CreatePreloadedTemplateURL(true, 999999));
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   // Do the copy after t_url is added and set as default so that its
   // internal state is correct.
-  std::unique_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
+  std::unique_ptr<TemplateURL> cloned_url =
+      base::MakeUnique<TemplateURL>(t_url->data());
 
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")));
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
   base::RunLoop().RunUntilIdle();
 
   // Ensure that merging won't clear the prepopulated template url
   // which is no longer present if it's the default engine.
   test_util()->ResetModel(true);
   {
     const TemplateURL* keyword_url =
@@ skipping 196 matching lines @@
 TEST_F(TemplateURLServiceTest, PatchEmptySyncGUID) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("google"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.sync_guid.clear();
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // Reload the model to verify it was actually saved to the database and
   // assigned a new GUID when brought back.
   test_util()->ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* loaded_url =
@@ skipping 15 matching lines @@
   data.SetURL("http://www.google.com/foo/bar");
   std::vector<std::string> encodings;
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("UTF-16");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("Big5");
   data.input_encodings.push_back("UTF-16");
   data.input_encodings.push_back("Big5");
   data.input_encodings.push_back("Windows-1252");
-  TemplateURL* t_url = new TemplateURL(data);
-  model()->Add(t_url);
+  model()->Add(base::MakeUnique<TemplateURL>(data));
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   EXPECT_EQ(8U, loaded_url->input_encodings().size());
 
   // Reload the model to verify it was actually saved to the database and the
   // duplicate encodings were removed.
   test_util()->ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   loaded_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_FALSE(loaded_url == NULL);
   EXPECT_EQ(4U, loaded_url->input_encodings().size());
 }
 
 TEST_F(TemplateURLServiceTest, DefaultExtensionEngine) {
   test_util()->VerifyLoad();
   // Add third-party default search engine.
   TemplateURL* user_dse = AddKeywordWithDate(
       "user", "user", "http://www.goo.com/s?q={searchTerms}",
       std::string(), std::string(), std::string(),
       true, "UTF-8", Time(), Time());
   model()->SetUserSelectedDefaultSearchProvider(user_dse);
   EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider());
 
-  TemplateURL* ext_dse = CreateKeywordWithDate(
+  std::unique_ptr<TemplateURL> ext_dse_ptr = CreateKeywordWithDate(
       model(), "ext", "ext", "http://www.search.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(),
-      true, true, "UTF-8", Time(), Time());
+      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
+      Time());
+  TemplateURL* ext_dse = ext_dse_ptr.get();
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info(
       new TemplateURL::AssociatedExtensionInfo(
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, "ext"));
   extension_info->wants_to_be_default_engine = true;
-  model()->AddExtensionControlledTURL(ext_dse, std::move(extension_info));
+  model()->AddExtensionControlledTURL(std::move(ext_dse_ptr),

[Peter Kasting, 2016/09/01 08:21:39]

Nit: Does it make sense for this Add() variant to also return a raw pointer?

We may still end up wanting to de-inline the creation of these objects for
readability, I dunno.  But it'd affect at least the four places here and below
that call this function.

[Avi (use Gerrit), 2016/09/01 15:14:46]

Might as well for completeness's sake.

+                                      std::move(extension_info));
   EXPECT_EQ(ext_dse, model()->GetDefaultSearchProvider());
 
   model()->RemoveExtensionControlledTURL(
       "ext", TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
   ExpectSimilar(user_dse, model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, ExtensionEnginesNotPersist) {
   test_util()->VerifyLoad();
   // Add third-party default search engine.
   TemplateURL* user_dse = AddKeywordWithDate(
       "user", "user", "http://www.goo.com/s?q={searchTerms}",
       std::string(), std::string(), std::string(),
       true, "UTF-8", Time(), Time());
   model()->SetUserSelectedDefaultSearchProvider(user_dse);
   EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider());
 
-  TemplateURL* ext_dse = CreateKeywordWithDate(
+  std::unique_ptr<TemplateURL> ext_dse_ptr = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(),
-      true, false, "UTF-8", Time(), Time());
+      std::string(), std::string(), std::string(), true, false, "UTF-8", Time(),
+      Time());
+  TemplateURL* ext_dse = ext_dse_ptr.get();
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info(
       new TemplateURL::AssociatedExtensionInfo(
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, "ext1"));
   extension_info->wants_to_be_default_engine = false;
-  model()->AddExtensionControlledTURL(ext_dse, std::move(extension_info));
+  model()->AddExtensionControlledTURL(std::move(ext_dse_ptr),
+                                      std::move(extension_info));
   EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider());
 
-  ext_dse = CreateKeywordWithDate(
+  ext_dse_ptr = CreateKeywordWithDate(
       model(), "ext2", "ext2", "http://www.ext2.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(),
-      true, true, "UTF-8", Time(), Time());
+      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
+      Time());
+  ext_dse = ext_dse_ptr.get();
   extension_info.reset(new TemplateURL::AssociatedExtensionInfo(
       TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, "ext2"));
   extension_info->wants_to_be_default_engine = true;
-  model()->AddExtensionControlledTURL(ext_dse, std::move(extension_info));
+  model()->AddExtensionControlledTURL(std::move(ext_dse_ptr),
+                                      std::move(extension_info));
   EXPECT_EQ(ext_dse, model()->GetDefaultSearchProvider());
 
   test_util()->ResetModel(true);
   user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user"));
   ExpectSimilar(user_dse, model()->GetDefaultSearchProvider());
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1")));
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext2")));
 }
 
 TEST_F(TemplateURLServiceTest, ExtensionEngineVsPolicy) {
@@ skipping 19 matching lines @@
   data.input_encodings = base::SplitString(
       kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   data.alternate_urls.push_back(kAlternateURL);
   data.search_terms_replacement_key = kSearchTermsReplacementKey;
   std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data));
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
-  TemplateURL* ext_dse = CreateKeywordWithDate(
+  std::unique_ptr<TemplateURL> ext_dse_ptr = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(),
-      true, true, "UTF-8", Time(), Time());
+      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
+      Time());
+  TemplateURL* ext_dse = ext_dse_ptr.get();
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info(
       new TemplateURL::AssociatedExtensionInfo(
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, "ext1"));
   extension_info->wants_to_be_default_engine = true;
-  model()->AddExtensionControlledTURL(ext_dse, std::move(extension_info));
+  model()->AddExtensionControlledTURL(std::move(ext_dse_ptr),
+                                      std::move(extension_info));
   EXPECT_EQ(ext_dse, model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1")));
   EXPECT_TRUE(model()->is_default_search_managed());
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 }