Use PrefChangeRegistrar everywhere

chrome/browser/extensions/extensions_service_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 "chrome/browser/extensions/extensions_service_unittest.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 269 matching lines @@
   service_ = NULL;
   profile_.reset(NULL);
   MessageLoop::current()->RunAllPending();
 }
 
 void ExtensionsServiceTestBase::InitializeExtensionsService(
     const FilePath& pref_file, const FilePath& extensions_install_dir) {
   ExtensionTestingProfile* profile = new ExtensionTestingProfile();
   // Create a preference service that only contains user defined
   // preference values.
-  prefs_.reset(PrefService::CreateUserPrefService(pref_file));
+  PrefService* prefs = PrefService::CreateUserPrefService(pref_file);
+  Profile::RegisterUserPrefs(prefs);
+  browser::RegisterUserPrefs(prefs);
+  profile->SetPrefService(prefs);
 
-  Profile::RegisterUserPrefs(prefs_.get());
-  browser::RegisterUserPrefs(prefs_.get());
   profile_.reset(profile);
 
   // TODO(scherkus): Remove this when we no longer need to have Talk
   // component extension state as a preference http://crbug.com/56429
   DictionaryValue* dict =
-      prefs_->GetMutableDictionary("extensions.settings");
+      profile->GetPrefs()->GetMutableDictionary("extensions.settings");
   dict->Remove("ggnioahjipcehijkhpdjekioddnjoben", NULL);
 
-  service_ = new ExtensionsService(profile_.get(),
-                                   CommandLine::ForCurrentProcess(),
-                                   prefs_.get(),
-                                   extensions_install_dir,
-                                   false);
+  service_ = profile->CreateExtensionsService(
+      CommandLine::ForCurrentProcess(),
+      extensions_install_dir);
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
   profile->set_extensions_service(service_.get());
 
   // When we start up, we want to make sure there is no external provider,
   // since the ExtensionService on Windows will use the Registry as a default
   // provider and if there is something already registered there then it will
   // interfere with the tests. Those tests that need an external provider
   // will register one specifically.
   service_->ClearProvidersForTesting();
@@ skipping 200 matching lines @@
       EXPECT_EQ(expected_enabled_extension_count,
                 enabled_extension_count);
     }
 
     // Update() should delete the temporary input file.
     EXPECT_FALSE(file_util::PathExists(path));
   }
 
   void ValidatePrefKeyCount(size_t count) {
     DictionaryValue* dict =
-        prefs_->GetMutableDictionary("extensions.settings");
+        profile_->GetPrefs()->GetMutableDictionary("extensions.settings");
     ASSERT_TRUE(dict != NULL);
     EXPECT_EQ(count, dict->size());
   }
 
   void ValidateBooleanPref(const std::string& extension_id,
                            const std::string& pref_path,
                            bool expected_val) {
     std::string msg = " while checking: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     msg += " == ";
     msg += expected_val ? "true" : "false";
 
-    const DictionaryValue* dict = prefs_->GetDictionary("extensions.settings");
+    PrefService* prefs = profile_->GetPrefs();
+    const DictionaryValue* dict =
+        prefs->GetDictionary("extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     bool val;
     ASSERT_TRUE(pref->GetBoolean(pref_path, &val)) << msg;
     EXPECT_EQ(expected_val, val) << msg;
   }
 
   bool IsPrefExist(const std::string& extension_id,
                    const std::string& pref_path) {
-    const DictionaryValue* dict = prefs_->GetDictionary("extensions.settings");
+    const DictionaryValue* dict =
+        profile_->GetPrefs()->GetDictionary("extensions.settings");
     if (dict == NULL) return false;
     DictionaryValue* pref = NULL;
     if (!dict->GetDictionary(extension_id, &pref)) {
       return false;
     }
     if (pref == NULL) {
       return false;
     }
     bool val;
     if (!pref->GetBoolean(pref_path, &val)) {
       return false;
     }
     return true;
   }
 
   void ValidateIntegerPref(const std::string& extension_id,
                            const std::string& pref_path,
                            int expected_val) {
     std::string msg = " while checking: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     msg += " == ";
     msg += base::IntToString(expected_val);
 
-    const DictionaryValue* dict = prefs_->GetDictionary("extensions.settings");
+    PrefService* prefs = profile_->GetPrefs();
+    const DictionaryValue* dict =
+        prefs->GetDictionary("extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     int val;
     ASSERT_TRUE(pref->GetInteger(pref_path, &val)) << msg;
     EXPECT_EQ(expected_val, val) << msg;
   }
 
   void ValidateStringPref(const std::string& extension_id,
                           const std::string& pref_path,
                           const std::string& expected_val) {
     std::string msg = " while checking: ";
     msg += extension_id;
     msg += ".manifest.";
     msg += pref_path;
     msg += " == ";
     msg += expected_val;
 
-    const DictionaryValue* dict = prefs_->GetDictionary("extensions.settings");
+    const DictionaryValue* dict =
+        profile_->GetPrefs()->GetDictionary("extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     std::string manifest_path = extension_id + ".manifest";
     ASSERT_TRUE(dict->GetDictionary(manifest_path, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     std::string val;
     ASSERT_TRUE(pref->GetString(pref_path, &val)) << msg;
     EXPECT_EQ(expected_val, val) << msg;
   }
 
   void SetPrefInteg(const std::string& extension_id,
                     const std::string& pref_path,
                     int value) {
     std::string msg = " while setting: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     msg += " = ";
     msg += base::IntToString(value);
 
     const DictionaryValue* dict =
-        prefs_->GetMutableDictionary("extensions.settings");
+        profile_->GetPrefs()->GetMutableDictionary("extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     pref->SetInteger(pref_path, value);
   }
 
  protected:
   ExtensionList loaded_;
   std::string unloaded_id_;
@@ skipping 205 matching lines @@
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
   InitializeInstalledExtensionsService(pref_path, source_install_dir);
 
   // Simulate that one of them got partially deleted by clearing its pref.
-  DictionaryValue* dict = prefs_->GetMutableDictionary("extensions.settings");
+  DictionaryValue* dict =
+      profile_->GetPrefs()->GetMutableDictionary("extensions.settings");
   ASSERT_TRUE(dict != NULL);
   dict->Remove("behllobkkfkfnphdnhnkndlbkcpglgmj", NULL);
 
   service_->Init();
   loop_.RunAllPending();
 
   file_util::FileEnumerator dirs(extensions_install_dir_, false,
                                  file_util::FileEnumerator::DIRECTORIES);
   size_t count = 0;
   while (!dirs.Next().empty())
@@ skipping 1002 matching lines @@
 
   EXPECT_NE(std::string(good1), loaded_[0]->id());
   EXPECT_NE(std::string(good1), loaded_[1]->id());
 }
 #endif
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionsServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionsService();
 
-  ListValue* whitelist = prefs_->GetMutableList("extensions.install.allowlist");
-  ListValue* blacklist = prefs_->GetMutableList("extensions.install.denylist");
+  ListValue* whitelist =
+      profile_->GetPrefs()->GetMutableList("extensions.install.allowlist");
+  ListValue* blacklist =
+      profile_->GetPrefs()->GetMutableList("extensions.install.denylist");
   ASSERT_TRUE(whitelist != NULL && blacklist != NULL);
 
   // Blacklist everything.
   blacklist->Append(Value::CreateStringValue("*"));
 
   // Blacklist prevents us from installing good_crx.
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
@@ skipping 16 matching lines @@
 
   // Install good_crx.
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
   EXPECT_EQ(1u, service_->extensions()->size());
 
-  ListValue* blacklist = prefs_->GetMutableList("extensions.install.denylist");
+  PrefService* prefs = profile_->GetPrefs();
+  ListValue* blacklist =
+      prefs->GetMutableList("extensions.install.denylist");
   ASSERT_TRUE(blacklist != NULL);
 
   // Blacklist this extension.
   blacklist->Append(Value::CreateStringValue(good_crx));
-  prefs_->ScheduleSavePersistentPrefs();
+  prefs->ScheduleSavePersistentPrefs();
 
   // Programmatically appending to the prefs doesn't seem to notify the
   // observers... :/
-  prefs_->pref_notifier()->FireObservers("extensions.install.denylist");
+  prefs->pref_notifier()->FireObservers("extensions.install.denylist");
 
   // Extension should not be running now.
   loop_.RunAllPending();
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
 // Tests disabling extensions
 TEST_F(ExtensionsServiceTest, DisableExtension) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
@@ skipping 297 matching lines @@
   loaded_.clear();
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::KILLBIT);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Now clear the preference and reinstall.
   SetPrefInteg(good_crx, "state", Extension::ENABLED);
-  prefs_->ScheduleSavePersistentPrefs();
+  profile_->GetPrefs()->ScheduleSavePersistentPrefs();
 
   loaded_.clear();
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(1u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Now test an externally triggered uninstall (deleting the registry key or
@@ skipping 207 matching lines @@
   MessageLoop loop;
   ChromeThread ui_thread(ChromeThread::UI, &loop);
   ChromeThread file_thread(ChromeThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
   scoped_refptr<ExtensionsService> service;
   FilePath install_dir = profile->GetPath()
       .AppendASCII(ExtensionsService::kInstallDirectoryName);
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::ARGUMENTS_ONLY));
-  service = new ExtensionsService(profile.get(), command_line.get(),
-      profile->GetPrefs(), install_dir, false);
+  service = profile->CreateExtensionsService(command_line.get(),
+                                             install_dir);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // If either the command line or pref is set, we are disabled.
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   command_line->AppendSwitch(switches::kDisableExtensions);
-  service = new ExtensionsService(profile.get(), command_line.get(),
-      profile->GetPrefs(), install_dir, false);
+  service = profile->CreateExtensionsService(command_line.get(),
+                                             install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
-  service = new ExtensionsService(profile.get(), command_line.get(),
-      profile->GetPrefs(), install_dir, false);
+  service = profile->CreateExtensionsService(command_line.get(),
+                                             install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   command_line.reset(new CommandLine(CommandLine::ARGUMENTS_ONLY));
-  service = new ExtensionsService(profile.get(), command_line.get(),
-      profile->GetPrefs(), install_dir, false);
+  service = profile->CreateExtensionsService(command_line.get(),
+                                             install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 }
 
 // Test loading extensions that require limited and unlimited storage quotas.
 TEST_F(ExtensionsServiceTest, StorageQuota) {
   InitializeEmptyExtensionsService();
 
@@ skipping 84 matching lines @@
   // Component extensions shouldn't get recourded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }