Update managed user registration to allow updating the avatar

chrome/browser/managed_mode/managed_user_sync_service.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 31 matching lines @@
                              const std::string& name,
                              bool acknowledged,
                              const std::string& master_key,
                              const std::string& chrome_avatar,
                              const std::string& chromeos_avatar) {
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user()->set_id(id);
   specifics.mutable_managed_user()->set_name(name);
   if (!chrome_avatar.empty())
     specifics.mutable_managed_user()->set_chrome_avatar(chrome_avatar);
+  else
+    specifics.mutable_managed_user()->clear_chrome_avatar();
   if (!chromeos_avatar.empty())
     specifics.mutable_managed_user()->set_chromeos_avatar(chromeos_avatar);
   if (!master_key.empty())
     specifics.mutable_managed_user()->set_master_key(master_key);
   if (acknowledged)
     specifics.mutable_managed_user()->set_acknowledged(true);
   return SyncData::CreateLocalData(id, name, specifics);
 }
 
 SyncData CreateSyncDataFromDictionaryEntry(
@@ skipping 15 matching lines @@
 
   return CreateLocalSyncData(it.key(), name, acknowledged, master_key,
                              chrome_avatar, chromeos_avatar);
 }
 
 }  // namespace
 
 const char ManagedUserSyncService::kAcknowledged[] = "acknowledged";
 const char ManagedUserSyncService::kChromeAvatar[] = "chromeAvatar";
 const char ManagedUserSyncService::kChromeOsAvatar[] = "chromeOsAvatar";
+const char ManagedUserSyncService::kMasterKey[] = "masterKey";
 const char ManagedUserSyncService::kName[] = "name";
-const char ManagedUserSyncService::kMasterKey[] = "masterKey";
+const int ManagedUserSyncService::kNoAvatar = -100;
 
 ManagedUserSyncService::ManagedUserSyncService(PrefService* prefs)
     : prefs_(prefs) {
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(
       prefs::kGoogleServicesLastUsername,
       base::Bind(&ManagedUserSyncService::OnLastSignedInUsernameChange,
                  base::Unretained(this)));
 }
 
 ManagedUserSyncService::~ManagedUserSyncService() {
 }
 
 // static
 void ManagedUserSyncService::RegisterProfilePrefs(
     PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kManagedUsers,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 bool ManagedUserSyncService::GetAvatarIndex(const std::string& avatar_str,
                                             int* avatar_index) {
   // TODO(ibraaaa): when chrome OS supports supervised users avatar syncing
   // then update this method to support extracting the avatar index
   // for chrome OS as well.
   DCHECK(avatar_index);
   if (avatar_str.empty()) {
-    *avatar_index = -1;
+    *avatar_index = kNoAvatar;
     return true;
   }
 
   size_t prefix_len = strlen(kChromeAvatarPrefix);
   if (avatar_str.size() <= prefix_len ||
       avatar_str.substr(0, prefix_len) != kChromeAvatarPrefix) {
     return false;
   }
 
   return base::StringToInt(avatar_str.substr(prefix_len), avatar_index);
@@ skipping 49 matching lines @@
       FROM_HERE,
       SyncChange::ACTION_ADD,
       CreateLocalSyncData(id, name, false, master_key,
                           chrome_avatar, std::string())));
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!error.IsSet()) << error.ToString();
 }
 
 void ManagedUserSyncService::DeleteManagedUser(const std::string& id) {
+  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  bool success = update->RemoveWithoutPathExpansion(id, NULL);
+  DCHECK(success);
+
   if (!sync_processor_)
     return;
 
   SyncChangeList change_list;
   change_list.push_back(SyncChange(
       FROM_HERE,
       SyncChange::ACTION_DELETE,
       SyncData::CreateLocalDelete(id, MANAGED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!sync_error.IsSet());
 }
 
 const DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
   DCHECK(sync_processor_);
   return prefs_->GetDictionary(prefs::kManagedUsers);
 }
 
+bool ManagedUserSyncService::UpdateManagedUserAvatarIfNeeded(
+    const std::string& id,
+    int avatar_index) {
+  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryValue* dict = update.Get();
+  DCHECK(dict->HasKey(id));
+  DictionaryValue* value = NULL;
+  bool success = dict->GetDictionaryWithoutPathExpansion(id, &value);
+  DCHECK(success);
+
+  bool acknowledged = false;
+  value->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
+  std::string name;
+  value->GetString(ManagedUserSyncService::kName, &name);
+  std::string master_key;
+  value->GetString(ManagedUserSyncService::kMasterKey, &master_key);
+  // TODO(ibraaaa): this should be updated when avatar syncing for
+  // supervised users is implemented on Chrome OS.
+  std::string chromeos_avatar;
+  value->GetString(ManagedUserSyncService::kChromeOsAvatar, &chromeos_avatar);
+  std::string chrome_avatar;
+  value->GetString(ManagedUserSyncService::kChromeAvatar, &chrome_avatar);
+  if (!chrome_avatar.empty() && avatar_index != kNoAvatar)
+    return false;
+
+  chrome_avatar = avatar_index == kNoAvatar ?
+      std::string() : BuildAvatarString(avatar_index);
+  value->SetString(kChromeAvatar, chrome_avatar);
+
+  if (!sync_processor_)
+    return true;
+
+  SyncChangeList change_list;
+  change_list.push_back(SyncChange(
+      FROM_HERE,
+      SyncChange::ACTION_UPDATE,
+      CreateLocalSyncData(id, name, acknowledged, master_key,
+                          chrome_avatar, chromeos_avatar)));
+  SyncError error =
+      sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
+  DCHECK(!error.IsSet()) << error.ToString();
+  return true;
+}
+
+void ManagedUserSyncService::ClearManagedUserAvatar(const std::string& id) {
+  bool cleared = UpdateManagedUserAvatarIfNeeded(id, kNoAvatar);
+  DCHECK(cleared);
+}
+
 void ManagedUserSyncService::GetManagedUsersAsync(
     const ManagedUsersCallback& callback) {
   // If we are already syncing, just run the callback.
   if (sync_processor_) {
     callback.Run(GetManagedUsers());
     return;
   }
 
   // Otherwise queue it up until we start syncing.
   callbacks_.push_back(callback);
@@ skipping 153 matching lines @@
 
 void ManagedUserSyncService::DispatchCallbacks() {
   const DictionaryValue* managed_users =
       prefs_->GetDictionary(prefs::kManagedUsers);
   for (std::vector<ManagedUsersCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
     it->Run(managed_users);
   }
   callbacks_.clear();
 }