chrome/browser/supervised_user/supervised_user_shared_settings_service.h

   1 // Copyright 2014 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 CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_
   6 #define CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_
   7
   8 #include "base/callback.h"
   9 #include "base/callback_list.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "chrome/browser/supervised_user/supervised_users.h"
  12 #include "components/keyed_service/core/keyed_service.h"
  13 #include "sync/api/syncable_service.h"
  14
  15 class PrefService;
  16
  17 namespace base {
  18 class DictionaryValue;
  19 class Value;
  20 }
  21
  22 namespace user_prefs {
  23 class PrefRegistrySyncable;
  24 }
  25
  26 // SupervisedUserSharedSettingsService syncs settings (as key-value pairs) that
  27 // can be modified both by a supervised user and their manager.
  28 // A supervised user can only modify their own settings, whereas a manager can
  29 // modify settings for all their supervised users.
  30 //
  31 // The shared settings are stored in the user preferences in a multi-level
  32 // dictionary. The first level is the SU ID (called "managed user ID" on the
  33 // server for historic reasons), the second level is the key for the setting,
  34 // and the third level is a dictionary with a "value" key for the value and an
  35 // "acknowledged" flag, which is used to wait for the Sync server to acknowledge
  36 // that it has seen a setting change (see SupervisedUserSharedSettingsUpdate for
  37 // how to use this).
  38 class SupervisedUserSharedSettingsService : public KeyedService,
  39                                             public syncer::SyncableService {
  40  public:
  41   // Called whenever a setting changes (see Subscribe() below).
  42   typedef base::Callback<void(const std::string& /* su_id */,
  43                               const std::string& /* key */)> ChangeCallback;
  44   typedef base::CallbackList<
  45       void(const std::string& /* su_id */, const std::string& /* key */)>
  46       ChangeCallbackList;
  47
  48   // This constructor is public only for testing. Use
  49   // |SupervisedUserSharedSettingsServiceFactory::GetForProfile(...)| instead to
  50   // get an instance of this service in production code.
  51   explicit SupervisedUserSharedSettingsService(PrefService* prefs);
  52   virtual ~SupervisedUserSharedSettingsService();
  53
  54   // Returns the value for the given |key| and the supervised user identified by
  55   // |su_id|. If either the supervised user or the key does not exist, NULL is
  56   // returned. Note that if the profile that owns this service belongs to a
  57   // supervised user, callers will only see settings for their own |su_id|, i.e.
  58   // a non-matching |su_id| is treated as non-existent.
  59   const base::Value* GetValue(const std::string& su_id, const std::string& key);
  60
  61   // Sets the value for the given |key| and the supervised user identified by
  62   // |su_id|. If the profile that owns this service belongs to a supervised
  63   // user, |su_id| must be their own.
  64   void SetValue(const std::string& su_id,
  65                 const std::string& key,
  66                 const base::Value& value);
  67
  68   // Subscribes to changes in the synced settings. The callback will be notified
  69   // whenever any setting for any supervised user is changed via Sync (but not
  70   // for local changes). Subscribers should filter the settings and users they
  71   // are interested in with the |su_id| and |key| parameters to the callback.
  72   scoped_ptr<ChangeCallbackList::Subscription> Subscribe(
  73       const ChangeCallback& cb);
  74
  75   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
  76
  77   // Public for testing.
  78   void SetValueInternal(const std::string& su_id,
  79                         const std::string& key,
  80                         const base::Value& value,
  81                         bool acknowledged);
  82
  83   // Public for testing.
  84   static syncer::SyncData CreateSyncDataForSetting(const std::string& su_id,
  85                                                    const std::string& key,
  86                                                    const base::Value& value,
  87                                                    bool acknowledged);
  88
  89   // KeyedService implementation:
  90   virtual void Shutdown() OVERRIDE;
  91
  92   // SyncableService implementation:
  93   virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
  94       syncer::ModelType type,
  95       const syncer::SyncDataList& initial_sync_data,
  96       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
  97       scoped_ptr<syncer::SyncErrorFactory> error_handler) OVERRIDE;
  98   virtual void StopSyncing(syncer::ModelType type) OVERRIDE;
  99   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
 100       OVERRIDE;
 101   virtual syncer::SyncError ProcessSyncChanges(
 102       const tracked_objects::Location& from_here,
 103       const syncer::SyncChangeList& change_list) OVERRIDE;
 104
 105  private:
 106   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
 107   scoped_ptr<syncer::SyncErrorFactory> error_handler_;
 108
 109   ChangeCallbackList callbacks_;
 110
 111   PrefService* prefs_;
 112 };
 113
 114 #endif  // CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_