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