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