Display supervised users synced avatars in the import overlay

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"
 #include "base/values.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 
 using base::DictionaryValue;
 using user_prefs::PrefRegistrySyncable;
 using syncer::MANAGED_USERS;
 using syncer::ModelType;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 using syncer::SyncChangeProcessor;
 using syncer::SyncData;
 using syncer::SyncDataList;
 using syncer::SyncError;
 using syncer::SyncErrorFactory;
 using syncer::SyncMergeResult;
 using sync_pb::ManagedUserSpecifics;
 
 namespace {
 
-const char kAcknowledged[] = "acknowledged";
-const char kChromeAvatar[] = "chromeAvatar";
-const char kChromeOsAvatar[] = "chromeOsAvatar";
-const char kName[] = "name";
-const char kMasterKey[] = "masterKey";
+const char kChromeAvatarPrefix[] = "chrome-avatar-index:";
 
 SyncData CreateLocalSyncData(const std::string& id,
                              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);
   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(
     const DictionaryValue::Iterator& it) {
   const DictionaryValue* dict = NULL;
   bool success = it.value().GetAsDictionary(&dict);
   DCHECK(success);
   bool acknowledged = false;
-  dict->GetBoolean(kAcknowledged, &acknowledged);
+  dict->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
-  dict->GetString(kName, &name);
+  dict->GetString(ManagedUserSyncService::kName, &name);
   DCHECK(!name.empty());
   std::string master_key;
-  dict->GetString(kMasterKey, &master_key);
+  dict->GetString(ManagedUserSyncService::kMasterKey, &master_key);
   std::string chrome_avatar;
-  dict->GetString(kChromeAvatar, &chrome_avatar);
+  dict->GetString(ManagedUserSyncService::kChromeAvatar, &chrome_avatar);
   std::string chromeos_avatar;
-  dict->GetString(kChromeOsAvatar, &chromeos_avatar);
+  dict->GetString(ManagedUserSyncService::kChromeOsAvatar, &chromeos_avatar);
 
   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::kName[] = "name";
+const char ManagedUserSyncService::kMasterKey[] = "masterKey";
+
 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;
+    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);
+}
+
+// static
+std::string ManagedUserSyncService::BuildAvatarString(int avatar_index) {
+  return base::StringPrintf("%s%d", kChromeAvatarPrefix, avatar_index);
+}
+
 void ManagedUserSyncService::AddObserver(
     ManagedUserSyncServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ManagedUserSyncService::RemoveObserver(
     ManagedUserSyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ManagedUserSyncService::AddManagedUser(const std::string& id,
                                             const std::string& name,
                                             const std::string& master_key,
                                             int avatar_index) {
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
   DictionaryValue* dict = update.Get();
   DictionaryValue* value = new DictionaryValue;
   value->SetString(kName, name);
   value->SetString(kMasterKey, master_key);
   std::string chrome_avatar;
 #if defined(CHROME_OS)
   // This is a dummy value that is passed when a supervised user is created on
   // Chrome OS.
   // TODO(ibraaaa): update this to use the correct avatar index
   // once avatar syncing for supervised users is implemented on Chrome OS.
   DCHECK_EQ(avatar_index, -111);
 #else
-  chrome_avatar = base::StringPrintf("chrome-avatar-index:%d", avatar_index);
+  chrome_avatar = BuildAvatarString(avatar_index);
 #endif
   value->SetString(kChromeAvatar, chrome_avatar);
   // TODO(ibraaaa): this should be updated to allow supervised
   // users avatar syncing on Chrome OS.
   value->SetString(kChromeOsAvatar, std::string());
   DCHECK(!dict->HasKey(id));
   dict->SetWithoutPathExpansion(id, value);
 
   if (!sync_processor_)
     return;
@@ skipping 195 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();
 }