1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef COMPONENTS_USER_PREFS_PREF_REGISTRY_SYNCABLE_H_ 6 #define COMPONENTS_USER_PREFS_PREF_REGISTRY_SYNCABLE_H_ 7 8 #include <set> 9 #include <string> 10 11 #include "base/callback.h" 12 #include "base/prefs/pref_registry.h" 13 #include "components/user_prefs/user_prefs_export.h" 14 15 namespace base { 16 class DictionaryValue; 17 class FilePath; 18 class ListValue; 19 class Value; 20 } 21 22 namespace user_prefs { 23 24 // A PrefRegistry that forces users to choose whether each registered 25 // preference is syncable or not. 26 // 27 // Classes or components that want to register such preferences should 28 // define a static function named RegisterUserPrefs that takes a 29 // PrefRegistrySyncable*, and the top-level application using the 30 // class or embedding the component should call this function at an 31 // appropriate time before the PrefService for these preferences is 32 // constructed. See e.g. chrome/browser/prefs/browser_prefs.cc which 33 // does this for Chrome. 34 class USER_PREFS_EXPORT PrefRegistrySyncable : public PrefRegistry { 35 public: 36 // Enum used when registering preferences to determine if it should 37 // be synced or not. Syncable priority preferences are preferences that are 38 // never encrypted and are synced before other datatypes. Because they're 39 // never encrypted, on first sync, they can be synced down before the user 40 // is prompted for a passphrase. 41 enum PrefSyncStatus { 42 UNSYNCABLE_PREF, 43 SYNCABLE_PREF, 44 SYNCABLE_PRIORITY_PREF, 45 }; 46 47 typedef 48 base::Callback<void(const char* path, const PrefSyncStatus sync_status)> 49 SyncableRegistrationCallback; 50 51 PrefRegistrySyncable(); 52 53 typedef std::map<std::string, PrefSyncStatus> PrefToStatus; 54 55 // Retrieve the set of syncable preferences currently registered. 56 const PrefToStatus& syncable_preferences() const; 57 58 // Exactly one callback can be set for the event of a syncable 59 // preference being registered. It will be fired after the 60 // registration has occurred. 61 // 62 // Calling this method after a callback has already been set will 63 // make the object forget the previous callback and use the new one 64 // instead. 65 void SetSyncableRegistrationCallback(const SyncableRegistrationCallback& cb); 66 67 void RegisterBooleanPref(const char* path, 68 bool default_value, 69 PrefSyncStatus sync_status); 70 void RegisterIntegerPref(const char* path, 71 int default_value, 72 PrefSyncStatus sync_status); 73 void RegisterDoublePref(const char* path, 74 double default_value, 75 PrefSyncStatus sync_status); 76 void RegisterStringPref(const char* path, 77 const std::string& default_value, 78 PrefSyncStatus sync_status); 79 void RegisterFilePathPref(const char* path, 80 const base::FilePath& default_value, 81 PrefSyncStatus sync_status); 82 void RegisterListPref(const char* path, 83 PrefSyncStatus sync_status); 84 void RegisterDictionaryPref(const char* path, 85 PrefSyncStatus sync_status); 86 void RegisterListPref(const char* path, 87 base::ListValue* default_value, 88 PrefSyncStatus sync_status); 89 void RegisterDictionaryPref(const char* path, 90 base::DictionaryValue* default_value, 91 PrefSyncStatus sync_status); 92 void RegisterLocalizedBooleanPref(const char* path, 93 int locale_default_message_id, 94 PrefSyncStatus sync_status); 95 void RegisterLocalizedIntegerPref(const char* path, 96 int locale_default_message_id, 97 PrefSyncStatus sync_status); 98 void RegisterLocalizedDoublePref(const char* path, 99 int locale_default_message_id, 100 PrefSyncStatus sync_status); 101 void RegisterLocalizedStringPref(const char* path, 102 int locale_default_message_id, 103 PrefSyncStatus sync_status); 104 void RegisterInt64Pref(const char* path, 105 int64 default_value, 106 PrefSyncStatus sync_status); 107 void RegisterUint64Pref(const char* path, 108 uint64 default_value, 109 PrefSyncStatus sync_status); 110 111 // Returns a new PrefRegistrySyncable that uses the same defaults 112 // store. 113 scoped_refptr<PrefRegistrySyncable> ForkForIncognito(); 114 115 private: 116 virtual ~PrefRegistrySyncable(); 117 118 void RegisterSyncablePreference(const char* path, 119 base::Value* default_value, 120 PrefSyncStatus sync_status); 121 122 SyncableRegistrationCallback callback_; 123 124 // Contains the names of all registered preferences that are syncable. 125 PrefToStatus syncable_preferences_; 126 127 DISALLOW_COPY_AND_ASSIGN(PrefRegistrySyncable); 128 }; 129 130 } // namespace user_prefs 131 132 #endif // COMPONENTS_USER_PREFS_PREF_REGISTRY_SYNCABLE_H_ 133