Remove PrefServiceSimple, replacing it with PrefService and PrefRegistrySimple.

chrome/browser/prefs/pref_service_syncable.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_syncable.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/prefs/default_pref_store.h"
 #include "base/prefs/overlay_user_pref_store.h"
 #include "base/string_number_conversions.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/pref_notifier_impl.h"
+#include "chrome/browser/prefs/pref_registry.h"
+#include "chrome/browser/prefs/pref_registry_simple.h"
 #include "chrome/browser/prefs/pref_service_syncable_observer.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/ui/prefs/prefs_tab_helper.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // A helper function for RegisterLocalized*Pref that creates a Value*
 // based on a localized resource.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate
@@ skipping 35 matching lines @@
   NOTREACHED();
   return Value::CreateNullValue();
 }
 
 }  // namespace
 
 PrefServiceSyncable::PrefServiceSyncable(
     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)
   : PrefService(pref_notifier,
                 pref_value_store,
                 user_prefs,
-                default_store,
+                pref_registry,
                 read_error_callback,
                 async) {
   pref_sync_associator_.SetPrefService(this);
 
   pref_value_store->set_callback(
       base::Bind(&PrefModelAssociator::ProcessPrefChange,
                  base::Unretained(&pref_sync_associator_)));
 }
 
 PrefServiceSyncable::~PrefServiceSyncable() {}
 
 PrefServiceSyncable* PrefServiceSyncable::CreateIncognitoPrefService(
     PrefStore* incognito_extension_prefs) {
   pref_service_forked_ = true;
   PrefNotifierImpl* pref_notifier = new PrefNotifierImpl();
   OverlayUserPrefStore* incognito_pref_store =
       new OverlayUserPrefStore(user_pref_store_.get());
   PrefsTabHelper::InitIncognitoUserPrefStore(incognito_pref_store);
+
+  // For the incognito service, we need a registry that shares the
+  // same default prefs, but does not interfere with callbacks on
+  // registration/unregistration made to the main service, or allow
+  // any registrations.

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

I understand we are intending to remove the callbacks eventually? If so, can we
have a TODO here saying that this can go away once the callbacks are gone?

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

Done.

+  scoped_refptr<PrefRegistry> incognito_registry = new PrefRegistry;
+  incognito_registry->defaults_ = pref_registry_->defaults_;
+
   PrefServiceSyncable* incognito_service = new PrefServiceSyncable(
       pref_notifier,
       pref_value_store_->CloneAndSpecialize(
           NULL,  // managed
           incognito_extension_prefs,
           NULL,  // command_line_prefs
           incognito_pref_store,
           NULL,  // recommended
-          default_store_.get(),
+          incognito_registry->defaults(),
           pref_notifier),
       incognito_pref_store,
-      default_store_.get(),
+      incognito_registry,
       read_error_callback_,
       false);
   return incognito_service;
 }
 
 bool PrefServiceSyncable::IsSyncing() {
   return pref_sync_associator_.models_associated();
 }
 
 void PrefServiceSyncable::AddObserver(PrefServiceSyncableObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void PrefServiceSyncable::RemoveObserver(
     PrefServiceSyncableObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void PrefServiceSyncable::UnregisterPreference(const char* path) {
-  PrefService::UnregisterPreference(path);
+  // TODO(joi): Temporary until we have PrefRegistrySyncable.
+  static_cast<PrefRegistrySimple*>(
+      DeprecatedGetPrefRegistry())->DeprecatedUnregisterPreference(path);
+
   if (pref_sync_associator_.IsPrefRegistered(path)) {
     pref_sync_associator_.UnregisterPref(path);
   }
 }
 
 void PrefServiceSyncable::RegisterBooleanPref(const char* path,
                                               bool default_value,
                                               PrefSyncStatus sync_status) {
   RegisterSyncablePreference(path,
                              Value::CreateBooleanValue(default_value),
@@ skipping 126 matching lines @@
   PrefService::UpdateCommandLinePrefStore(cmd_line_store);
 }
 
 void PrefServiceSyncable::OnIsSyncingChanged() {
   FOR_EACH_OBSERVER(PrefServiceSyncableObserver, observer_list_,
                     OnIsSyncingChanged());
 }
 
 void PrefServiceSyncable::RegisterSyncablePreference(
     const char* path, Value* default_value, PrefSyncStatus sync_status) {
-  PrefService::RegisterPreference(path, default_value);
+  // TODO(joi): Temporary until we have PrefRegistrySyncable.
+  static_cast<PrefRegistrySimple*>(
+      DeprecatedGetPrefRegistry())->RegisterPreference(path, default_value);
   // Register with sync if necessary.
   if (sync_status == SYNCABLE_PREF)
     pref_sync_associator_.RegisterPref(path);
 }