Rename SetDefaultSearchProvider.

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 "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 473 matching lines @@
     // Tie. Sync wins.
     {100, 100, false, false, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     TemplateURL* local_turl = CreateTestTemplateURL(
         ASCIIToUTF16("localkey"), "www.local.com", "localguid",
         test_cases[i].local_time, true, test_cases[i].local_created_by_policy);
     model()->Add(local_turl);
     if (test_cases[i].local_is_default)
-      model()->SetDefaultSearchProvider(local_turl);
+      model()->SetUserSelectedDefaultSearchProvider(local_turl);
 
     scoped_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()->SetDefaultSearchProvider(NULL);
+      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.
@@ skipping 930 matching lines @@
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultGUIDArrivesFirst) {
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The default search provider should support replacement.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://key2.com/{searchTerms}", "key2", 90));
   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
-  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
+  model()->SetUserSelectedDefaultSearchProvider(
+      model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
   // the model yet. Ensure that the default has not changed in any way.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
 
@@ skipping 42 matching lines @@
   data.prepopulate_id = 999999;
   data.sync_guid = "key2";
   data.show_in_default_list = true;
   scoped_ptr<TemplateURL> turl2(new TemplateURL(NULL, data));
   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
       *turl1));
   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
       *turl2));
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
-  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key1"));
+  model()->SetUserSelectedDefaultSearchProvider(
+      model()->GetTemplateURLForGUID("key1"));
   ASSERT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
   // the model yet. Ensure that the default has not changed in any way.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
@@ skipping 36 matching lines @@
   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultArrivesAfterStartup) {
   // Start with the default set to something in the model before we start
   // syncing.
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
                                      "http://thewhat.com/{searchTerms}",
                                      "initdefault"));
-  model()->SetDefaultSearchProvider(
+  model()->SetUserSelectedDefaultSearchProvider(
       model()->GetTemplateURLForGUID("initdefault"));
 
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Set kSyncedDefaultSearchProviderGUID to something that is not yet in
   // the model but is expected in the initial sync. Ensure that this doesn't
   // change our default since we're not quite syncing yet.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "key2");
@@ skipping 17 matching lines @@
   ASSERT_EQ("key2", model()->GetDefaultSearchProvider()->sync_guid());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultAlreadySetOnStartup) {
   // Start with the default set to something in the model before we start
   // syncing.
   const char kGUID[] = "initdefault";
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
                                      "http://thewhat.com/{searchTerms}",
                                      kGUID));
-  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID(kGUID));
+  model()->SetUserSelectedDefaultSearchProvider(
+      model()->GetTemplateURLForGUID(kGUID));
 
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Set kSyncedDefaultSearchProviderGUID to the current default.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, kGUID);
 
   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
 
@@ skipping 21 matching lines @@
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://key2.com/{searchTerms}", "key2", 90));
   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     TemplateURL* converted = Deserialize(*iter);
     model()->Add(converted);
   }
 
   // Set the initial default to something other than the desired default.
-  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key1"));
+  model()->SetUserSelectedDefaultSearchProvider(
+      model()->GetTemplateURLForGUID("key1"));
 
   // Merge in the same data (i.e. already synced entries).
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   TemplateURL* current_default = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(current_default);
   EXPECT_EQ("key2", current_default->sync_guid());
   EXPECT_EQ(ASCIIToUTF16("key2"), current_default->keyword());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
   // First start off with a few entries and make sure we can set an unmanaged
   // default search provider.
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
-  model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
+  model()->SetUserSelectedDefaultSearchProvider(
+      model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   ASSERT_FALSE(model()->is_default_search_managed());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Change the default search provider to a managed one.
   const char kName[] = "manageddefault";
   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
@@ skipping 35 matching lines @@
 
   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);
-  model()->SetDefaultSearchProvider(default_turl);
+  model()->SetUserSelectedDefaultSearchProvider(default_turl);
 
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The key1 entry should be a duplicate of the default.
   scoped_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);
-  model()->SetDefaultSearchProvider(default_turl);
+  model()->SetUserSelectedDefaultSearchProvider(default_turl);
 
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The key1 entry should be different from the default but conflict in the
   // keyword.
   scoped_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());
@@ skipping 471 matching lines @@
   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());
 }