Code refactor(rename email to user_id in wallpaper_manager.h/cc)

chrome/browser/chromeos/login/wallpaper_manager.cc

 // Copyright (c) 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/chromeos/login/wallpaper_manager.h"
 
 #include <numeric>
 #include <vector>
 
 #include "ash/shell.h"
@@ skipping 84 matching lines @@
 
 // Returns custom wallpaper directory by appending corresponding |sub_dir|.
 base::FilePath GetCustomWallpaperDir(const char* sub_dir) {
   base::FilePath custom_wallpaper_dir;
   CHECK(PathService::Get(chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS,
                          &custom_wallpaper_dir));
   return custom_wallpaper_dir.Append(sub_dir);
 }
 
 bool MoveCustomWallpaperDirectory(const char* sub_dir,
-                                  const std::string& email,
+                                  const std::string& user_id,
                                   const std::string& user_id_hash) {
   base::FilePath base_path = GetCustomWallpaperDir(sub_dir);
   base::FilePath to_path = base_path.Append(user_id_hash);
-  base::FilePath from_path = base_path.Append(email);
+  base::FilePath from_path = base_path.Append(user_id);
   if (base::PathExists(from_path))
     return base::Move(from_path, to_path);
   return false;
 }
 
 }  // namespace
 
 namespace chromeos {
 
 const char kWallpaperSequenceTokenName[] = "wallpaper-sequence";
@@ skipping 378 matching lines @@
             base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
         should_cache_wallpaper_ = false;
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
-void WallpaperManager::RemoveUserWallpaperInfo(const std::string& email) {
+void WallpaperManager::RemoveUserWallpaperInfo(const std::string& user_id) {
   WallpaperInfo info;
-  GetUserWallpaperInfo(email, &info);
+  GetUserWallpaperInfo(user_id, &info);
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
-  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(email, NULL);
-  DeleteUserWallpapers(email, info.file);
+  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
+  DeleteUserWallpapers(user_id, info.file);
 }
 
 bool WallpaperManager::ResizeWallpaper(
     const UserImage& wallpaper,
     ash::WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
     scoped_refptr<base::RefCountedBytes>* output) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
@@ skipping 188 matching lines @@
   wallpaper_info_dict->SetInteger(kNewWallpaperLayoutNodeName, info.layout);
   wallpaper_info_dict->SetInteger(kNewWallpaperTypeNodeName, info.type);
   wallpaper_update->SetWithoutPathExpansion(user_id, wallpaper_info_dict);
 }
 
 void WallpaperManager::SetLastSelectedUser(
     const std::string& last_selected_user) {
   last_selected_user_ = last_selected_user;
 }
 
-void WallpaperManager::SetUserWallpaperDelayed(const std::string& email) {
-  ScheduleSetUserWallpaper(email, true);
+void WallpaperManager::SetUserWallpaperDelayed(const std::string& user_id) {
+  ScheduleSetUserWallpaper(user_id, true);
 }
 
-void WallpaperManager::SetUserWallpaperNow(const std::string& email) {
-  ScheduleSetUserWallpaper(email, false);
+void WallpaperManager::SetUserWallpaperNow(const std::string& user_id) {
+  ScheduleSetUserWallpaper(user_id, false);
 }
 
-void WallpaperManager::ScheduleSetUserWallpaper(const std::string& email,
+void WallpaperManager::ScheduleSetUserWallpaper(const std::string& user_id,
                                                 bool delayed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Some unit tests come here without a UserManager or without a pref system.
   if (!UserManager::IsInitialized() || !g_browser_process->local_state())
     return;
   // There is no visible background in kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   // Guest user, regular user in ephemeral mode, or kiosk app.
-  const User* user = UserManager::Get()->FindUser(email);
-  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(email) ||
+  const User* user = UserManager::Get()->FindUser(user_id);
+  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id) ||
       (user != NULL && user->GetType() == User::USER_TYPE_KIOSK_APP)) {
-    InitInitialUserWallpaper(email, false);
-    GetPendingWallpaper(email, delayed)->ResetSetDefaultWallpaper();
+    InitInitialUserWallpaper(user_id, false);
+    GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
     return;
   }
 
-  if (!UserManager::Get()->IsKnownUser(email))
+  if (!UserManager::Get()->IsKnownUser(user_id))
     return;
 
-  SetLastSelectedUser(email);
+  SetLastSelectedUser(user_id);
 
   WallpaperInfo info;
 
-  if (!GetUserWallpaperInfo(email, &info)) {
-    InitInitialUserWallpaper(email, true);
-    GetUserWallpaperInfo(email, &info);
+  if (!GetUserWallpaperInfo(user_id, &info)) {
+    InitInitialUserWallpaper(user_id, true);
+    GetUserWallpaperInfo(user_id, &info);
   }
 
   gfx::ImageSkia user_wallpaper;
   current_user_wallpaper_info_ = info;
-  if (GetWallpaperFromCache(email, &user_wallpaper)) {
-    GetPendingWallpaper(email, delayed)->
+  if (GetWallpaperFromCache(user_id, &user_wallpaper)) {
+    GetPendingWallpaper(user_id, delayed)->
         ResetSetWallpaperImage(user_wallpaper, info);
   } else {
     if (info.type == User::CUSTOMIZED) {
       ash::WallpaperResolution resolution =
           ash::Shell::GetInstance()->
               desktop_background_controller()->
                   GetAppropriateResolution();
       const char* sub_dir = (resolution == ash::WALLPAPER_RESOLUTION_SMALL)
                                 ? kSmallWallpaperSubDir
                                 : kLargeWallpaperSubDir;
 
       // Wallpaper is not resized when layout is ash::WALLPAPER_LAYOUT_CENTER.
       // Original wallpaper should be used in this case.
       // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
       if (info.layout == ash::WALLPAPER_LAYOUT_CENTER)
         sub_dir = kOriginalWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       if (current_wallpaper_path_ == wallpaper_path)
         return;
       current_wallpaper_path_ = wallpaper_path;
       loaded_wallpapers_++;
 
-      GetPendingWallpaper(email, delayed)->
+      GetPendingWallpaper(user_id, delayed)->
           ResetSetCustomWallpaper(info, wallpaper_path);
       return;
     }
 
     if (info.file.empty()) {
       // Uses default built-in wallpaper when file is empty. Eventually, we
       // will only ship one built-in wallpaper in ChromeOS image.
-      GetPendingWallpaper(email, delayed)->ResetSetDefaultWallpaper();
+      GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
       return;
     }
 
     // Load downloaded ONLINE or converted DEFAULT wallpapers.
-    GetPendingWallpaper(email, delayed)->ResetLoadWallpaper(info);
+    GetPendingWallpaper(user_id, delayed)->ResetLoadWallpaper(info);
   }
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(
     const std::string& user_id,
     const gfx::ImageSkia& wallpaper,
     ash::WallpaperLayout layout) {
   // There is no visible background in  kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
@@ skipping 27 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void WallpaperManager::NotifyAnimationFinished() {
   FOR_EACH_OBSERVER(
       Observer, observers_, OnWallpaperAnimationFinished(last_selected_user_));
 }
 
 // WallpaperManager, private: --------------------------------------------------
 
-bool WallpaperManager::GetWallpaperFromCache(const std::string& email,
+bool WallpaperManager::GetWallpaperFromCache(const std::string& user_id,
                                              gfx::ImageSkia* wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(email);
+  CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(user_id);
   if (it != wallpaper_cache_.end()) {
     *wallpaper = (*it).second;
     return true;
   }
   return false;
 }
 
 void WallpaperManager::CacheUsersWallpapers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UserList users = UserManager::Get()->GetUsers();
 
   if (!users.empty()) {
     UserList::const_iterator it = users.begin();
     // Skip the wallpaper of first user in the list. It should have been cached.
     it++;
     for (int cached = 0;
          it != users.end() && cached < kMaxWallpapersToCache;
          ++it, ++cached) {
-      std::string user_email = (*it)->email();
-      CacheUserWallpaper(user_email);
+      std::string user_id = (*it)->email();
+      CacheUserWallpaper(user_id);
     }
   }
 }
 
-void WallpaperManager::CacheUserWallpaper(const std::string& email) {
-  if (wallpaper_cache_.find(email) != wallpaper_cache_.end())
+void WallpaperManager::CacheUserWallpaper(const std::string& user_id) {
+  if (wallpaper_cache_.find(user_id) != wallpaper_cache_.end())
     return;
   WallpaperInfo info;
-  if (GetUserWallpaperInfo(email, &info)) {
+  if (GetUserWallpaperInfo(user_id, &info)) {
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
     if (info.type == User::CUSTOMIZED) {
       ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
           desktop_background_controller()->GetAppropriateResolution();
       const char* sub_dir  = (resolution == ash::WALLPAPER_RESOLUTION_SMALL) ?
             kSmallWallpaperSubDir : kLargeWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      base::Unretained(this),
-                     email,
+                     user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
                      base::Passed(MovableOnDestroyCallbackHolder())));
       return;
     }
-    LoadWallpaper(email,
+    LoadWallpaper(user_id,
                   info,
                   false /* do not update wallpaper */,
                   MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 void WallpaperManager::ClearObsoleteWallpaperPrefs() {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate wallpaper_properties_pref(prefs,
       kUserWallpapersProperties);
@@ skipping 21 matching lines @@
     base::FilePath path = *it;
     // Some users may still have legacy wallpapers with png extension. We need
     // to delete these wallpapers too.
     if (!base::DeleteFile(path, true) &&
         !base::DeleteFile(path.AddExtension(".png"), false)) {
       LOG(ERROR) << "Failed to remove user wallpaper at " << path.value();
     }
   }
 }
 
-void WallpaperManager::DeleteUserWallpapers(const std::string& email,
+void WallpaperManager::DeleteUserWallpapers(const std::string& user_id,
                                             const std::string& path_to_file) {
   std::vector<base::FilePath> file_to_remove;
   // Remove small user wallpaper.
   base::FilePath wallpaper_path =
       GetCustomWallpaperDir(kSmallWallpaperSubDir);
   // Remove old directory if exists
-  file_to_remove.push_back(wallpaper_path.Append(email));
+  file_to_remove.push_back(wallpaper_path.Append(user_id));
   wallpaper_path = wallpaper_path.Append(path_to_file).DirName();
   file_to_remove.push_back(wallpaper_path);
 
   // Remove large user wallpaper.
   wallpaper_path = GetCustomWallpaperDir(kLargeWallpaperSubDir);
-  file_to_remove.push_back(wallpaper_path.Append(email));
+  file_to_remove.push_back(wallpaper_path.Append(user_id));
   wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   // Remove user wallpaper thumbnail.
   wallpaper_path = GetCustomWallpaperDir(kThumbnailWallpaperSubDir);
-  file_to_remove.push_back(wallpaper_path.Append(email));
+  file_to_remove.push_back(wallpaper_path.Append(user_id));
   wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   // Remove original user wallpaper.
   wallpaper_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
-  file_to_remove.push_back(wallpaper_path.Append(email));
+  file_to_remove.push_back(wallpaper_path.Append(user_id));
   wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::DeleteWallpaperInList,
                  base::Unretained(this),
                  file_to_remove),
       false);
 }
@@ skipping 44 matching lines @@
   }
 
   if (!disable_boot_animation) {
     // Normal boot, load user wallpaper.
     // If normal boot animation is disabled wallpaper would be set
     // asynchronously once user pods are loaded.
     SetUserWallpaperDelayed(users[0]->email());
   }
 }
 
-void WallpaperManager::LoadWallpaper(const std::string& email,
+void WallpaperManager::LoadWallpaper(const std::string& user_id,
                                      const WallpaperInfo& info,
                                      bool update_wallpaper,
                                      MovableOnDestroyCallbackHolder on_finish) {
   base::FilePath wallpaper_dir;
   base::FilePath wallpaper_path;
   if (info.type == User::ONLINE) {
     std::string file_name = GURL(info.file).ExtractFileName();
     ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
         desktop_background_controller()->GetAppropriateResolution();
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
     if (info.layout != ash::WALLPAPER_LAYOUT_STRETCH &&
         resolution == ash::WALLPAPER_RESOLUTION_SMALL) {
       file_name = base::FilePath(file_name).InsertBeforeExtension(
           kSmallWallpaperSuffix).value();
     }
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     wallpaper_path = wallpaper_dir.Append(file_name);
     if (current_wallpaper_path_ == wallpaper_path)
       return;
 
     if (update_wallpaper)
       current_wallpaper_path_ = wallpaper_path;
 
     loaded_wallpapers_++;
-    StartLoad(email, info, update_wallpaper, wallpaper_path, on_finish.Pass());
+    StartLoad(user_id, info, update_wallpaper, wallpaper_path,
+              on_finish.Pass());
   } else if (info.type == User::DEFAULT) {
     // Default wallpapers are migrated from M21 user profiles. A code refactor
     // overlooked that case and caused these wallpapers not being loaded at all.
     // On some slow devices, it caused login webui not visible after upgrade to
     // M26 from M21. See crosbug.com/38429 for details.
     base::FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     wallpaper_path = user_data_dir.Append(info.file);
-    StartLoad(email, info, update_wallpaper, wallpaper_path, on_finish.Pass());
+    StartLoad(user_id, info, update_wallpaper, wallpaper_path,
+              on_finish.Pass());
   } else {
     // In unexpected cases, revert to default wallpaper to fail safely. See
     // crosbug.com/38429.
     LOG(ERROR) << "Wallpaper reverts to default unexpected.";
-    DoSetDefaultWallpaper(email, on_finish.Pass());
+    DoSetDefaultWallpaper(user_id, on_finish.Pass());
   }
 }
 
-bool WallpaperManager::GetUserWallpaperInfo(const std::string& email,
+bool WallpaperManager::GetUserWallpaperInfo(const std::string& user_id,
                                             WallpaperInfo* info){
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(email)) {
+  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id)) {
     // Default to the values cached in memory.
     *info = current_user_wallpaper_info_;
 
     // Ephemeral users do not save anything to local state. But we have got
     // wallpaper info from memory. Returns true.
     return true;
   }
 
   const base::DictionaryValue* user_wallpapers =
       g_browser_process->local_state()->
           GetDictionary(prefs::kUsersWallpaperInfo);
   const base::DictionaryValue* wallpaper_info_dict;
   if (user_wallpapers->GetDictionaryWithoutPathExpansion(
-          email, &wallpaper_info_dict)) {
+          user_id, &wallpaper_info_dict)) {
     info->file = "";
     info->layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = User::UNKNOWN;
     info->date = base::Time::Now().LocalMidnight();
     wallpaper_info_dict->GetString(kNewWallpaperFileNodeName, &(info->file));
     int temp;
     wallpaper_info_dict->GetInteger(kNewWallpaperLayoutNodeName, &temp);
     info->layout = static_cast<ash::WallpaperLayout>(temp);
     wallpaper_info_dict->GetInteger(kNewWallpaperTypeNodeName, &temp);
     info->type = static_cast<User::WallpaperType>(temp);
     std::string date_string;
     int64 val;
     if (!(wallpaper_info_dict->GetString(kNewWallpaperDateNodeName,
                                          &date_string) &&
           base::StringToInt64(date_string, &val)))
       val = 0;
     info->date = base::Time::FromInternalValue(val);
     return true;
   }
 
   return false;
 }
 
 void WallpaperManager::MoveCustomWallpapersOnWorker(
-    const std::string& email,
+    const std::string& user_id,
     const std::string& user_id_hash) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
   if (MoveCustomWallpaperDirectory(kOriginalWallpaperSubDir,
-                                   email,
+                                   user_id,
                                    user_id_hash)) {
     // Consider success if the original wallpaper is moved to the new directory.
     // Original wallpaper is the fallback if the correct resolution wallpaper
     // can not be found.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&WallpaperManager::MoveCustomWallpapersSuccess,
                    base::Unretained(this),
-                   email,
+                   user_id,
                    user_id_hash));
   }
-  MoveCustomWallpaperDirectory(kLargeWallpaperSubDir, email, user_id_hash);
-  MoveCustomWallpaperDirectory(kSmallWallpaperSubDir, email, user_id_hash);
-  MoveCustomWallpaperDirectory(kThumbnailWallpaperSubDir, email, user_id_hash);
+  MoveCustomWallpaperDirectory(kLargeWallpaperSubDir, user_id, user_id_hash);
+  MoveCustomWallpaperDirectory(kSmallWallpaperSubDir, user_id, user_id_hash);
+  MoveCustomWallpaperDirectory(kThumbnailWallpaperSubDir, user_id,

[Nikita (slow), 2014/02/11 12:25:29]

nit: One parameter per line.

[bshe, 2014/02/13 15:34:04]

Done.

+                               user_id_hash);
 }
 
 void WallpaperManager::MoveCustomWallpapersSuccess(
-    const std::string& email,
+    const std::string& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
-  GetUserWallpaperInfo(email, &info);
+  GetUserWallpaperInfo(user_id, &info);
   if (info.type == User::CUSTOMIZED) {
     // New file field should include user id hash in addition to file name.
     // This is needed because at login screen, user id hash is not available.
     std::string relative_path =
         base::FilePath(user_id_hash).Append(info.file).value();
     info.file = relative_path;
     bool is_persistent =
-        !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(email);
-    SetUserWallpaperInfo(email, info, is_persistent);
+        !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
+    SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
   const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::MoveCustomWallpapersOnWorker,
                  base::Unretained(this),
                  logged_in_user->email(),
                  logged_in_user->username_hash()));
 }
 
 void WallpaperManager::GetCustomWallpaperInternal(
-    const std::string& email,
+    const std::string& user_id,
     const WallpaperInfo& info,
     const base::FilePath& wallpaper_path,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
 
   base::FilePath valid_path = wallpaper_path;
   if (!base::PathExists(wallpaper_path)) {
     // Falls back on original file if the correct resoltuion file does not
     // exist. This may happen when the original custom wallpaper is small or
     // browser shutdown before resized wallpaper saved.
     valid_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
     valid_path = valid_path.Append(info.file);
   }
 
   if (!base::PathExists(valid_path)) {
     // Falls back to custom wallpaper that uses email as part of its file path.
     // Note that email is used instead of user_id_hash here.
-    valid_path = GetCustomWallpaperPath(kOriginalWallpaperSubDir, email,
+    valid_path = GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id,
                                         info.file);
   }
 
   if (!base::PathExists(valid_path)) {
     LOG(ERROR) << "Failed to load previously selected custom wallpaper. " <<
                   "Fallback to default wallpaper";
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::DoSetDefaultWallpaper,
                                        base::Unretained(this),
-                                       email,
+                                       user_id,
                                        base::Passed(on_finish.Pass())));
   } else {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::StartLoad,
                                        base::Unretained(this),
-                                       email,
+                                       user_id,
                                        info,
                                        update_wallpaper,
                                        valid_path,
                                        base::Passed(on_finish.Pass())));
   }
 }
 
 void WallpaperManager::OnWallpaperDecoded(
-    const std::string& email,
+    const std::string& user_id,
     ash::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
 
   // If decoded wallpaper is empty, we are probably failed to decode the file.
   // Use default wallpaper in this case.
   if (wallpaper.image().isNull()) {
     // Updates user pref to default wallpaper.
     WallpaperInfo info = {
                            "",
                            ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
                            User::DEFAULT,
                            base::Time::Now().LocalMidnight()
                          };
-    SetUserWallpaperInfo(email, info, true);
+    SetUserWallpaperInfo(user_id, info, true);
 
     if (update_wallpaper)
-      DoSetDefaultWallpaper(email, on_finish.Pass());
+      DoSetDefaultWallpaper(user_id, on_finish.Pass());
     return;
   }
 
   // Only cache the user wallpaper at login screen and for multi profile users.
   if (!UserManager::Get()->IsUserLoggedIn() ||
       UserManager::IsMultipleProfilesAllowed()) {
-    wallpaper_cache_[email] = wallpaper.image();
+    wallpaper_cache_[user_id] = wallpaper.image();
   }
 
   if (update_wallpaper) {
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetCustomWallpaper(wallpaper.image(), layout);
   }
 }
 
 void WallpaperManager::ProcessCustomWallpaper(
     const std::string& user_id_hash,
@@ skipping 47 matching lines @@
                             User::WALLPAPER_TYPE_COUNT);
 }
 
 void WallpaperManager::SaveWallpaperInternal(const base::FilePath& path,
                                              const char* data,
                                              int size) {
   int written_bytes = file_util::WriteFile(path, data, size);
   DCHECK(written_bytes == size);
 }
 
-void WallpaperManager::StartLoad(const std::string& email,
+void WallpaperManager::StartLoad(const std::string& user_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
 
   wallpaper_loader_->Start(wallpaper_path.value(),
                            0,
                            base::Bind(&WallpaperManager::OnWallpaperDecoded,
                                       base::Unretained(this),
-                                      email,
+                                      user_id,
                                       info.layout,
                                       update_wallpaper,
                                       base::Passed(on_finish.Pass())));
 }
 
 void WallpaperManager::SaveLastLoadTime(const base::TimeDelta elapsed) {
   while (last_load_times_.size() >= kLastLoadsStatsMsMaxSize)
     last_load_times_.pop_front();
 
   if (elapsed > base::TimeDelta::FromMicroseconds(0)) {
@@ skipping 38 matching lines @@
     loading_.push_back(new WallpaperManager::PendingWallpaper(
         (delayed ? GetWallpaperLoadDelay()
                  : base::TimeDelta::FromMilliseconds(0)),
         user_id));
     pending_inactive_ = loading_.back();
   }
   return pending_inactive_;
 }
 
 }  // namespace chromeos