Display supervised users synced avatars in the import overlay

BUG=None

Review URL: https://chromiumcodereview.appspot.com/23523038

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@222513 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 91 insertions, 11 deletions

diff --git a/chrome/browser/managed_mode/managed_user_sync_service.cc b/chrome/browser/managed_mode/managed_user_sync_service.cc
index 4e17e97..177e2b7 100644
--- a/chrome/browser/managed_mode/managed_user_sync_service.cc
+++ b/chrome/browser/managed_mode/managed_user_sync_service.cc
@@ -6,6 +6,7 @@
 
 #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"
@@ -35,11 +36,7 @@ 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,
@@ -67,16 +64,16 @@ SyncData CreateSyncDataFromDictionaryEntry(
   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);
@@ -84,6 +81,12 @@ SyncData CreateSyncDataFromDictionaryEntry(
 
 }  // 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_);
@@ -103,6 +106,32 @@ void ManagedUserSyncService::RegisterProfilePrefs(
                                    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);
@@ -130,7 +159,7 @@ void ManagedUserSyncService::AddManagedUser(const std::string& id,
   // 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
diff --git a/chrome/browser/managed_mode/managed_user_sync_service.h b/chrome/browser/managed_mode/managed_user_sync_service.h
index 832ba51..89bfdac 100644
--- a/chrome/browser/managed_mode/managed_user_sync_service.h
+++ b/chrome/browser/managed_mode/managed_user_sync_service.h
@@ -33,10 +33,30 @@ class ManagedUserSyncService : public BrowserContextKeyedService,
   typedef base::Callback<void(const base::DictionaryValue*)>
       ManagedUsersCallback;
 
+  static const char kAcknowledged[];
+  static const char kChromeAvatar[];
+  static const char kChromeOsAvatar[];
+  static const char kName[];
+  static const char kMasterKey[];
+
   virtual ~ManagedUserSyncService();
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
+  // Extracts the avatar index from the input |avatar_str| and set
+  // |avatar_index| to hold the extracted value. Returns true if the
+  // index was extracted successfully and false otherwise.
+  // |avatar_str| should have the format: "chrome-avatar-index:INDEX"
+  // where INDEX is the integer to be extracted. |avatar_str| can be empty
+  // in case there is no avatar synced for a managed user in which case
+  // |avatar_index| is set to -1.
+  static bool GetAvatarIndex(const std::string& avatar_str, int* avatar_index);
+
+  // Given an |avatar_index|, it returns a string of the form:
+  // "chrome-avatar-index:INDEX" where INDEX = |avatar_index|.
+  // It is exposed for testing purposes only.
+  static std::string BuildAvatarString(int avatar_index);
+
   void AddObserver(ManagedUserSyncServiceObserver* observer);
   void RemoveObserver(ManagedUserSyncServiceObserver* observer);
 
diff --git a/chrome/browser/managed_mode/managed_user_sync_service_unittest.cc b/chrome/browser/managed_mode/managed_user_sync_service_unittest.cc
index 8d904e5..9f7571d 100644
--- a/chrome/browser/managed_mode/managed_user_sync_service_unittest.cc
+++ b/chrome/browser/managed_mode/managed_user_sync_service_unittest.cc
@@ -267,3 +267,34 @@ TEST_F(ManagedUserSyncServiceTest, MergeExisting) {
     EXPECT_EQ(kAvatar1, managed_user.chrome_avatar());
   }
 }
+
+TEST_F(ManagedUserSyncServiceTest, GetAvatarIndex) {
+  int avatar = 100;
+  EXPECT_TRUE(ManagedUserSyncService::GetAvatarIndex(std::string(), &avatar));
+  EXPECT_EQ(-1, avatar);
+
+  std::string avatar_str = ManagedUserSyncService::BuildAvatarString(24);
+  EXPECT_EQ("chrome-avatar-index:24", avatar_str);
+  EXPECT_TRUE(ManagedUserSyncService::GetAvatarIndex(avatar_str, &avatar));
+  EXPECT_EQ(24, avatar);
+
+  avatar_str = ManagedUserSyncService::BuildAvatarString(0);
+  EXPECT_EQ("chrome-avatar-index:0", avatar_str);
+  EXPECT_TRUE(ManagedUserSyncService::GetAvatarIndex(avatar_str, &avatar));
+  EXPECT_EQ(0, avatar);
+
+  EXPECT_FALSE(ManagedUserSyncService::GetAvatarIndex("wrong-prefix:5",
+                                                      &avatar));
+
+  EXPECT_FALSE(ManagedUserSyncService::GetAvatarIndex("chrome-avatar-indes:2",
+                                                      &avatar));
+
+  EXPECT_FALSE(ManagedUserSyncService::GetAvatarIndex("chrome-avatar-indexxx:2",
+                                                      &avatar));
+
+  EXPECT_FALSE(ManagedUserSyncService::GetAvatarIndex("chrome-avatar-index:",
+                                                      &avatar));
+
+  EXPECT_FALSE(ManagedUserSyncService::GetAvatarIndex("chrome-avatar-index:x",
+                                                      &avatar));
+}