Home | History | Annotate | Download | only in managed_mode 
      1 // Copyright 2013 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_MANAGED_MODE_MANAGED_USER_SYNC_SERVICE_H_
      6 #define CHROME_BROWSER_MANAGED_MODE_MANAGED_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/managed_mode/managed_user_sync_service_observer.h"
     15 #include "chrome/browser/managed_mode/managed_users.h"
     16 #include "components/browser_context_keyed_service/browser_context_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 ManagedUserSyncService : public BrowserContextKeyedService,
     30                                public syncer::SyncableService {
     31  public:
     32   // For use with GetManagedUsersAsync() below.
     33   typedef base::Callback<void(const base::DictionaryValue*)>
     34       ManagedUsersCallback;
     35 
     36   // Dictionary keys for entry values of |prefs::kManagedUsers|.
     37   static const char kAcknowledged[];
     38   static const char kChromeAvatar[];
     39   static const char kChromeOsAvatar[];
     40   static const char kMasterKey[];
     41   static const char kName[];
     42 
     43   // Represents a non-existing avatar on Chrome and Chrome OS.
     44   static const int kNoAvatar;
     45 
     46   virtual ~ManagedUserSyncService();
     47 
     48   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
     49 
     50   // Extracts the avatar index from the input |avatar_str| and set
     51   // |avatar_index| to hold the extracted value. Returns true if the
     52   // index was extracted successfully and false otherwise.
     53   // |avatar_str| should have the format: "chrome-avatar-index:INDEX"
     54   // where INDEX is the integer to be extracted. |avatar_str| can be empty
     55   // in case there is no avatar synced for a managed user in which case
     56   // |avatar_index| is set to -1.
     57   static bool GetAvatarIndex(const std::string& avatar_str,
     58                              int* avatar_index);
     59 
     60   // Given an |avatar_index|, it returns a string of the form:
     61   // "chrome-avatar-index:INDEX" where INDEX = |avatar_index|.
     62   // It is exposed for testing purposes only.
     63   static std::string BuildAvatarString(int avatar_index);
     64 
     65   void AddObserver(ManagedUserSyncServiceObserver* observer);
     66   void RemoveObserver(ManagedUserSyncServiceObserver* observer);
     67 
     68   void AddManagedUser(const std::string& id,
     69                       const std::string& name,
     70                       const std::string& master_key,
     71                       int avatar_index);
     72   void DeleteManagedUser(const std::string& id);
     73 
     74   // Updates the managed user avatar only if the managed user has
     75   // no avatar and |avatar_index| is set to some value other than
     76   // |kNoAvatar|. If |avatar_index| equals |kNoAvatar| and the
     77   // managed user has an avatar, it will be cleared. However,
     78   // to clear an avatar call the convenience method |ClearManagedUserAvatar()|.
     79   // Returns true if the avatar value is changed (either updated or cleared)
     80   // and false otherwise.
     81   bool UpdateManagedUserAvatarIfNeeded(const std::string& id, int avatar_index);
     82   void ClearManagedUserAvatar(const std::string& id);
     83 
     84   // Returns a dictionary containing all managed users managed by this
     85   // custodian. This method should only be called once this service has started
     86   // syncing managed users (i.e. has finished its initial merge of local and
     87   // server-side data, via MergeDataAndStartSyncing), as the stored data might
     88   // be outdated before that.
     89   const base::DictionaryValue* GetManagedUsers();
     90 
     91   // Calls the passed |callback| with a dictionary containing all managed users
     92   // managed by this custodian.
     93   void GetManagedUsersAsync(const ManagedUsersCallback& callback);
     94 
     95   // BrowserContextKeyedService implementation:
     96   virtual void Shutdown() OVERRIDE;
     97 
     98   // SyncableService implementation:
     99   virtual syncer::SyncMergeResult MergeDataAndStartSyncing(
    100       syncer::ModelType type,
    101       const syncer::SyncDataList& initial_sync_data,
    102       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
    103       scoped_ptr<syncer::SyncErrorFactory> error_handler) OVERRIDE;
    104   virtual void StopSyncing(syncer::ModelType type) OVERRIDE;
    105   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
    106       OVERRIDE;
    107   virtual syncer::SyncError ProcessSyncChanges(
    108       const tracked_objects::Location& from_here,
    109       const syncer::SyncChangeList& change_list) OVERRIDE;
    110 
    111  private:
    112   friend class ManagedUserSyncServiceFactory;
    113 
    114   // Use |ManagedUserSyncServiceFactory::GetForProfile(...)| to get an
    115   // instance of this service.
    116   explicit ManagedUserSyncService(PrefService* prefs);
    117 
    118   void OnLastSignedInUsernameChange();
    119 
    120   void NotifyManagedUserAcknowledged(const std::string& managed_user_id);
    121   void NotifyManagedUsersSyncingStopped();
    122 
    123   void DispatchCallbacks();
    124 
    125   PrefService* prefs_;
    126   PrefChangeRegistrar pref_change_registrar_;
    127 
    128   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
    129   scoped_ptr<syncer::SyncErrorFactory> error_handler_;
    130 
    131   ObserverList<ManagedUserSyncServiceObserver> observers_;
    132 
    133   std::vector<ManagedUsersCallback> callbacks_;
    134 
    135   DISALLOW_COPY_AND_ASSIGN(ManagedUserSyncService);
    136 };
    137 
    138 #endif  // CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_SYNC_SERVICE_H_
    139