[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 15 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros/cert_library.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
+#include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/system/runtime_environment.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 11 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 15 matching lines @@
   prefs_users_update->Append(Value::CreateStringValue(email));
   UserList::iterator logged_in_user = users_.end();
   for (UserList::iterator it = users_.begin(); it != users_.end(); ++it) {
     std::string user_email = (*it)->email();
     // Skip the most recent user.
     if (email != user_email)
       prefs_users_update->Append(Value::CreateStringValue(user_email));
     else
       logged_in_user = it;
   }
-  prefs->ScheduleSavePersistentPrefs();
 
   if (logged_in_user == users_.end()) {
     current_user_is_new_ = true;
     logged_in_user_ = CreateUser(email);
   } else {
     logged_in_user_ = *logged_in_user;
     users_.erase(logged_in_user);
   }
   // This user must be in the front of the user list.
   users_.insert(users_.begin(), logged_in_user_);
@@ skipping 78 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);
 
-  prefs->ScheduleSavePersistentPrefs();
+  DictionaryPrefUpdate prefs_display_email_update(prefs, kUserDisplayEmail);
+  prefs_display_email_update->RemoveWithoutPathExpansion(email, NULL);
 
   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.";
-  local_state->ScheduleSavePersistentPrefs();
+  DVLOG(1) << "Saving user OAuth token status in Local State";
   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) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  User* user = const_cast<User*>(FindUser(username));
+  if (!user)
+    return;  // Ignore if there is no such user.
+
+  user->set_display_email(display_email);
+
+  PrefService* local_state = g_browser_process->local_state();
+
+  DictionaryPrefUpdate display_email_update(local_state, kUserDisplayEmail);
+  display_email_update->SetWithoutPathExpansion(
+      username,
+      base::Value::CreateStringValue(display_email));
+}
+
+std::string UserManager::GetUserDisplayEmail(
+    const std::string& username) const {
+  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 136 matching lines @@
   }
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate images_update(local_state, kUserImages);
   base::DictionaryValue* image_properties = new base::DictionaryValue();
   image_properties->Set(kImagePathNodeName, new StringValue(image_path));
   image_properties->Set(kImageIndexNodeName,
                         new base::FundamentalValue(image_index));
   images_update->SetWithoutPathExpansion(username, image_properties);
   DVLOG(1) << "Saving path to user image in Local State.";
-  local_state->ScheduleSavePersistentPrefs();
 
   NotifyLocalStateChanged();
 }
 
 void UserManager::DeleteUserImage(const FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::Delete(image_path, false)) {
     LOG(ERROR) << "Failed to remove user image.";
     return;
   }
@@ skipping 99 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