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"
@@ skipping 49 matching lines @@
   NOTREACHED();
   return Value::CreateNullValue();
 }
 
 }  // namespace
 
 PrefServiceSyncable::PrefServiceSyncable(
     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)
   : PrefService(pref_notifier,
                 pref_value_store,
                 user_prefs,
-                default_store,
+                pref_registry.Pass(),
                 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());
+  // TODO(joi): Temporary until we have a PrefRegistrySyncable.
+  PrefRegistry* dummy_registry = new PrefRegistry;
+  dummy_registry->default_prefs_ = default_store_;

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

shouldn't the two stores share the same registry?

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

Done.

   PrefsTabHelper::InitIncognitoUserPrefStore(incognito_pref_store);
   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(),
           pref_notifier),
       incognito_pref_store,
-      default_store_.get(),
+      make_scoped_ptr(dummy_registry),
       read_error_callback_,
       false);
   return incognito_service;
 }
 
 bool PrefServiceSyncable::IsSyncing() {
   return pref_sync_associator_.models_associated();
 }
 
 void PrefServiceSyncable::AddObserver(PrefServiceSyncableObserver* observer) {
@@ skipping 139 matching lines @@
 }
 
 void PrefServiceSyncable::UpdateCommandLinePrefStore(
     PrefStore* cmd_line_store) {
   // If |pref_service_forked_| is true, then this PrefService and the forked
   // copies will be out of sync.
   DCHECK(!pref_service_forked_);
   PrefService::UpdateCommandLinePrefStore(cmd_line_store);
 }
 
+bool PrefServiceSyncable::AllowPrefRegistrarSimple() const {
+  return false;
+}
+
 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);
+  PrefService::RegisterPreference(path, default_value, false);
   // Register with sync if necessary.
   if (sync_status == SYNCABLE_PREF)
     pref_sync_associator_.RegisterPref(path);
 }