Create a DefaultPrefStore to hold registered application-default preference v...

chrome/browser/extensions/extension_pref_store.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_pref_store.h"
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 69 matching lines @@
       i != extension_stack_.end(); ++i) {
     (*result).push_back((*i)->extension->id());
   }
 }
 
 // This could be sped up by keeping track of which extension currently controls
 // a given preference, among other optimizations. But probably fewer than 10
 // installed extensions will be trying to control any preferences, so stick
 // with this simpler algorithm until it causes a problem.
 void ExtensionPrefStore::UpdateOnePref(const char* path) {
-  scoped_ptr<Value> old_value;
   PrefService* pref_service = GetPrefService();
 
   // There are at least two PrefServices, one for local state and one for
   // user prefs. (See browser_main.cc.) Different preferences are registered
   // in each; if this one doesn't have the desired pref registered, we ignore
   // it and let the other one handle it.
   // The pref_service may be NULL in unit testing.
-  if (pref_service) {
-    const PrefService::Preference* pref = pref_service->FindPreference(path);
-    if (!pref)
+  if (pref_service && !pref_service->FindPreference(path))
       return;
-    old_value.reset(pref->GetValue()->DeepCopy());
-  }
+
+  // Save the old value before removing it from the local cache.
+  Value* my_old_value_ptr = NULL;
+  prefs_->Get(path, &my_old_value_ptr);
+  scoped_ptr<Value> my_old_value;
+  if (my_old_value_ptr)
+    my_old_value.reset(my_old_value_ptr->DeepCopy());
 
   // DictionaryValue::Set complains if a key is overwritten with the same
-  // value, so delete it first.
+  // value, so remove it first.
   prefs_->Remove(path, NULL);
 
   // Find the first extension that wants to set this pref and use its value.
+  Value* my_new_value = NULL;
   for (ExtensionStack::iterator ext_iter = extension_stack_.begin();
         ext_iter != extension_stack_.end(); ++ext_iter) {
     PrefValueMap::iterator value_iter = (*ext_iter)->pref_values->find(path);
     if (value_iter != (*ext_iter)->pref_values->end()) {
       prefs_->Set(path, (*value_iter).second->DeepCopy());
+      my_new_value = (*value_iter).second;
       break;
     }
   }
 
   if (pref_service) {
-    pref_service->pref_notifier()->OnPreferenceSet(
-        path, type_, old_value.get());
+    bool value_changed = true;
+    if (!my_old_value.get() && !my_new_value) {
+      value_changed = false;
+    } else if (my_old_value.get() &&
+               my_new_value &&
+               my_old_value->Equals(my_new_value)) {
+      value_changed = false;
+    }
+
+    if (value_changed)
+      pref_service->pref_notifier()->OnPreferenceSet(path, type_);
   }
 }
 
 void ExtensionPrefStore::UpdatePrefs(const PrefValueMap* pref_values) {
   if (!pref_values)
     return;
 
   for (PrefValueMap::const_iterator i = pref_values->begin();
         i != pref_values->end(); ++i) {
     UpdateOnePref(i->first);
@@ skipping 45 matching lines @@
   }
 }
 
 ExtensionPrefStore::ExtensionPrefs::ExtensionPrefs(Extension* extension,
     PrefValueMap* values) : extension(extension), pref_values(values) {}
 
 ExtensionPrefStore::ExtensionPrefs::~ExtensionPrefs() {
   STLDeleteValues(pref_values);
   delete pref_values;
 }