Change behaivor to decide whether a search engine should be shown in the default list

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 52 matching lines @@
 
 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,
+    int prepopulate_id,
     const std::string& encodings,
     Time date_created,
     Time last_modified,
     TemplateURL::Type type = TemplateURL::NORMAL) {
   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.prepopulate_id = prepopulate_id;
   data.input_encodings = base::SplitString(
       encodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   data.date_created = date_created;
   data.last_modified = last_modified;
   return base::MakeUnique<TemplateURL>(data, type);
 }
 
 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 = model->Add(CreateKeywordWithDate(
       model, short_name, keyword, url, suggest_url, alternate_url, favicon_url,
-      safe_for_autoreplace, false, encodings, date_created, last_modified));
+      safe_for_autoreplace, 0, 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());
   EXPECT_EQ(expected->keyword(), actual->keyword());
   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->show_in_default_list(), actual->show_in_default_list());
   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());
 }
 
 }  // 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 75 matching lines @@
 }
 
 void TemplateURLServiceTest::AssertEquals(const TemplateURL& expected,
                                           const TemplateURL& actual) {
   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.alternate_urls(), actual.alternate_urls());
-  ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
+  ASSERT_EQ(expected.prepopulate_id(), actual.prepopulate_id());
   ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
   ASSERT_EQ(expected.input_encodings(), actual.input_encodings());
   ASSERT_EQ(expected.id(), actual.id());
   ASSERT_EQ(expected.date_created(), actual.date_created());
   AssertTimesEqual(expected.last_modified(), actual.last_modified());
   ASSERT_EQ(expected.sync_guid(), actual.sync_guid());
   ASSERT_EQ(expected.search_terms_replacement_key(),
             actual.search_terms_replacement_key());
 }
 
 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));
 }
 
 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 base::MakeUnique<TemplateURL>(data);
 }
 
 void TemplateURLServiceTest::VerifyObserverCount(int expected_changed_count) {
   EXPECT_EQ(expected_changed_count, test_util_->GetObserverCount());
@@ skipping 405 matching lines @@
   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());
+  ASSERT_TRUE(model()->ShowInDefaultList(t_url));
 
   // Setting the default search provider should have caused notification.
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
 
   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);
@@ skipping 159 matching lines @@
                                                   kIconURL, kEncodings,
                                                   kAlternateURL,
                                                   kSearchTermsReplacementKey);
   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.show_in_default_list = true;
+  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));
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
@@ skipping 161 matching lines @@
   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.
   test_util()->ChangeModelToLoadState();
-  model()->Add(CreatePreloadedTemplateURL(true, 999999));
+  model()->Add(CreatePreloadedTemplateURL(true, kPrepopulatedId));
   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.
   test_util()->ChangeModelToLoadState();
-  TemplateURL* t_url = model()->Add(CreatePreloadedTemplateURL(false, 999999));
+  TemplateURL* t_url =
+      model()->Add(CreatePreloadedTemplateURL(false, kPrepopulatedId));
 
   // Do the copy after t_url is added so that the id is set.
   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.
@@ skipping 35 matching lines @@
 }
 
 // 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.
   test_util()->ChangeModelToLoadState();
-  TemplateURL* t_url = model()->Add(CreatePreloadedTemplateURL(true, 999999));
+  TemplateURL* t_url =
+      model()->Add(CreatePreloadedTemplateURL(true, kPrepopulatedId));
   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 =
       base::MakeUnique<TemplateURL>(t_url->data());
 
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")));
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
   base::RunLoop().RunUntilIdle();
 
@@ skipping 96 matching lines @@
   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.show_in_default_list = true;
+  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));
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default1.get(), actual_managed_default);
-  EXPECT_TRUE(actual_managed_default->show_in_default_list());
+  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());
   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.show_in_default_list = true;
+  data2.prepopulate_id = kPrepopulatedId;
   std::unique_ptr<TemplateURL> expected_managed_default2(
       new TemplateURL(data2));
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default2.get(), actual_managed_default);
-  EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
+  EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true);
 
   // Remove all the managed prefs and check that we are no longer managed.
   test_util()->RemoveManagedDefaultSearchPreferences();
   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(actual_final_managed_default->show_in_default_list(), true);
+  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());
   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);
   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(actual_managed_default->show_in_default_list(), true);
+  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();
   test_util()->ResetModel(true);
   TemplateURL* new_default =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1"));
@@ skipping 83 matching lines @@
   // 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());
 
   std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate(
       model(), "ext", "ext", "http://www.search.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
-      Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
+      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("ext"));
   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()->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());
 
   std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(), true, false, "UTF-8", Time(),
+      std::string(), std::string(), std::string(), true, 0, "UTF-8", Time(),
       Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info(
       new TemplateURL::AssociatedExtensionInfo("ext1"));
   extension_info->wants_to_be_default_engine = false;
   model()->AddExtensionControlledTURL(std::move(ext_dse),
                                       std::move(extension_info));
   EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider());
 
   ext_dse = CreateKeywordWithDate(
       model(), "ext2", "ext2", "http://www.ext2.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
-      Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
+      std::string(), std::string(), std::string(), true, kPrepopulatedId,
+      "UTF-8", Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
   extension_info.reset(new TemplateURL::AssociatedExtensionInfo("ext2"));
   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()->GetDefaultSearchProvider());
 
   test_util()->ResetModel(true);
   user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user"));
   ExpectSimilar(user_dse, model()->GetDefaultSearchProvider());
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1")));
@@ skipping 12 matching lines @@
   test_util()->SetManagedDefaultSearchPreferences(
       true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings,
       kAlternateURL, kSearchTermsReplacementKey);
   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.show_in_default_list = true;
   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);
 
   std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
-      std::string(), std::string(), std::string(), true, true, "UTF-8", Time(),
-      Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION);
+      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"));
   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);
 }