Remove PrefServiceSimple, replacing it with PrefService and PrefRegistrySimple.

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2012 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/prefs/pref_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/default_pref_store.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/value_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/prefs/pref_notifier_impl.h"
+#include "chrome/browser/prefs/pref_registry.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 
 using content::BrowserContext;
 
 namespace {
 
 class ReadErrorHandler : public PersistentPrefStore::ReadErrorDelegate {
  public:
   ReadErrorHandler(base::Callback<void(PersistentPrefStore::PrefReadError)> cb)
       : callback_(cb) {}
 
   virtual void OnError(PersistentPrefStore::PrefReadError error) {
     callback_.Run(error);
   }
 
  private:
   base::Callback<void(PersistentPrefStore::PrefReadError)> callback_;
 };
 
 }  // namespace
 
 PrefService::PrefService(
     PrefNotifierImpl* pref_notifier,
     PrefValueStore* pref_value_store,
     PersistentPrefStore* user_prefs,
-    DefaultPrefStore* default_store,
+    PrefRegistry* pref_registry,
     base::Callback<void(PersistentPrefStore::PrefReadError)>
         read_error_callback,
     bool async)
     : pref_notifier_(pref_notifier),
       pref_value_store_(pref_value_store),
+      pref_registry_(pref_registry),
       user_pref_store_(user_prefs),
-      default_store_(default_store),
-      read_error_callback_(read_error_callback) {
+      read_error_callback_(read_error_callback),
+      weak_ptr_factory_(this) {
   pref_notifier_->SetPrefService(this);
+
+  pref_registry_->SetRegistrationCallback(
+      base::Bind(&PrefService::AddRegisteredPreference,
+                 weak_ptr_factory_.GetWeakPtr()));

[Mattias Nissler (ping if slow), 2013/01/29 18:10:45]

Do we need the weak_ptr_factory_ here? We hold a references to pref_registry_,
so base::Unretained() should work as long as you reset the callbacks on
destruction.

[Jói, 2013/01/30 14:23:33]

That would be the alternative. Seems a bit cleaner, I've switched to that.

+  pref_registry_->SetUnregistrationCallback(
+      base::Bind(&PrefService::RemoveRegisteredPreference,
+                 weak_ptr_factory_.GetWeakPtr()));

[Mattias Nissler (ping if slow), 2013/01/29 18:10:45]

So this will break if we're ever passing a registry to several PrefService
instances (which we might do for incognito?)

[Jói, 2013/01/30 14:23:33]

Yes, which is why I used the approach you see in pref_service_syncable.cc for
the incognito PrefService.

+  AddInitialPreferences();
+
   InitFromStorage(async);
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
 
   // Reset pointers so accesses after destruction reliably crash.
   pref_value_store_.reset();
   user_pref_store_ = NULL;
-  default_store_ = NULL;
   pref_notifier_.reset();
 }
 
 void PrefService::InitFromStorage(bool async) {
   if (!async) {
     read_error_callback_.Run(user_pref_store_->ReadPrefs());
   } else {
     // Guarantee that initialization happens after this function returned.
     MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 89 matching lines @@
 }
 
 bool PrefService::HasPrefPath(const char* path) const {
   const Preference* pref = FindPreference(path);
   return pref && !pref->IsDefaultValue();
 }
 
 DictionaryValue* PrefService::GetPreferenceValues() const {
   DCHECK(CalledOnValidThread());
   DictionaryValue* out = new DictionaryValue;
-  DefaultPrefStore::const_iterator i = default_store_->begin();
-  for (; i != default_store_->end(); ++i) {
+  PrefRegistry::const_iterator i = pref_registry_->begin();
+  for (; i != pref_registry_->end(); ++i) {
     const Value* value = GetPreferenceValue(i->first);
     DCHECK(value);
     out->Set(i->first, value->DeepCopy());
   }
   return out;
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
   PreferenceMap::iterator it = prefs_map_.find(pref_name);
   if (it != prefs_map_.end())
     return &(it->second);
-  const base::Value::Type type = default_store_->GetType(pref_name);
-  if (type == Value::TYPE_NULL)
+  const base::Value* default_value = NULL;
+  if (!pref_registry_->defaults()->GetValue(pref_name, &default_value))
     return NULL;
   it = prefs_map_.insert(
-      std::make_pair(pref_name, Preference(this, pref_name, type))).first;
+      std::make_pair(pref_name, Preference(
+          this, pref_name, default_value->GetType()))).first;
   return &(it->second);
 }
 
 bool PrefService::ReadOnly() const {
   return user_pref_store_->ReadOnly();
 }
 
 PrefService::PrefInitializationStatus PrefService::GetInitializationStatus()
     const {
   if (!user_pref_store_->IsInitializationComplete())
@@ skipping 54 matching lines @@
     return NULL;
   }
 
   return value;
 }
 
 const base::Value* PrefService::GetDefaultPrefValue(const char* path) const {
   DCHECK(CalledOnValidThread());
   // Lookup the preference in the default store.
   const base::Value* value = NULL;
-  if (!default_store_->GetValue(path, &value)) {
+  if (!pref_registry_->defaults()->GetValue(path, &value)) {
     NOTREACHED() << "Default value missing for pref: " << path;
     return NULL;
   }
   return value;
 }
 
 const ListValue* PrefService::GetList(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   const Value* value = GetPreferenceValue(path);
@@ skipping 13 matching lines @@
 }
 
 void PrefService::RemovePrefObserver(const char* path, PrefObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
 
 void PrefService::AddPrefInitObserver(base::Callback<void(bool)> obs) {
   pref_notifier_->AddInitObserver(obs);
 }
 
-void PrefService::RegisterPreference(const char* path,
-                                     Value* default_value) {
+PrefRegistry* PrefService::DeprecatedGetPrefRegistry() {
+  return pref_registry_.get();
+}
+
+void PrefService::AddInitialPreferences() {
+  for (PrefRegistry::const_iterator it = pref_registry_->begin();
+       it != pref_registry_->end();
+       ++it) {
+    AddRegisteredPreference(it->first.c_str(), it->second);
+  }
+}
+
+// TODO(joi): Once MarkNeedsEmptyValue is gone, we can probably
+// completely get rid of this method. There will be one difference in
+// semantics; currently all registered preferences are stored right
+// away in the prefs_map_, if we remove this they would be stored only
+// opportunistically.
+void PrefService::AddRegisteredPreference(const char* path,
+                                          Value* default_value) {
   DCHECK(CalledOnValidThread());
 
-  // The main code path takes ownership, but most don't. We'll be safe.
-  scoped_ptr<Value> scoped_value(default_value);
-
-  CHECK(!FindPreference(path)) << "Tried to register duplicate pref " << path;
-
-  base::Value::Type orig_type = default_value->GetType();
-  DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
-         "invalid preference type: " << orig_type;
+  // Calling FindPreference here has the side-effect of updating the
+  // pref_map_ cache, so all preferences are immediately in the cache.
+  bool already_registered = FindPreference(path);
+  CHECK(!already_registered) << "Tried to register duplicate pref " << path;
 
   // For ListValue and DictionaryValue with non empty default, empty value
   // for |path| needs to be persisted in |user_pref_store_|. So that
   // non empty default is not used when user sets an empty ListValue or
   // DictionaryValue.
   bool needs_empty_value = false;
+  base::Value::Type orig_type = default_value->GetType();
   if (orig_type == base::Value::TYPE_LIST) {
     const base::ListValue* list = NULL;
     if (default_value->GetAsList(&list) && !list->empty())
       needs_empty_value = true;
   } else if (orig_type == base::Value::TYPE_DICTIONARY) {
     const base::DictionaryValue* dict = NULL;
     if (default_value->GetAsDictionary(&dict) && !dict->empty())
       needs_empty_value = true;
   }
   if (needs_empty_value)
     user_pref_store_->MarkNeedsEmptyValue(path);
-
-  // Hand off ownership.
-  default_store_->SetDefaultValue(path, scoped_value.release());
 }
 
-void PrefService::UnregisterPreference(const char* path) {
+// TODO(joi): We can get rid of this once the ability to unregister
+// prefs has been removed.
+void PrefService::RemoveRegisteredPreference(const char* path) {
   DCHECK(CalledOnValidThread());
 
-  PreferenceMap::iterator it = prefs_map_.find(path);
-  CHECK(it != prefs_map_.end()) << "Trying to unregister an unregistered pref: "
-                                << path;
-
-  prefs_map_.erase(it);
-  default_store_->RemoveDefaultValue(path);
+  prefs_map_.erase(path);
 }
 
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
@@ skipping 198 matching lines @@
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }
 
 const base::Value* PrefService::GetPreferenceValue(
     const std::string& path) const {
   DCHECK(CalledOnValidThread());
-  const base::Value::Type type = default_store_->GetType(path);
-  if (type == Value::TYPE_NULL)
-    return NULL;
-  const Value* found_value = NULL;
-  if (pref_value_store_->GetValue(path, type, &found_value)) {
-    DCHECK(found_value->IsType(type));
-    return found_value;
+  const Value* default_value = NULL;
+  if (pref_registry_->defaults()->GetValue(path, &default_value)) {
+    const Value* found_value = NULL;
+    base::Value::Type default_type = default_value->GetType();
+    if (pref_value_store_->GetValue(path, default_type, &found_value)) {
+      DCHECK(found_value->IsType(default_type));
+      return found_value;
+    } else {
+      // Every registered preference has at least a default value.
+      NOTREACHED() << "no valid value found for registered pref " << path;
+    }
   }
 
-  // Every registered preference has at least a default value.
-  NOTREACHED() << "no valid value found for registered pref " << path;
   return NULL;
 }