Split PrefService into PrefService, PrefServiceSimple and PrefServiceSyncable.

chrome/browser/sync/sync_prefs.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/sync/sync_prefs.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 namespace browser_sync {
 
 SyncPrefObserver::~SyncPrefObserver() {}
 
-SyncPrefs::SyncPrefs(PrefService* pref_service)
+SyncPrefs::SyncPrefs(PrefServiceSyncable* pref_service)
     : pref_service_(pref_service) {
   RegisterPrefGroups();
   // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case
   // throughout this file.  This is a problem now due to lack of injection at
   // ProfileSyncService. Bug 130176.
   if (pref_service_) {
     RegisterPreferences();
     // Watch the preference that indicates sync is managed so we can take
     // appropriate action.
     pref_sync_managed_.Init(prefs::kSyncManaged, pref_service_,
@@ skipping 268 matching lines @@
   pref_groups_[syncer::SESSIONS].Put(syncer::HISTORY_DELETE_DIRECTIVES);
 }
 
 void SyncPrefs::RegisterPreferences() {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   if (pref_service_->FindPreference(prefs::kSyncLastSyncedTime)) {
     return;
   }
 
+  // TODO(joi): Switch to official way of registering user prefs for
+  // this class, i.e. in a function called from
+  // browser_prefs::RegisterUserPrefs.
   pref_service_->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
                                      false,
-                                     PrefService::UNSYNCABLE_PREF);
+                                     PrefServiceSyncable::UNSYNCABLE_PREF);
   pref_service_->RegisterBooleanPref(prefs::kSyncSuppressStart,
                                      false,
-                                     PrefService::UNSYNCABLE_PREF);
+                                     PrefServiceSyncable::UNSYNCABLE_PREF);
   pref_service_->RegisterInt64Pref(prefs::kSyncLastSyncedTime,
                                    0,
-                                   PrefService::UNSYNCABLE_PREF);
+                                   PrefServiceSyncable::UNSYNCABLE_PREF);
 
   // If you've never synced before, or if you're using Chrome OS or Android,
   // all datatypes are on by default.
   // TODO(nick): Perhaps a better model would be to always default to false,
   // and explicitly call SetDataTypes() when the user shows the wizard.
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   bool enable_by_default = true;
 #else
   bool enable_by_default =
       !pref_service_->HasPrefPath(prefs::kSyncHasSetupCompleted);
 #endif
 
   pref_service_->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced,
                                      enable_by_default,
-                                     PrefService::UNSYNCABLE_PREF);
+                                     PrefServiceSyncable::UNSYNCABLE_PREF);
 
   syncer::ModelTypeSet user_types = syncer::UserTypes();
 
   // Treat bookmarks specially.
   RegisterDataTypePreferredPref(syncer::BOOKMARKS, true);
   user_types.Remove(syncer::BOOKMARKS);
 
   for (syncer::ModelTypeSet::Iterator it = user_types.First();
        it.Good(); it.Inc()) {
     RegisterDataTypePreferredPref(it.Get(), enable_by_default);
   }
 
   pref_service_->RegisterBooleanPref(prefs::kSyncManaged,
                                      false,
-                                     PrefService::UNSYNCABLE_PREF);
+                                     PrefServiceSyncable::UNSYNCABLE_PREF);
   pref_service_->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
                                     "",
-                                    PrefService::UNSYNCABLE_PREF);
+                                    PrefServiceSyncable::UNSYNCABLE_PREF);
   pref_service_->RegisterStringPref(
       prefs::kSyncKeystoreEncryptionBootstrapToken,
       "",
-      PrefService::UNSYNCABLE_PREF);
+      PrefServiceSyncable::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
   pref_service_->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
                                     "",
-                                    PrefService::UNSYNCABLE_PREF);
+                                    PrefServiceSyncable::UNSYNCABLE_PREF);
 #endif
 
   // We will start prompting people about new data types after the launch of
   // SESSIONS - all previously launched data types are treated as if they are
   // already acknowledged.
   syncer::ModelTypeSet model_set;
   model_set.Put(syncer::BOOKMARKS);
   model_set.Put(syncer::PREFERENCES);
   model_set.Put(syncer::PASSWORDS);
   model_set.Put(syncer::AUTOFILL_PROFILE);
   model_set.Put(syncer::AUTOFILL);
   model_set.Put(syncer::THEMES);
   model_set.Put(syncer::EXTENSIONS);
   model_set.Put(syncer::NIGORI);
   model_set.Put(syncer::SEARCH_ENGINES);
   model_set.Put(syncer::APPS);
   model_set.Put(syncer::TYPED_URLS);
   model_set.Put(syncer::SESSIONS);
   pref_service_->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
                                   syncer::ModelTypeSetToValue(model_set),
-                                  PrefService::UNSYNCABLE_PREF);
+                                  PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 void SyncPrefs::RegisterDataTypePreferredPref(syncer::ModelType type,
                                               bool is_preferred) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
   pref_service_->RegisterBooleanPref(pref_name, is_preferred,
-                                     PrefService::UNSYNCABLE_PREF);
+                                     PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 bool SyncPrefs::GetDataTypePreferred(syncer::ModelType type) const {
   DCHECK(CalledOnValidThread());
   if (!pref_service_) {
     return false;
   }
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
@@ skipping 25 matching lines @@
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
     else
       types_with_groups.RemoveAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync