[cros] Display emails of users are stored in a separate dictionary in Local State.

chrome/browser/chromeos/login/user_manager.cc

 // Copyright (c) 2011 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/chromeos/login/user_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 // A vector pref of the users who have logged into the device.
 const char kLoggedInUsers[] = "LoggedInUsers";
 // A dictionary that maps usernames to file paths to their images.
 const char kUserImages[] = "UserImages";
+// A dictionary that maps usernames to the displayed (non-canonical) emails.
+const char kUserDisplayEmail[] = "UserDisplayEmail";
 // A dictionary that maps usernames to OAuth token presence flag.
 const char kUserOAuthTokenStatus[] = "OAuthTokenStatus";
 
 // Incognito user is represented by an empty string (since some code already
 // depends on that and it's hard to figure out what).
 const char kGuestUser[] = "";
 
 // Stub user email (for test paths).
 const char kStubUser[] = "stub-user@example.com";
 
@@ skipping 141 matching lines @@
   return &g_user_manager.Get();
 }
 
 // static
 void UserManager::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterListPref(kLoggedInUsers, PrefService::UNSYNCABLE_PREF);
   local_state->RegisterDictionaryPref(kUserImages,
                                       PrefService::UNSYNCABLE_PREF);
   local_state->RegisterDictionaryPref(kUserOAuthTokenStatus,
                                       PrefService::UNSYNCABLE_PREF);
+  local_state->RegisterDictionaryPref(kUserDisplayEmail,
+                                      PrefService::UNSYNCABLE_PREF);
 }
 
 const UserList& UserManager::GetUsers() const {
   const_cast<UserManager*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
 void UserManager::UserLoggedIn(const std::string& email) {
   DCHECK(!user_is_logged_in_);
 
@@ skipping 114 matching lines @@
   DictionaryPrefUpdate prefs_images_update(prefs, kUserImages);
   std::string image_path_string;
   prefs_images_update->GetStringWithoutPathExpansion(email, &image_path_string);
   prefs_images_update->RemoveWithoutPathExpansion(email, NULL);
 
   DictionaryPrefUpdate prefs_oauth_update(prefs, kUserOAuthTokenStatus);
   int oauth_status;
   prefs_oauth_update->GetIntegerWithoutPathExpansion(email, &oauth_status);
   prefs_oauth_update->RemoveWithoutPathExpansion(email, NULL);
 
+  DictionaryPrefUpdate prefs_display_email_update(prefs, kUserDisplayEmail);
+  prefs_display_email_update->RemoveWithoutPathExpansion(email, NULL);
+
   prefs->ScheduleSavePersistentPrefs();

[Nikita (slow), 2011/12/05 13:13:04]

nit: Cleanup, this call could be removed.

[Ivan Korotkov, 2011/12/05 14:12:48]

Done.

 
   if (user_to_remove != users_.end()) {
     --display_name_count_[(*user_to_remove)->GetDisplayName()];
     delete *user_to_remove;
     users_.erase(user_to_remove);
   }
 
   int default_image_id = User::kInvalidImageIndex;
   if (!image_path_string.empty() &&
       !IsDefaultImagePath(image_path_string, &default_image_id)) {
@@ skipping 28 matching lines @@
 }
 
 void UserManager::SaveUserOAuthStatus(
     const std::string& username,
     User::OAuthTokenStatus oauth_token_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate oauth_status_update(local_state, kUserOAuthTokenStatus);
   oauth_status_update->SetWithoutPathExpansion(username,
       new base::FundamentalValue(static_cast<int>(oauth_token_status)));
-  DVLOG(1) << "Saving user OAuth token status in Local State.";
+  DVLOG(1) << "Saving user OAuth token status in Local State";
   local_state->ScheduleSavePersistentPrefs();

[Nikita (slow), 2011/12/05 13:13:04]

nit: Cleanup, this call could be removed.

[Ivan Korotkov, 2011/12/05 14:12:48]

Done.

   User* user = const_cast<User*>(FindUser(username));
   if (user)
     user->set_oauth_token_status(oauth_token_status);
 }
 
-User::OAuthTokenStatus UserManager::GetUserOAuthStatus(
+User::OAuthTokenStatus UserManager::LoadUserOAuthStatus(
     const std::string& username) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSkipOAuthLogin)) {
     // Use OAUTH_TOKEN_STATUS_VALID flag if kSkipOAuthLogin is present.
     return User::OAUTH_TOKEN_STATUS_VALID;
   } else {
     PrefService* local_state = g_browser_process->local_state();
     const DictionaryValue* prefs_oauth_status =
         local_state->GetDictionary(kUserOAuthTokenStatus);
 
     int oauth_token_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
     if (prefs_oauth_status &&
         prefs_oauth_status->GetIntegerWithoutPathExpansion(username,
             &oauth_token_status)) {
       return static_cast<User::OAuthTokenStatus>(oauth_token_status);
     }
   }
 
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
+void UserManager::SaveUserDisplayEmail(const std::string& username,
+                                       const std::string& display_email,
+                                       bool update_if_exists) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  PrefService* local_state = g_browser_process->local_state();
+
+  if (!update_if_exists) {
+    // Check if a display name is already known for that username.
+    std::string display_email;
+    const DictionaryValue* prefs_display_email =
+        local_state->GetDictionary(kUserDisplayEmail);
+    if (prefs_display_email &&
+        prefs_display_email->GetStringWithoutPathExpansion(
+            username, &display_email))
+      return;
+  }
+
+  DictionaryPrefUpdate display_email_update(local_state, kUserDisplayEmail);
+  display_email_update->SetWithoutPathExpansion(
+      username,
+      base::Value::CreateStringValue(display_email));
+  DVLOG(1) << "Saving displayed email in Local State";

[Nikita (slow), 2011/12/05 13:13:04]

nit: cleanup log.

[Ivan Korotkov, 2011/12/05 14:12:48]

Done.

+  local_state->ScheduleSavePersistentPrefs();

[Nikita (slow), 2011/12/05 13:13:04]

Please remove since prefs are automatically scheduled for save so it's a no-op
now.

[Ivan Korotkov, 2011/12/05 14:12:48]

Done.

+
+  User* user = const_cast<User*>(FindUser(username));
+  if (user)
+    user->set_display_email(display_email);
+}
+
+std::string UserManager::GetUserDisplayEmail(
+    const std::string& username) const {
+  // TODO(ivankr): won't work with users that are not registered but present

[Nikita (slow), 2011/12/05 13:13:04]

Is this only for whitelist? We may as well ignore whitelist use case for display
emails.

[Ivan Korotkov, 2011/12/05 14:12:48]

Yes, it's for whitelist only. I'll leave a TODO for myself for now.

+  // in |kUserDisplayEmail| dictionary.
+  const User* user = FindUser(username);
+  return user ? user->display_email() : username;
+}
+
 void UserManager::SaveUserDefaultImageIndex(const std::string& username,
                                             int image_index) {
   DCHECK(image_index >= 0 && image_index < kDefaultImagesCount);
   SetUserImage(username, image_index, GetDefaultImage(image_index));
   SaveImageToLocalState(username, "", image_index, false);
 }
 
 void UserManager::SaveUserImage(const std::string& username,
                                 const SkBitmap& image) {
   SaveUserImageInternal(username, User::kExternalImageIndex, image);
@@ skipping 107 matching lines @@
 void UserManager::EnsureUsersLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!users_.empty())
     return;
   if (!g_browser_process)
     return;
 
   PrefService* local_state = g_browser_process->local_state();
   const ListValue* prefs_users = local_state->GetList(kLoggedInUsers);
   const DictionaryValue* prefs_images = local_state->GetDictionary(kUserImages);
+  const DictionaryValue* prefs_display_emails =
+      local_state->GetDictionary(kUserDisplayEmail);
 
   if (prefs_users) {
     for (ListValue::const_iterator it = prefs_users->begin();
          it != prefs_users->end(); ++it) {
       std::string email;
       if ((*it)->GetAsString(&email)) {
         User* user = CreateUser(email);
         users_.push_back(user);
 
         if (prefs_images) {
@@ skipping 43 matching lines @@
                 image_loader_->Start(
                     image_path, 0,
                     base::Bind(&UserManager::SetUserImage,
                                base::Unretained(this), email, image_index));
               }
             } else {
               NOTREACHED();
             }
           }
         }
+
+        std::string display_email;
+        if (prefs_display_emails &&
+            prefs_display_emails->GetStringWithoutPathExpansion(
+                email, &display_email)) {
+          user->set_display_email(display_email);
+        }
       }
     }
   }
 }
 
 void UserManager::StubUserLoggedIn() {
   logged_in_user_ = &stub_user_;
   stub_user_.SetImage(GetDefaultImage(kStubDefaultImageIndex),
                       kStubDefaultImageIndex);
 }
@@ skipping 260 matching lines @@
         chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
         content::Source<UserManager>(this),
         content::NotificationService::NoDetails());
   }
 
   profile_image_downloader_.reset();
 }
 
 User* UserManager::CreateUser(const std::string& email) const {
   User* user = new User(email);
-  user->set_oauth_token_status(GetUserOAuthStatus(email));
+  user->set_oauth_token_status(LoadUserOAuthStatus(email));
   // Used to determine whether user's display name is unique.
   ++display_name_count_[user->GetDisplayName()];
   return user;
 }
 
 }  // namespace chromeos