Sanitize PrefStore interface.

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 176 matching lines @@
   // Set the managed preferences for the default search provider and trigger
   // notification.
   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(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderEnabled,
         Value::CreateBooleanValue(enabled));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderName,
         Value::CreateStringValue(name));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderSearchURL,
         Value::CreateStringValue(search_url));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderSuggestURL,
         Value::CreateStringValue(suggest_url));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderIconURL,
         Value::CreateStringValue(icon_url));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         prefs::kDefaultSearchProviderEncodings,
         Value::CreateStringValue(encodings));
-    service->SetManagedPrefWithoutNotification(
+    service->SetManagedPref(
         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();
   }
 
   // Remove all the managed preferences for the default search provider and
   // trigger notification.
   void RemoveManagedDefaultSearchPreferences() {
     TestingPrefService* service = profile()->GetTestingPrefService();
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
+        prefs::kDefaultSearchProviderSearchURL);
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderEnabled);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderName);
-    service->RemoveManagedPrefWithoutNotification(
-        prefs::kDefaultSearchProviderSearchURL);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderSuggestURL);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderIconURL);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderEncodings);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderKeyword);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderID);
-    service->RemoveManagedPrefWithoutNotification(
+    service->RemoveManagedPref(
         prefs::kDefaultSearchProviderPrepopulateID);
-    NotifyManagedPrefsHaveChanged();
   }
 
   // Creates a TemplateURL with the same prepopluated id as a real prepopulated
   // item. The input number determines which prepopulated item. The caller is
   // responsible for owning the returned TemplateURL*.
   TemplateURL* CreateReplaceablePreloadedTemplateURL(
       size_t index_offset_from_default,
       std::wstring* 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 TemplateURLModelTestUtil methods less
   // visually noisy in the test code.
   void VerifyObserverCount(int expected_changed_count) {
-    test_util_.VerifyObserverCount(expected_changed_count);
+    EXPECT_EQ(expected_changed_count, test_util_.GetObserverCount());
+    test_util_.ResetObserverCount();
+  }
+  void VerifyObserverFired() {
+    EXPECT_LE(1, test_util_.GetObserverCount());
+    test_util_.ResetObserverCount();
   }
   void BlockTillServiceProcessesRequests() {
     TemplateURLModelTestUtil::BlockTillServiceProcessesRequests();
   }
   void VerifyLoad() { test_util_.VerifyLoad(); }
   void ChangeModelToLoadState() { test_util_.ChangeModelToLoadState(); }
   void ResetModel(bool verify_load) { test_util_.ResetModel(verify_load); }
   std::wstring GetAndClearSearchTerm() {
     return test_util_.GetAndClearSearchTerm();
   }
@@ skipping 828 matching lines @@
   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(true, kName, kSearchURL, "", kIconURL,
                                      kEncodings, "");
-  VerifyObserverCount(1);
+  VerifyObserverFired();
   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(true, kNewName, kNewSearchURL,
                                      kNewSuggestURL, "", "", "");
-  VerifyObserverCount(1);
+  VerifyObserverFired();
   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);
+  VerifyObserverFired();
   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.
   SetManagedDefaultSearchPreferences(false, "", "", "", "", "", "");
-  VerifyObserverCount(1);
+  VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider());
   EXPECT_EQ(1 + initial_count, model()->GetTemplateURLs().size());
 
   // Re-enable it.
   SetManagedDefaultSearchPreferences(true, kName, kSearchURL, "", kIconURL,
                                      kEncodings, "");
-  VerifyObserverCount(1);
+  VerifyObserverFired();
   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);
 }