If default search is managed, we should not asked the user to choose it at Fi...

chrome/browser/search_engines/template_url_model_unittest.cc

 // Copyright (c) 2010 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/callback.h"
 #include "base/scoped_vector.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
@@ skipping 168 matching lines @@
     EXPECT_EQ(expected->short_name(), actual->short_name());
     EXPECT_EQ(JoinString(expected->input_encodings(), ';'),
               JoinString(actual->input_encodings(), ';'));
     EXPECT_TRUE(expected->GetFavIconURL() == actual->GetFavIconURL());
     EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace());
     EXPECT_EQ(expected->show_in_default_list(), actual->show_in_default_list());
   }
 
   // Set the managed preferences for the default search provider and trigger
   // notification.
-  void SetManagedDefaultSearchPreferences(const char* name,
+  void SetManagedDefaultSearchPreferences(bool enabled,
+                                          const char* name,
                                           const char* search_url,
                                           const char* suggest_url,
                                           const char* icon_url,
                                           const char* encodings,
                                           const char* keyword) {
     TestingPrefService* service = profile()->GetTestingPrefService();
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderEnabled,
-        Value::CreateBooleanValue(true));
+        Value::CreateBooleanValue(enabled));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderName,
         Value::CreateStringValue(name));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderSearchURL,
         Value::CreateStringValue(search_url));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderSuggestURL,
         Value::CreateStringValue(suggest_url));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderIconURL,
         Value::CreateStringValue(icon_url));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderEncodings,
         Value::CreateStringValue(encodings));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderKeyword,
         Value::CreateStringValue(keyword));
     // Clear the IDs that are not specified via policy.
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderID, new StringValue(""));
     service->SetManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderPrepopulateID, new StringValue(""));
     NotifyManagedPrefsHaveChanged();
   }
 
-  // Set the managed preferences for the default search provider and trigger
-  // notification.
-  void DisableManagedDefaultSearchProvider() {
-    TestingPrefService* service = profile()->GetTestingPrefService();
-    service->SetManagedPrefWithoutNotification(
-        prefs::kDefaultSearchProviderEnabled,
-        Value::CreateBooleanValue(false));
-    NotifyManagedPrefsHaveChanged();
-  }
-
   // Remove all the managed preferences for the default search provider and
   // trigger notification.
   void RemoveManagedDefaultSearchPreferences() {
     TestingPrefService* service = profile()->GetTestingPrefService();
     service->RemoveManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderEnabled);
     service->RemoveManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderName);
     service->RemoveManagedPrefWithoutNotification(
         prefs::kDefaultSearchProviderSearchURL);
@@ skipping 868 matching lines @@
   // notifications.
   VerifyObserverCount(1);
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   // Set a managed preference that establishes a default search provider.
   const char kName[] = "test1";
   const char kSearchURL[] = "http://test.com/search?t={searchTerms}";
   const char kIconURL[] = "http://test.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
-  SetManagedDefaultSearchPreferences(kName, kSearchURL, "", kIconURL,
+  SetManagedDefaultSearchPreferences(true, kName, kSearchURL, "", kIconURL,
                                      kEncodings, "");
   VerifyObserverCount(1);
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(2 + initial_count, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are getting is the managed one.
   scoped_ptr<TemplateURL> expected_managed_default1(new TemplateURL());
   expected_managed_default1->SetURL(kSearchURL, 0, 0);
   expected_managed_default1->SetFavIconURL(GURL(kIconURL));
   expected_managed_default1->set_short_name(L"test1");
   std::vector<std::string> encodings_vector;
   base::SplitString(kEncodings, ';', &encodings_vector);
   expected_managed_default1->set_input_encodings(encodings_vector);
   expected_managed_default1->set_show_in_default_list(true);
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(actual_managed_default, expected_managed_default1.get());
   EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
 
   // Update the managed preference and check that the model has changed.
   const char kNewName[] = "test2";
   const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}";
   const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}";
-  SetManagedDefaultSearchPreferences(kNewName, kNewSearchURL, kNewSuggestURL,
-                                     "", "", "");
+  SetManagedDefaultSearchPreferences(true, kNewName, kNewSearchURL,
+                                     kNewSuggestURL, "", "", "");
   VerifyObserverCount(1);
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(2 + initial_count, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are now getting is the correct one.
   scoped_ptr<TemplateURL> expected_managed_default2(new TemplateURL());
   expected_managed_default2->SetURL(kNewSearchURL, 0, 0);
   expected_managed_default2->SetSuggestionsURL(kNewSuggestURL, 0, 0);
   expected_managed_default2->set_short_name(L"test2");
   expected_managed_default2->set_show_in_default_list(true);
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(actual_managed_default, expected_managed_default2.get());
   EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
 
   // Remove all the managed prefs and check that we are no longer managed.
   RemoveManagedDefaultSearchPreferences();
   VerifyObserverCount(1);
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   // The default should now be the first URL added
   const TemplateURL* actual_final_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(actual_final_managed_default,
       model()->GetTemplateURLs()[0]);
   EXPECT_EQ(actual_final_managed_default->show_in_default_list(), true);
 
   // Disable the default search provider through policy.
-  DisableManagedDefaultSearchProvider();
+  SetManagedDefaultSearchPreferences(false, "", "", "", "", "", "");
   VerifyObserverCount(1);
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider());
   EXPECT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   // Re-enable it.
-  SetManagedDefaultSearchPreferences(kName, kSearchURL, "", kIconURL,
+  SetManagedDefaultSearchPreferences(true, kName, kSearchURL, "", kIconURL,
                                      kEncodings, "");
   VerifyObserverCount(1);
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(2 + initial_count, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are getting is the managed one.
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(actual_managed_default, expected_managed_default1.get());
   EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
 }