Refactor search_engines tests to better reuse code

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>
@@ skipping 23 matching lines @@
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
+// A prepopulated ID to set for engines we want to show in the default list.
+// This must simply be greater than 0.
+static constexpr int kPrepopulatedId = 999999;
+
 // QueryHistoryCallbackImpl ---------------------------------------------------
 
 struct QueryHistoryCallbackImpl {
   QueryHistoryCallbackImpl() : success(false) {}
 
   void Callback(bool success,
                 const history::URLRow& row,
                 const history::VisitVector& visits) {
     this->success = success;
     if (success) {
@@ skipping 67 matching lines @@
   EXPECT_EQ(expected->url(), actual->url());
   EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url());
   EXPECT_EQ(expected->favicon_url(), actual->favicon_url());
   EXPECT_EQ(expected->alternate_urls(), actual->alternate_urls());
   EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace());
   EXPECT_EQ(expected->input_encodings(), actual->input_encodings());
   EXPECT_EQ(expected->search_terms_replacement_key(),
             actual->search_terms_replacement_key());
 }
 
+std::unique_ptr<TemplateURLData> CreateTestSearchEngine() {
+  auto result = base::MakeUnique<TemplateURLData>();
+  result->SetShortName(ASCIIToUTF16("test1"));
+  result->SetKeyword(ASCIIToUTF16("test.com"));
+  result->SetURL("http://test.com/search?t={searchTerms}");
+  result->favicon_url = GURL("http://test.com/icon.jpg");
+  result->prepopulate_id = kPrepopulatedId;
+  result->input_encodings = {"UTF-16", "UTF-32"};
+  result->alternate_urls = {"http://test.com/search#t={searchTerms}"};
+  result->search_terms_replacement_key = "espv";
+  return result;
+}
+
 }  // namespace
 
 
 // TemplateURLServiceTest -----------------------------------------------------
 
 class TemplateURLServiceTest : public testing::Test {
  public:
   TemplateURLServiceTest();
 
-  // A prepopulated ID to set for engines we want to show in the default list.
-  // This must simply be greater than 0.
-  static constexpr int kPrepopulatedId = 999999;
-
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
   TemplateURL* AddKeywordWithDate(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,
@@ skipping 688 matching lines @@
   ASSERT_TRUE(bing);
   EXPECT_EQ(TemplateURL::NORMAL, bing->type());
 
   // User search engine is preserved.
   EXPECT_EQ(user_dse, model()->GetTemplateURLForHost("www.goo.com"));
   EXPECT_EQ(ASCIIToUTF16("google.com"), user_dse->keyword());
 }
 
 TEST_F(TemplateURLServiceTest, RepairSearchEnginesWithManagedDefault) {
   // Set a managed preference that establishes a default search provider.
-  const char kName[] = "test1";
-  const char kKeyword[] = "test.com";
-  const char kSearchURL[] = "http://test.com/search?t={searchTerms}";
-  const char kIconURL[] = "http://test.com/icon.jpg";
-  const char kEncodings[] = "UTF-16;UTF-32";
-  const char kAlternateURL[] = "http://test.com/search#t={searchTerms}";
-  const char kSearchTermsReplacementKey[] = "espv";
-  test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword,
-                                                  kSearchURL, std::string(),
-                                                  kIconURL, kEncodings,
-                                                  kAlternateURL,
-                                                  kSearchTermsReplacementKey);
+  std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine();
+  SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile());
   test_util()->VerifyLoad();
+
   // Verify that the default manager we are getting is the managed one.
-  TemplateURLData data;
-  data.SetShortName(ASCIIToUTF16(kName));
-  data.SetKeyword(ASCIIToUTF16(kKeyword));
-  data.SetURL(kSearchURL);
-  data.favicon_url = GURL(kIconURL);
-  data.prepopulate_id = kPrepopulatedId;
-  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));
+  auto expected_managed_default = base::MakeUnique<TemplateURL>(*managed);
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
   // The following call has no effect on the managed search engine.
   model()->RepairPrepopulatedSearchEngines();
 
   EXPECT_TRUE(model()->is_default_search_managed());
   actual_managed_default = model()->GetDefaultSearchProvider();
@@ skipping 336 matching lines @@
       std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time());
   VerifyObserverCount(1);
   model()->SetUserSelectedDefaultSearchProvider(regular_default);
   // Adding the URL and setting the default search provider should have caused
   // notifications.
   VerifyObserverCount(1);
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // Set a managed preference that establishes a default search provider.
-  const char kName[] = "test1";
-  const char kKeyword[] = "test.com";
-  const char kSearchURL[] = "http://test.com/search?t={searchTerms}";
-  const char kIconURL[] = "http://test.com/icon.jpg";
-  const char kEncodings[] = "UTF-16;UTF-32";
-  const char kAlternateURL[] = "http://test.com/search#t={searchTerms}";
-  const char kSearchTermsReplacementKey[] = "espv";
-  test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword,
-      kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
-      kSearchTermsReplacementKey);
+  std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine();
+  SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile());
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are getting is the managed one.
-  TemplateURLData data;
-  data.SetShortName(ASCIIToUTF16(kName));
-  data.SetKeyword(ASCIIToUTF16(kKeyword));
-  data.SetURL(kSearchURL);
-  data.favicon_url = GURL(kIconURL);
-  data.prepopulate_id = kPrepopulatedId;
-  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_default1(new TemplateURL(data));
+  auto expected_managed_default1 = base::MakeUnique<TemplateURL>(*managed);
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default1.get(), actual_managed_default);
   EXPECT_TRUE(model()->ShowInDefaultList(actual_managed_default));
 
   // Update the managed preference and check that the model has changed.
-  const char kNewName[] = "test2";
-  const char kNewKeyword[] = "other.com";
-  const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}";
-  const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}";
-  test_util()->SetManagedDefaultSearchPreferences(true, kNewName, kNewKeyword,
-      kNewSearchURL, kNewSuggestURL, std::string(), std::string(),
-      std::string(), std::string());
+  TemplateURLData managed2;
+  managed2.SetShortName(ASCIIToUTF16("test2"));
+  managed2.SetKeyword(ASCIIToUTF16("other.com"));
+  managed2.SetURL("http://other.com/search?t={searchTerms}");
+  managed2.suggestions_url = "http://other.com/suggest?t={searchTerms}";
+  SetManagedDefaultSearchPreferences(managed2, true, test_util()->profile());
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are now getting is the correct one.
-  TemplateURLData data2;
-  data2.SetShortName(ASCIIToUTF16(kNewName));
-  data2.SetKeyword(ASCIIToUTF16(kNewKeyword));
-  data2.SetURL(kNewSearchURL);
-  data2.suggestions_url = kNewSuggestURL;
-  data2.prepopulate_id = kPrepopulatedId;
-  std::unique_ptr<TemplateURL> expected_managed_default2(
-      new TemplateURL(data2));
+  auto expected_managed_default2 = base::MakeUnique<TemplateURL>(managed2);
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default2.get(), actual_managed_default);
   EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true);
 
   // Remove all the managed prefs and check that we are no longer managed.
-  test_util()->RemoveManagedDefaultSearchPreferences();
+  RemoveManagedDefaultSearchPreferences(test_util()->profile());
   VerifyObserverFired();
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // The default should now be the user preference.
   const TemplateURL* actual_final_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(regular_default, actual_final_managed_default);
   EXPECT_EQ(model()->ShowInDefaultList(actual_final_managed_default), true);
 
   // Disable the default search provider through policy.
-  test_util()->SetManagedDefaultSearchPreferences(false, std::string(),
-      std::string(), std::string(), std::string(), std::string(),
-      std::string(), std::string(), std::string());
+  SetManagedDefaultSearchPreferences(managed2, false, test_util()->profile());
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider());
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // Re-enable it.
-  test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword,
-      kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
-      kSearchTermsReplacementKey);
+  SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile());
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are getting is the managed one.
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default1.get(), actual_managed_default);
   EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true);
 
   // Clear the model and disable the default search provider through policy.
   // Verify that there is no default search provider after loading the model.
   // This checks against regressions of http://crbug.com/67180
 
   // First, remove the preferences, reset the model, and set a default.
-  test_util()->RemoveManagedDefaultSearchPreferences();
+  RemoveManagedDefaultSearchPreferences(test_util()->profile());
   test_util()->ResetModel(true);
   TemplateURL* new_default =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1"));
   ASSERT_FALSE(new_default == NULL);
   model()->SetUserSelectedDefaultSearchProvider(new_default);
   EXPECT_EQ(new_default, model()->GetDefaultSearchProvider());
 
   // Now reset the model again but load it after setting the preferences.
   test_util()->ResetModel(false);
-  test_util()->SetManagedDefaultSearchPreferences(false, std::string(),
-      std::string(), std::string(), std::string(), std::string(),
-      std::string(), std::string(), std::string());
+  SetManagedDefaultSearchPreferences(*managed, false, test_util()->profile());
   test_util()->VerifyLoad();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(model()->GetDefaultSearchProvider() == NULL);
 }
 
 // Test that if we load a TemplateURL with an empty GUID, the load process
 // assigns it a newly generated GUID.
 TEST_F(TemplateURLServiceTest, PatchEmptySyncGUID) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
@@ skipping 118 matching lines @@
 
   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) {
   // Set a managed preference that establishes a default search provider.
-  const char kName[] = "test";
-  const char kKeyword[] = "test.com";
-  const char kSearchURL[] = "http://test.com/search?t={searchTerms}";
-  const char kIconURL[] = "http://test.com/icon.jpg";
-  const char kEncodings[] = "UTF-16;UTF-32";
-  const char kAlternateURL[] = "http://test.com/search#t={searchTerms}";
-  const char kSearchTermsReplacementKey[] = "espv";
-  test_util()->SetManagedDefaultSearchPreferences(
-      true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings,
-      kAlternateURL, kSearchTermsReplacementKey);
+  std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine();
+  SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile());
   test_util()->VerifyLoad();
   // Verify that the default manager we are getting is the managed one.
-  TemplateURLData data;
-  data.SetShortName(ASCIIToUTF16(kName));
-  data.SetKeyword(ASCIIToUTF16(kKeyword));
-  data.SetURL(kSearchURL);
-  data.favicon_url = GURL(kIconURL);
-  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));
+  auto expected_managed_default = base::MakeUnique<TemplateURL>(*managed);
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
   std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
       std::string(), std::string(), std::string(), true, kPrepopulatedId,
       "UTF-8", Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
-  std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info(
-      new TemplateURL::AssociatedExtensionInfo("ext1"));
+  auto extension_info =
+      base::MakeUnique<TemplateURL::AssociatedExtensionInfo>("ext1");
   extension_info->wants_to_be_default_engine = true;
   TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL(
       std::move(ext_dse), std::move(extension_info));
   EXPECT_EQ(ext_dse_ptr,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1")));
   EXPECT_TRUE(model()->is_default_search_managed());
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 }