| // Copyright 2014 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. |
| |
| #ifndef CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_ |
| #define CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_ |
| |
| #include <string> |
| |
| #include "base/callback.h" |
| #include "base/callback_list.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "chrome/browser/supervised_user/supervised_users.h" |
| #include "components/keyed_service/core/keyed_service.h" |
| #include "sync/api/syncable_service.h" |
| |
| class PrefService; |
| |
| namespace base { |
| class DictionaryValue; |
| class Value; |
| } |
| |
| namespace user_prefs { |
| class PrefRegistrySyncable; |
| } |
| |
| // SupervisedUserSharedSettingsService syncs settings (as key-value pairs) that |
| // can be modified both by a supervised user and their manager. |
| // A supervised user can only modify their own settings, whereas a manager can |
| // modify settings for all their supervised users. |
| // |
| // The shared settings are stored in the user preferences in a multi-level |
| // dictionary. The first level is the SU ID (called "managed user ID" on the |
| // server for historic reasons), the second level is the key for the setting, |
| // and the third level is a dictionary with a "value" key for the value and an |
| // "acknowledged" flag, which is used to wait for the Sync server to acknowledge |
| // that it has seen a setting change (see SupervisedUserSharedSettingsUpdate for |
| // how to use this). |
| class SupervisedUserSharedSettingsService : public KeyedService, |
| public syncer::SyncableService { |
| public: |
| // Called whenever a setting changes (see Subscribe() below). |
| typedef base::Callback<void(const std::string& /* su_id */, |
| const std::string& /* key */)> ChangeCallback; |
| typedef base::CallbackList< |
| void(const std::string& /* su_id */, const std::string& /* key */)> |
| ChangeCallbackList; |
| |
| // This constructor is public only for testing. Use |
| // |SupervisedUserSharedSettingsServiceFactory::GetForProfile(...)| instead to |
| // get an instance of this service in production code. |
| explicit SupervisedUserSharedSettingsService(PrefService* prefs); |
| virtual ~SupervisedUserSharedSettingsService(); |
| |
| // Returns the value for the given |key| and the supervised user identified by |
| // |su_id|. If either the supervised user or the key does not exist, NULL is |
| // returned. Note that if the profile that owns this service belongs to a |
| // supervised user, callers will only see settings for their own |su_id|, i.e. |
| // a non-matching |su_id| is treated as non-existent. |
| const base::Value* GetValue(const std::string& su_id, const std::string& key); |
| |
| // Sets the value for the given |key| and the supervised user identified by |
| // |su_id|. If the profile that owns this service belongs to a supervised |
| // user, |su_id| must be their own. |
| void SetValue(const std::string& su_id, |
| const std::string& key, |
| const base::Value& value); |
| |
| // Subscribes to changes in the synced settings. The callback will be notified |
| // whenever any setting for any supervised user is changed via Sync (but not |
| // for local changes). Subscribers should filter the settings and users they |
| // are interested in with the |su_id| and |key| parameters to the callback. |
| scoped_ptr<ChangeCallbackList::Subscription> Subscribe( |
| const ChangeCallback& cb); |
| |
| static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry); |
| |
| // Public for testing. |
| void SetValueInternal(const std::string& su_id, |
| const std::string& key, |
| const base::Value& value, |
| bool acknowledged); |
| |
| // Public for testing. |
| static syncer::SyncData CreateSyncDataForSetting(const std::string& su_id, |
| const std::string& key, |
| const base::Value& value, |
| bool acknowledged); |
| |
| // KeyedService implementation: |
| virtual void Shutdown() override; |
| |
| // SyncableService implementation: |
| virtual syncer::SyncMergeResult MergeDataAndStartSyncing( |
| syncer::ModelType type, |
| const syncer::SyncDataList& initial_sync_data, |
| scoped_ptr<syncer::SyncChangeProcessor> sync_processor, |
| scoped_ptr<syncer::SyncErrorFactory> error_handler) override; |
| virtual void StopSyncing(syncer::ModelType type) override; |
| virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const |
| override; |
| virtual syncer::SyncError ProcessSyncChanges( |
| const tracked_objects::Location& from_here, |
| const syncer::SyncChangeList& change_list) override; |
| |
| private: |
| scoped_ptr<syncer::SyncChangeProcessor> sync_processor_; |
| scoped_ptr<syncer::SyncErrorFactory> error_handler_; |
| |
| ChangeCallbackList callbacks_; |
| |
| PrefService* prefs_; |
| }; |
| |
| #endif // CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SHARED_SETTINGS_SERVICE_H_ |