Home | History | Annotate | Download | only in supervised_user
      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_SYNC_SERVICE_H_
      6 #define CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SYNC_SERVICE_H_
      7 
      8 #include <vector>
      9 
     10 #include "base/callback_forward.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/observer_list.h"
     13 #include "base/prefs/pref_change_registrar.h"
     14 #include "chrome/browser/supervised_user/supervised_user_sync_service_observer.h"
     15 #include "chrome/browser/supervised_user/supervised_users.h"
     16 #include "components/keyed_service/core/keyed_service.h"
     17 #include "sync/api/syncable_service.h"
     18 
     19 namespace base {
     20 class DictionaryValue;
     21 }
     22 
     23 namespace user_prefs {
     24 class PrefRegistrySyncable;
     25 }
     26 
     27 class PrefService;
     28 
     29 class SupervisedUserSyncService : public KeyedService,
     30                                   public syncer::SyncableService {
     31  public:
     32   // For use with GetSupervisedUsersAsync() below.
     33   typedef base::Callback<void(const base::DictionaryValue*)>
     34       SupervisedUsersCallback;
     35 
     36   // Dictionary keys for entry values of |prefs::kSupervisedUsers|.
     37   static const char kAcknowledged[];
     38   static const char kChromeAvatar[];
     39   static const char kChromeOsAvatar[];
     40   static const char kMasterKey[];
     41   static const char kPasswordSignatureKey[];
     42   static const char kPasswordEncryptionKey[];
     43   static const char kName[];
     44 
     45   // Represents a non-existing avatar on Chrome and Chrome OS.
     46   static const int kNoAvatar;
     47 
     48   virtual ~SupervisedUserSyncService();
     49 
     50   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
     51 
     52   // Extracts the avatar index from the input |avatar_str| and set
     53   // |avatar_index| to hold the extracted value. Returns true if the
     54   // index was extracted successfully and false otherwise.
     55   // |avatar_str| should have the format: "chrome-avatar-index:INDEX"
     56   // where INDEX is the integer to be extracted. |avatar_str| can be empty
     57   // in case there is no avatar synced for a supervised user in which case
     58   // |avatar_index| is set to -1.
     59   static bool GetAvatarIndex(const std::string& avatar_str,
     60                              int* avatar_index);
     61 
     62   // Given an |avatar_index|, it returns a string of the form:
     63   // "chrome-avatar-index:INDEX" where INDEX = |avatar_index|.
     64   // It is exposed for testing purposes only.
     65   static std::string BuildAvatarString(int avatar_index);
     66 
     67   void AddObserver(SupervisedUserSyncServiceObserver* observer);
     68   void RemoveObserver(SupervisedUserSyncServiceObserver* observer);
     69 
     70   void AddSupervisedUser(const std::string& id,
     71                          const std::string& name,
     72                          const std::string& master_key,
     73                          const std::string& signature_key,
     74                          const std::string& encryption_key,
     75                          int avatar_index);
     76   void UpdateSupervisedUser(const std::string& id,
     77                             const std::string& name,
     78                             const std::string& master_key,
     79                             const std::string& signature_key,
     80                             const std::string& encryption_key,
     81                             int avatar_index);
     82 
     83   void DeleteSupervisedUser(const std::string& id);
     84 
     85   // Updates the supervised user avatar only if the supervised user has
     86   // no avatar and |avatar_index| is set to some value other than
     87   // |kNoAvatar|. If |avatar_index| equals |kNoAvatar| and the
     88   // supervised user has an avatar, it will be cleared. However,
     89   // to clear an avatar call the convenience method
     90   // |ClearSupervisedUserAvatar()|.
     91   // Returns true if the avatar value is changed (either updated or cleared)
     92   // and false otherwise.
     93   bool UpdateSupervisedUserAvatarIfNeeded(const std::string& id,
     94                                           int avatar_index);
     95   void ClearSupervisedUserAvatar(const std::string& id);
     96 
     97   // Returns a dictionary containing all supervised users supervised by this
     98   // custodian. This method should only be called once this service has started
     99   // syncing supervised users (i.e. has finished its initial merge of local and
    100   // server-side data, via MergeDataAndStartSyncing), as the stored data might
    101   // be outdated before that.
    102   const base::DictionaryValue* GetSupervisedUsers();
    103 
    104   // Calls the passed |callback| with a dictionary containing all supervised
    105   // users managed by this custodian.
    106   void GetSupervisedUsersAsync(const SupervisedUsersCallback& callback);
    107 
    108   // KeyedService implementation:
    109   virtual void Shutdown() OVERRIDE;
    110 
    111   // SyncableService implementation:
    112   virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
    113       syncer::ModelType type,
    114       const syncer::SyncDataList& initial_sync_data,
    115       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
    116       scoped_ptr<syncer::SyncErrorFactory> error_handler) OVERRIDE;
    117   virtual void StopSyncing(syncer::ModelType type) OVERRIDE;
    118   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
    119       OVERRIDE;
    120   virtual syncer::SyncError ProcessSyncChanges(
    121       const tracked_objects::Location& from_here,
    122       const syncer::SyncChangeList& change_list) OVERRIDE;
    123 
    124  private:
    125   friend class SupervisedUserSyncServiceFactory;
    126 
    127   // Use |SupervisedUserSyncServiceFactory::GetForProfile(...)| to get an
    128   // instance of this service.
    129   explicit SupervisedUserSyncService(PrefService* prefs);
    130 
    131   void OnLastSignedInUsernameChange();
    132 
    133   scoped_ptr<base::DictionaryValue> CreateDictionary(
    134       const std::string& name,
    135       const std::string& master_key,
    136       const std::string& signature_key,
    137       const std::string& encryption_key,
    138       int avatar_index);
    139 
    140   void UpdateSupervisedUserImpl(const std::string& id,
    141                                 const std::string& name,
    142                                 const std::string& master_key,
    143                                 const std::string& signature_key,
    144                                 const std::string& encryption_key,
    145                                 int avatar_index,
    146                                 bool add_user);
    147 
    148   void NotifySupervisedUserAcknowledged(const std::string& supervised_user_id);
    149   void NotifySupervisedUsersSyncingStopped();
    150   void NotifySupervisedUsersChanged();
    151 
    152   void DispatchCallbacks();
    153 
    154   PrefService* prefs_;
    155   PrefChangeRegistrar pref_change_registrar_;
    156 
    157   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
    158   scoped_ptr<syncer::SyncErrorFactory> error_handler_;
    159 
    160   ObserverList<SupervisedUserSyncServiceObserver> observers_;
    161 
    162   std::vector<SupervisedUsersCallback> callbacks_;
    163 
    164   DISALLOW_COPY_AND_ASSIGN(SupervisedUserSyncService);
    165 };
    166 
    167 #endif  // CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SYNC_SERVICE_H_
    168