Sanitize PrefStore interface.

chrome/browser/extensions/extension_prefs.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/extension_prefs.h"
 
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 
 using base::Time;
 
 namespace {
 
@@ skipping 113 matching lines @@
                               std::set<std::string>* result) {
   ExtensionExtent::PatternList patterns = host_extent.patterns();
   ExtensionExtent::PatternList::const_iterator i;
 
   for (i = patterns.begin(); i != patterns.end(); ++i)
     result->insert(i->GetAsString());
 }
 
 }  // namespace
 
-ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
+ExtensionPrefs::ExtensionPrefs(PrefService* prefs,
+                               const FilePath& root_dir,
+                               ExtensionPrefStore* pref_store)
     : prefs_(prefs),
-      install_directory_(root_dir) {
+      install_directory_(root_dir),
+      pref_store_(pref_store) {
   // TODO(asargent) - Remove this in a couple of months. (See comment above
   // CleanupBadExtensionKeys).
   CleanupBadExtensionKeys(prefs_);
 
   MakePathsRelative();
 
   InitPrefStore();
 }
 
 ExtensionPrefs::~ExtensionPrefs() {}
@@ skipping 1027 matching lines @@
 
   // Collect the unique extension controlled preference keys of all extensions.
   PrefKeySet ext_controlled_prefs;
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     GetExtensionControlledPrefKeys(*ext_id, &ext_controlled_prefs);
   }
 
   // Store winning preference for each extension controlled preference.
   UpdatePrefStore(ext_controlled_prefs);
+  pref_store_->OnInitializationCompleted();
 }
 
 const Value* ExtensionPrefs::GetWinningExtensionControlledPrefValue(
     const std::string& key) const {
   Value *winner = NULL;
   base::Time winners_install_time = base::Time();
 
   ExtensionIdSet extension_ids;
   GetEnabledExtensions(&extension_ids);
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
@@ skipping 19 matching lines @@
 
 void ExtensionPrefs::UpdatePrefStore(
     const ExtensionPrefs::PrefKeySet& pref_keys) {
   for (PrefKeySet::const_iterator i = pref_keys.begin();
        i != pref_keys.end(); ++i) {
     UpdatePrefStore(*i);
   }
 }
 
 void ExtensionPrefs::UpdatePrefStore(const std::string& pref_key) {
-  PrefStore* extension_pref_store =
-      pref_service()->GetExtensionPrefStore();
-  if (extension_pref_store == NULL)
-    return;  // Profile is being shut down, Pref Service is already gone.
+  if (pref_store_ == NULL)
+    return;
   const Value* winning_pref_value =
       GetWinningExtensionControlledPrefValue(pref_key);
-  Value* old_value = NULL;
-  extension_pref_store->prefs()->Get(pref_key, &old_value);
-  bool changed = !Value::Equals(winning_pref_value, old_value);
 
-  if (winning_pref_value) {
-    extension_pref_store->prefs()->Set(pref_key,
-                                       winning_pref_value->DeepCopy());
-  } else {
-    extension_pref_store->prefs()->Remove(pref_key, NULL);
-  }
-
-  if (changed)
-    pref_service()->pref_notifier()->OnPreferenceChanged(pref_key.c_str());
+  if (winning_pref_value)
+    pref_store_->SetExtensionPref(pref_key, winning_pref_value->DeepCopy());
+  else
+    pref_store_->RemoveExtensionPref(pref_key);
 }
 
 void ExtensionPrefs::SetExtensionControlledPref(const std::string& extension_id,
                                                 const std::string& pref_key,
                                                 Value* value) {
   scoped_ptr<Value> scoped_value(value);
   DCHECK(pref_service()->FindPreference(pref_key.c_str()))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
   DictionaryValue* extension_preferences =
@@ skipping 41 matching lines @@
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList);
   prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */);
 }