Revert of Use the DefaultSearchManager as the exclusive authority on DSE, ignoring Web Data.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
@@ skipping 169 matching lines @@
                                   Time last_modified);
 
   // Verifies the two TemplateURLs are equal.
   void AssertEquals(const TemplateURL& expected, const TemplateURL& 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);
 
+  // Creates a TemplateURL with the same prepopulated id as a real prepopulated
+  // item. The input number determines which prepopulated item. The caller is
+  // responsible for owning the returned TemplateURL*.
+  TemplateURL* CreateReplaceablePreloadedTemplateURL(
+      bool safe_for_autoreplace,
+      size_t index_offset_from_default,
+      base::string16* prepopulated_display_url);
+
+  // Verifies the behavior of when a preloaded url later gets changed.
+  // Since the input is the offset from the default, when one passes in
+  // 0, it tests the default. Passing in a number > 0 will verify what
+  // happens when a preloaded url that is not the default gets updated.
+  void TestLoadUpdatingPreloadedURL(size_t index_offset_from_default);
+
   // Helper methods to make calling TemplateURLServiceTestUtil methods less
   // visually noisy in the test code.
   void VerifyObserverCount(int expected_changed_count);
   void VerifyObserverFired();
   TemplateURLService* model() { return test_util_.model(); }
 
  protected:
   TemplateURLServiceTestUtil test_util_;
 
   void TestGenerateSearchURL(SearchTermsData* search_terms_data) {
@@ skipping 22 matching lines @@
       EXPECT_EQ(result,  generate_url_cases[i].expected)
           << generate_url_cases[i].test_name << " failed. Expected "
           << generate_url_cases[i].expected << " Actual " << result;
     }
   }
 
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceTest);
 };
 
-class TemplateURLServiceWithoutFallbackTest : public TemplateURLServiceTest {
- public:
-  TemplateURLServiceWithoutFallbackTest() : TemplateURLServiceTest() {}
-
-  virtual void SetUp() OVERRIDE {
-    TemplateURLService::set_fallback_search_engines_disabled(true);
-    TemplateURLServiceTest::SetUp();
-  }
-
-  virtual void TearDown() OVERRIDE {
-    TemplateURLServiceTest::TearDown();
-    TemplateURLService::set_fallback_search_engines_disabled(false);
-  }
-};
-
 TemplateURLServiceTest::TemplateURLServiceTest() {
 }
 
 void TemplateURLServiceTest::SetUp() {
   test_util_.SetUp();
 }
 
 void TemplateURLServiceTest::TearDown() {
   test_util_.TearDown();
 }
@@ skipping 43 matching lines @@
   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(test_util_.profile(), data);
 }
 
+TemplateURL* TemplateURLServiceTest::CreateReplaceablePreloadedTemplateURL(
+    bool safe_for_autoreplace,
+    size_t index_offset_from_default,
+    base::string16* prepopulated_display_url) {
+  size_t default_search_provider_index = 0;
+  ScopedVector<TemplateURLData> prepopulated_urls =
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(
+          test_util_.profile()->GetPrefs(), &default_search_provider_index);
+  EXPECT_LT(index_offset_from_default, prepopulated_urls.size());
+  size_t prepopulated_index = (default_search_provider_index +
+      index_offset_from_default) % prepopulated_urls.size();
+  TemplateURL* t_url = CreatePreloadedTemplateURL(safe_for_autoreplace,
+      prepopulated_urls[prepopulated_index]->prepopulate_id);
+  *prepopulated_display_url =
+      TemplateURL(NULL, *prepopulated_urls[prepopulated_index]).url_ref().
+          DisplayURL();
+  return t_url;
+}
+
+void TemplateURLServiceTest::TestLoadUpdatingPreloadedURL(
+    size_t index_offset_from_default) {
+  base::string16 prepopulated_url;
+  TemplateURL* t_url = CreateReplaceablePreloadedTemplateURL(false,
+      index_offset_from_default, &prepopulated_url);
+
+  base::string16 original_url = t_url->url_ref().DisplayURL();
+  std::string original_guid = t_url->sync_guid();
+  EXPECT_NE(prepopulated_url, original_url);
+
+  // Then add it to the model and save it all.
+  test_util_.ChangeModelToLoadState();
+  model()->Add(t_url);
+  const TemplateURL* keyword_url =
+      model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
+  ASSERT_TRUE(keyword_url != NULL);
+  EXPECT_EQ(t_url, keyword_url);
+  EXPECT_EQ(original_url, keyword_url->url_ref().DisplayURL());
+  base::RunLoop().RunUntilIdle();
+
+  // Now reload the model and verify that the merge updates the url, and
+  // preserves the sync GUID.
+  test_util_.ResetModel(true);
+  keyword_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
+  ASSERT_TRUE(keyword_url != NULL);
+  EXPECT_EQ(prepopulated_url, keyword_url->url_ref().DisplayURL());
+  EXPECT_EQ(original_guid, keyword_url->sync_guid());
+
+  // Wait for any saves to finish.
+  base::RunLoop().RunUntilIdle();
+
+  // Reload the model to verify that change was saved correctly.
+  test_util_.ResetModel(true);
+  keyword_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
+  ASSERT_TRUE(keyword_url != NULL);
+  EXPECT_EQ(prepopulated_url, keyword_url->url_ref().DisplayURL());
+  EXPECT_EQ(original_guid, keyword_url->sync_guid());
+}
+
 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 665 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     history::URLVisitedDetails details;
     details.row = history::URLRow(GURL(data[i].url));
     details.transition = content::PageTransitionFromInt(0);
     model()->UpdateKeywordSearchTermsForURL(details);
     ASSERT_EQ(base::string16(), test_util_.GetAndClearSearchTerm());
   }
 }
 
-TEST_F(TemplateURLServiceWithoutFallbackTest, ChangeGoogleBaseValue) {
-  // NOTE: Do not load the prepopulate data, which also has a {google:baseURL}
-  // keyword in it and would confuse this test.
+TEST_F(TemplateURLServiceTest, ChangeGoogleBaseValue) {
+  // NOTE: Do not do a VerifyLoad() here as it will load the prepopulate data,
+  // which also has a {google:baseURL} keyword in it, which will confuse this
+  // test.
   test_util_.ChangeModelToLoadState();
-
   test_util_.SetGoogleBaseURL(GURL("http://google.com/"));
   const TemplateURL* t_url = AddKeywordWithDate(
       "name", "google.com", "{google:baseURL}?q={searchTerms}", "http://sugg1",
       std::string(), "http://icon1", false, "UTF-8;UTF-16", Time(), Time());
   ASSERT_EQ(t_url, model()->GetTemplateURLForHost("google.com"));
   EXPECT_EQ("google.com", t_url->url_ref().GetHost());
   EXPECT_EQ(ASCIIToUTF16("google.com"), t_url->keyword());
 
   // Change the Google base url.
   test_util_.ResetObserverCount();
@@ skipping 156 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Reload the model and check that the default search provider
   // was properly saved.
   test_util_.ResetModel(true);
   default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search != NULL);
   AssertEquals(*cloned_url, *default_search);
 }
 
+TEST_F(TemplateURLServiceTest, FindNewDefaultSearchProvider) {
+  // Ensure that if our service is initially empty, we don't initial have a
+  // valid new DSP.
+  EXPECT_FALSE(model()->FindNewDefaultSearchProvider());
+
+  // Add a few entries with searchTerms, but ensure only the last one is in the
+  // default list.
+  AddKeywordWithDate("name1", "key1", "http://foo1/{searchTerms}",
+                     "http://sugg1", std::string(), "http://icon1", true,
+                     "UTF-8;UTF-16", Time(), Time());
+  AddKeywordWithDate("name2", "key2", "http://foo2/{searchTerms}",
+                     "http://sugg2", std::string(), "http://icon1", true,
+                     "UTF-8;UTF-16", Time(), Time());
+  AddKeywordWithDate("name3", "key3", "http://foo1/{searchTerms}",
+                     "http://sugg3", std::string(), "http://icon3", true,
+                     "UTF-8;UTF-16", Time(), Time());
+  TemplateURLData data;
+  data.short_name = ASCIIToUTF16("valid");
+  data.SetKeyword(ASCIIToUTF16("validkeyword"));
+  data.SetURL("http://valid/{searchTerms}");
+  data.favicon_url = GURL("http://validicon");
+  data.show_in_default_list = true;
+  TemplateURL* valid_turl(new TemplateURL(test_util_.profile(), data));
+  model()->Add(valid_turl);
+  EXPECT_EQ(4U, model()->GetTemplateURLs().size());
+
+  // Request a new DSP from the service and only expect the valid one.
+  TemplateURL* new_default = model()->FindNewDefaultSearchProvider();
+  ASSERT_TRUE(new_default);
+  EXPECT_EQ(valid_turl, new_default);
+
+  // Remove the default we received and ensure that the service returns NULL.
+  model()->Remove(new_default);
+  EXPECT_FALSE(model()->FindNewDefaultSearchProvider());
+}
+
 // 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);
@@ skipping 25 matching lines @@
   test_util_.ResetModel(true);
   {
     const TemplateURL* keyword_url =
         model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
     ASSERT_TRUE(keyword_url != NULL);
     AssertEquals(*cloned_url, *keyword_url);
     ASSERT_EQ(keyword_url, model()->GetDefaultSearchProvider());
   }
 }
 
+// Make sure that the load routine updates the url of a preexisting
+// default search engine provider and that the result is saved correctly.
+TEST_F(TemplateURLServiceTest, LoadUpdatesDefaultSearchURL) {
+  TestLoadUpdatingPreloadedURL(0);
+}
+
+// Make sure that the load routine updates the url of a preexisting
+// non-default search engine provider and that the result is saved correctly.
+TEST_F(TemplateURLServiceTest, LoadUpdatesSearchURL) {
+  TestLoadUpdatingPreloadedURL(1);
+}
+
 // Make sure that the load routine sets a default search provider if it was
 // missing and not managed.
 TEST_F(TemplateURLServiceTest, LoadEnsuresDefaultSearchProviderExists) {
   // Force the model to load and make sure we have a default search provider.
   test_util_.VerifyLoad();
-  EXPECT_TRUE(model()->GetDefaultSearchProvider());
+  TemplateURL* old_default = model()->GetDefaultSearchProvider();
+  EXPECT_TRUE(old_default);
 
+  // Now remove it.
+  model()->SetUserSelectedDefaultSearchProvider(NULL);
+  model()->Remove(old_default);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(model()->GetDefaultSearchProvider());
+
+  // Reset the model and load it. There should be a default search provider.
+  test_util_.ResetModel(true);
+
+  ASSERT_TRUE(model()->GetDefaultSearchProvider());
   EXPECT_TRUE(model()->GetDefaultSearchProvider()->SupportsReplacement());
 
   // Make default search provider unusable (no search terms).
   model()->ResetTemplateURL(model()->GetDefaultSearchProvider(),
                             ASCIIToUTF16("test"), ASCIIToUTF16("test"),
                             "http://example.com/");
   base::RunLoop().RunUntilIdle();
 
   // Reset the model and load it. There should be a usable default search
   // provider.
@@ skipping 97 matching lines @@
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default2.get(), actual_managed_default);
   EXPECT_EQ(actual_managed_default->show_in_default_list(), 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.
+  // The default should now be the first URL added
   const TemplateURL* actual_final_managed_default =
       model()->GetDefaultSearchProvider();
-  ExpectSimilar(regular_default, actual_final_managed_default);
+  ExpectSimilar(model()->GetTemplateURLs()[0], actual_final_managed_default);
   EXPECT_EQ(actual_final_managed_default->show_in_default_list(), 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());
@@ skipping 203 matching lines @@
   scoped_ptr<AssociatedExtensionInfo> extension_info(
       new AssociatedExtensionInfo);
   extension_info->wants_to_be_default_engine = true;
   extension_info->extension_id = "ext1";
   model()->AddExtensionControlledTURL(ext_dse, extension_info.Pass());
   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);
 }