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,
+    scoped_ptr<PrefRegistry> pref_registry,
     base::Callback<void(PersistentPrefStore::PrefReadError)>
         read_error_callback,
     bool async)
     : pref_notifier_(pref_notifier),
       pref_value_store_(pref_value_store),
       user_pref_store_(user_prefs),
-      default_store_(default_store),
-      read_error_callback_(read_error_callback) {
+      read_error_callback_(read_error_callback),
+      pref_registry_(pref_registry.Pass()) {
   pref_notifier_->SetPrefService(this);
+
+  pref_registry_->RetrieveDefaults(&default_store_);
+  pref_registry_->pref_service_ = this;
+  RegisterInitialPreferences();
+
   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;
@@ skipping 227 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);
 }
 
+PrefRegistry* PrefService::DeprecatedGetPrefRegistry() const {
+  return pref_registry_.get();
+}
+
+void PrefService::RegisterInitialPreferences() {
+  // Invariant: default_store_ is valid and contains the preferences
+  // registered prior to construction time.
+  for (DefaultPrefStore::const_iterator it = default_store_->begin();
+       it != default_store_->end();
+       ++it) {
+    RegisterPreference(it->first.c_str(), it->second, true);
+  }
+}
+
+// TODO(joi): Once all registration is done before the PrefService is
+// constructed, we can stop exposing a separate RegisterPreference
+// method, and we can simplify the registration logic. Possibly at the
+// same point we can remove UnregisterPreference. For now, because a
+// few remaining places register preferences after PrefService
+// construction, it is better to leave this here and have PrefRegistry
+// delegate to PrefService::RegisterPreference after that
+// point. Otherwise, PrefRegistry would need to control PrefService's
+// default_store_ and user_pref_store_ members, as well as the
+// pref_map_ member for UnregisterPreference.

[Mattias Nissler (ping if slow), 2013/01/25 14:57:11]

The default_store_ it controls already! The user_pref_store_ piece is
unfortunate and the whole MarkNeedsEmptyValue thing seems like a big hack to me.
I just looked at the CL that added it, and I think the proper way of handling
this would have been to fix JsonPrefStore to never discard prefs that are set,
even if empty. I'll think a bit more about this and see whether there's a good
way to get rid of PersistentPrefStore::MarkNeedsEmptyValue().

[Jói, 2013/01/29 16:10:02]

Registration is now fully owned by PrefRegistry. PrefService registers for
registration and unregistration callbacks to update its internal caches when
registration is done after construction time, and on unregistration.

+//
+// We are, however, able to implement the interface we desire in the
+// long term on PrefRegistry, and make this relationship an
+// implementation detail.
 void PrefService::RegisterPreference(const char* path,
-                                     Value* default_value) {
+                                     Value* default_value,
+                                     bool in_default_store) {
   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;
 
   // 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;
   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());
+  if (!in_default_store) {
+    // Hand off ownership.
+    default_store_->SetDefaultValue(path, scoped_value.release());
+  }
 }
 
 void PrefService::UnregisterPreference(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);
 }
 
+bool PrefService::AllowPrefRegistrarSimple() const {
+  return true;
+}
+
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
   user_pref_store_->RemoveValue(path);
 }
@@ skipping 209 matching lines @@
   const Value* found_value = NULL;
   if (pref_value_store_->GetValue(path, type, &found_value)) {
     DCHECK(found_value->IsType(type));
     return found_value;
   }
 
   // Every registered preference has at least a default value.
   NOTREACHED() << "no valid value found for registered pref " << path;
   return NULL;
 }