We should use UserID object to identify users instead of username.

components/wallpaper/wallpaper_manager_base.cc

 // Copyright 2014 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 "components/wallpaper/wallpaper_manager_base.h"
 
 #include <numeric>
 #include <vector>
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 10 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/user_names.h"
 #include "components/user_manager/user.h"
+#include "components/user_manager/user_id.h"
 #include "components/user_manager/user_image/user_image.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "components/wallpaper/wallpaper_layout.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 26 matching lines @@
 // color.
 const SkColor kDefaultWallpaperColor = SK_ColorGRAY;
 
 // The path ids for directories.
 int dir_user_data_path_id = -1;            // chrome::DIR_USER_DATA
 int dir_chromeos_wallpapers_path_id = -1;  // chrome::DIR_CHROMEOS_WALLPAPERS
 int dir_chromeos_custom_wallpapers_path_id =
     -1;  // chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS
 
 bool MoveCustomWallpaperDirectory(const char* sub_dir,
-                                  const std::string& user_id,
+                                  const user_manager::UserID& user_id,
                                   const std::string& user_id_hash) {
   base::FilePath base_path =
       WallpaperManagerBase::GetCustomWallpaperDir(sub_dir);
   base::FilePath to_path = base_path.Append(user_id_hash);
-  base::FilePath from_path = base_path.Append(user_id);
+  base::FilePath from_path = base_path.Append(user_id.GetUserEmail());
   if (base::PathExists(from_path))
     return base::Move(from_path, to_path);
   return false;
 }
 
 // Deletes a list of wallpaper files in |file_list|.
 void DeleteWallpaperInList(const std::vector<base::FilePath>& file_list) {
   for (std::vector<base::FilePath>::const_iterator it = file_list.begin();
        it != file_list.end(); ++it) {
     base::FilePath path = *it;
@@ skipping 158 matching lines @@
 
 // TestApi. For testing purpose
 WallpaperManagerBase::TestApi::TestApi(WallpaperManagerBase* wallpaper_manager)
     : wallpaper_manager_(wallpaper_manager) {
 }
 
 WallpaperManagerBase::TestApi::~TestApi() {
 }
 
 bool WallpaperManagerBase::TestApi::GetWallpaperFromCache(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     gfx::ImageSkia* image) {
   return wallpaper_manager_->GetWallpaperFromCache(user_id, image);
 }
 
 bool WallpaperManagerBase::TestApi::GetPathFromCache(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     base::FilePath* path) {
   return wallpaper_manager_->GetPathFromCache(user_id, path);
 }
 
 void WallpaperManagerBase::TestApi::SetWallpaperCache(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const base::FilePath& path,
     const gfx::ImageSkia& image) {
   DCHECK(!image.isNull());
   wallpaper_manager_->wallpaper_cache_[user_id] =
       CustomWallpaperElement(path, image);
 }
 
 void WallpaperManagerBase::TestApi::ClearDisposableWallpaperCache() {
   wallpaper_manager_->ClearDisposableWallpaperCache();
 }
@@ skipping 27 matching lines @@
 
 void WallpaperManagerBase::EnsureLoggedInUserWallpaperLoaded() {
   WallpaperInfo info;
   if (GetLoggedInUserWallpaperInfo(&info)) {
     UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", info.type,
                               user_manager::User::WALLPAPER_TYPE_COUNT);
     if (info == current_user_wallpaper_info_)
       return;
   }
   SetUserWallpaperNow(
-      user_manager::UserManager::Get()->GetLoggedInUser()->email());
+      user_manager::UserManager::Get()->GetLoggedInUser()->GetUserID());
 }
 
 void WallpaperManagerBase::ClearDisposableWallpaperCache() {
   // Cancel callback for previous cache requests.
   weak_factory_.InvalidateWeakPtrs();
   // Keep the wallpaper of logged in users in cache at multi-profile mode.
-  std::set<std::string> logged_in_users_names;
+  std::set<user_manager::UserID> logged_in_users_ids;
   const user_manager::UserList& logged_users =
       user_manager::UserManager::Get()->GetLoggedInUsers();
   for (user_manager::UserList::const_iterator it = logged_users.begin();
        it != logged_users.end(); ++it) {
-    logged_in_users_names.insert((*it)->email());
+    logged_in_users_ids.insert((*it)->GetUserID());
   }
 
   CustomWallpaperMap logged_in_users_cache;
   for (CustomWallpaperMap::iterator it = wallpaper_cache_.begin();
        it != wallpaper_cache_.end(); ++it) {
-    if (logged_in_users_names.find(it->first) != logged_in_users_names.end()) {
+    if (logged_in_users_ids.find(it->first) != logged_in_users_ids.end()) {
       logged_in_users_cache.insert(*it);
     }
   }
   wallpaper_cache_ = logged_in_users_cache;
 }
 
 bool WallpaperManagerBase::GetLoggedInUserWallpaperInfo(WallpaperInfo* info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (user_manager::UserManager::Get()->IsLoggedInAsStub()) {
     info->location = current_user_wallpaper_info_.location = "";
     info->layout = current_user_wallpaper_info_.layout =
         WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type =
         user_manager::User::DEFAULT;
     info->date = current_user_wallpaper_info_.date =
         base::Time::Now().LocalMidnight();
     return true;
   }
 
   return GetUserWallpaperInfo(
-      user_manager::UserManager::Get()->GetLoggedInUser()->email(), info);
+      user_manager::UserManager::Get()->GetLoggedInUser()->GetUserID(), info);
 }
 
 // static
 bool WallpaperManagerBase::ResizeImage(
     const gfx::ImageSkia& image,
     WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
     scoped_refptr<base::RefCountedBytes>* output,
     gfx::ImageSkia* output_skia) {
@@ skipping 64 matching lines @@
   scoped_refptr<base::RefCountedBytes> data;
   if (ResizeImage(image, layout, preferred_width, preferred_height, &data,
                   output_skia)) {
     return SaveWallpaperInternal(
         path, reinterpret_cast<const char*>(data->front()), data->size());
   }
   return false;
 }
 
 bool WallpaperManagerBase::IsPolicyControlled(
-    const std::string& user_id) const {
+    const user_manager::UserID& user_id) const {
   WallpaperInfo info;
   if (!GetUserWallpaperInfo(user_id, &info))
     return false;
   return info.type == user_manager::User::POLICY;
 }
 
 void WallpaperManagerBase::OnPolicySet(const std::string& policy,
-                                       const std::string& user_id) {
+                                       const user_manager::UserID& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   info.type = user_manager::User::POLICY;
   SetUserWallpaperInfo(user_id, info, true /* is_persistent */);
 }
 
 void WallpaperManagerBase::OnPolicyCleared(const std::string& policy,
-                                           const std::string& user_id) {
+                                           const user_manager::UserID& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   info.type = user_manager::User::DEFAULT;
   SetUserWallpaperInfo(user_id, info, true /* is_persistent */);
   SetDefaultWallpaperNow(user_id);
 }
 
 // static
 base::FilePath WallpaperManagerBase::GetCustomWallpaperPath(
     const char* sub_dir,
     const std::string& user_id_hash,
     const std::string& file) {
   base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
   return custom_wallpaper_path.Append(user_id_hash).Append(file);
 }
 
 WallpaperManagerBase::WallpaperManagerBase()
     : loaded_wallpapers_for_test_(0),
       command_line_for_testing_(NULL),
+      last_selected_user_(std::string(), std::string()),
       should_cache_wallpaper_(false),
       weak_factory_(this) {
   SetDefaultWallpaperPathsFromCommandLine(
       base::CommandLine::ForCurrentProcess());
   sequence_token_ = BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
       kWallpaperSequenceTokenName);
   task_runner_ =
       BrowserThread::GetBlockingPool()
           ->GetSequencedTaskRunnerWithShutdownBehavior(
               sequence_token_, base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 }
 
 WallpaperManagerBase::~WallpaperManagerBase() {
   // TODO(bshe): Lifetime of WallpaperManagerBase needs more consideration.
   // http://crbug.com/171694
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void WallpaperManagerBase::SetPolicyControlledWallpaper(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const user_manager::UserImage& user_image) {
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
 
   if (user->username_hash().empty()) {
     cryptohome::AsyncMethodCaller::GetInstance()->AsyncGetSanitizedUsername(
         user_id,
         base::Bind(&WallpaperManagerBase::SetCustomWallpaperOnSanitizedUsername,
                    weak_factory_.GetWeakPtr(), user_id, user_image.image(),
                    true /* update wallpaper */));
   } else {
     SetCustomWallpaper(user_id, user->username_hash(), "policy-controlled.jpeg",
                        WALLPAPER_LAYOUT_CENTER_CROPPED,
                        user_manager::User::POLICY, user_image.image(),
                        true /* update wallpaper */);
   }
 }
 
 void WallpaperManagerBase::SetCustomWallpaperOnSanitizedUsername(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const gfx::ImageSkia& image,
     bool update_wallpaper,
     bool cryptohome_success,
     const std::string& user_id_hash) {
   if (!cryptohome_success)
     return;
   SetCustomWallpaper(user_id, user_id_hash, "policy-controlled.jpeg",
                      WALLPAPER_LAYOUT_CENTER_CROPPED,
                      user_manager::User::POLICY, image, update_wallpaper);
 }
@@ skipping 28 matching lines @@
   ResizeAndSaveWallpaper(*image, small_wallpaper_path, layout,
                          kSmallWallpaperMaxWidth, kSmallWallpaperMaxHeight,
                          NULL);
   ResizeAndSaveWallpaper(*image, large_wallpaper_path, layout,
                          kLargeWallpaperMaxWidth, kLargeWallpaperMaxHeight,
                          NULL);
 }
 
 // static
 void WallpaperManagerBase::MoveCustomWallpapersOnWorker(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& user_id_hash,
     base::WeakPtr<WallpaperManagerBase> weak_ptr) {
   if (MoveCustomWallpaperDirectory(kOriginalWallpaperSubDir, 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(&WallpaperManagerBase::MoveCustomWallpapersSuccess, weak_ptr,
                    user_id, user_id_hash));
   }
   MoveCustomWallpaperDirectory(kLargeWallpaperSubDir, user_id, user_id_hash);
   MoveCustomWallpaperDirectory(kSmallWallpaperSubDir, user_id, user_id_hash);
   MoveCustomWallpaperDirectory(kThumbnailWallpaperSubDir, user_id,
                                user_id_hash);
 }
 
 // static
 void WallpaperManagerBase::GetCustomWallpaperInternal(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const WallpaperInfo& info,
     const base::FilePath& wallpaper_path,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     base::WeakPtr<WallpaperManagerBase> weak_ptr) {
   base::FilePath valid_path = wallpaper_path;
   if (!base::PathExists(wallpaper_path)) {
     // Falls back on original file if the correct resolution 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.location);
   }
 
   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, user_id,
+    valid_path = GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id.GetUserEmail() /* FIXME! */,
                                         info.location);
   }
 
   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(&WallpaperManagerBase::DoSetDefaultWallpaper, weak_ptr,
                    user_id, base::Passed(on_finish.Pass())));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&WallpaperManagerBase::StartLoad, weak_ptr, user_id, info,
                    update_wallpaper, valid_path,
                    base::Passed(on_finish.Pass())));
   }
 }
 
-void WallpaperManagerBase::InitInitialUserWallpaper(const std::string& user_id,
+void WallpaperManagerBase::InitInitialUserWallpaper(const user_manager::UserID& user_id,
                                                     bool is_persistent) {
   current_user_wallpaper_info_.location = "";
   current_user_wallpaper_info_.layout = WALLPAPER_LAYOUT_CENTER_CROPPED;
   current_user_wallpaper_info_.type = user_manager::User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
   SetUserWallpaperInfo(user_id, info, is_persistent);
 }
 
-void WallpaperManagerBase::SetUserWallpaperDelayed(const std::string& user_id) {
+void WallpaperManagerBase::SetUserWallpaperDelayed(const user_manager::UserID& user_id) {
   ScheduleSetUserWallpaper(user_id, true);
 }
 
-void WallpaperManagerBase::SetUserWallpaperNow(const std::string& user_id) {
+void WallpaperManagerBase::SetUserWallpaperNow(const user_manager::UserID& user_id) {
   ScheduleSetUserWallpaper(user_id, false);
 }
 
 void WallpaperManagerBase::UpdateWallpaper(bool clear_cache) {
   FOR_EACH_OBSERVER(Observer, observers_, OnUpdateWallpaperForTesting());
   if (clear_cache)
     wallpaper_cache_.clear();
   // For GAIA login flow, the last_selected_user_ may not be set before user
   // login. If UpdateWallpaper is called at GAIA login screen, no wallpaper will
   // be set. It could result a black screen on external monitors.
   // See http://crbug.com/265689 for detail.
   if (last_selected_user_.empty()) {
-    SetDefaultWallpaperNow(chromeos::login::kSignInUser);
+    SetDefaultWallpaperNow(chromeos::login::GetSignInUserID());
     return;
   }
   SetUserWallpaperNow(last_selected_user_);
 }
 
 void WallpaperManagerBase::AddObserver(
     WallpaperManagerBase::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void WallpaperManagerBase::RemoveObserver(
     WallpaperManagerBase::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WallpaperManagerBase::NotifyAnimationFinished() {
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnWallpaperAnimationFinished(last_selected_user_));
 }
 
 // WallpaperManager, protected: -----------------------------------------------
 
-bool WallpaperManagerBase::GetWallpaperFromCache(const std::string& user_id,
+bool WallpaperManagerBase::GetWallpaperFromCache(const user_manager::UserID& user_id,
                                                  gfx::ImageSkia* image) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(user_id);
   if (it != wallpaper_cache_.end() && !(*it).second.second.isNull()) {
     *image = (*it).second.second;
     return true;
   }
   return false;
 }
 
-bool WallpaperManagerBase::GetPathFromCache(const std::string& user_id,
+bool WallpaperManagerBase::GetPathFromCache(const user_manager::UserID& user_id,
                                             base::FilePath* path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(user_id);
   if (it != wallpaper_cache_.end()) {
     *path = (*it).second.first;
     return true;
   }
   return false;
 }
 
 int WallpaperManagerBase::loaded_wallpapers_for_test() const {
   return loaded_wallpapers_for_test_;
 }
 
 void WallpaperManagerBase::CacheUsersWallpapers() {
   // TODO(dpolukhin): crbug.com/408734.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   user_manager::UserList users = user_manager::UserManager::Get()->GetUsers();
 
   if (!users.empty()) {
     user_manager::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_id = (*it)->email();
-      CacheUserWallpaper(user_id);
+      CacheUserWallpaper((*it)->GetUserID());
     }
   }
 }
 
-void WallpaperManagerBase::CacheUserWallpaper(const std::string& user_id) {
+void WallpaperManagerBase::CacheUserWallpaper(const user_manager::UserID& user_id) {
   CustomWallpaperMap::iterator it = wallpaper_cache_.find(user_id);
   if (it != wallpaper_cache_.end() && !it->second.second.isNull())
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(user_id, &info)) {
     if (info.location.empty())
       return;
 
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
@@ skipping 12 matching lines @@
                      base::Passed(MovableOnDestroyCallbackHolder()),
                      weak_factory_.GetWeakPtr()));
       return;
     }
     LoadWallpaper(user_id, info, false /* do not update wallpaper */,
                   MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 void WallpaperManagerBase::DeleteUserWallpapers(
-    const std::string& user_id,
+    const user_manager::UserID& 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(user_id));
+  file_to_remove.push_back(wallpaper_path.Append(user_id.GetUserEmail()));
   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(user_id));
+  file_to_remove.push_back(wallpaper_path.Append(user_id.GetUserEmail()));
   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(user_id));
+  file_to_remove.push_back(wallpaper_path.Append(user_id.GetUserEmail()));
   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(user_id));
+  file_to_remove.push_back(wallpaper_path.Append(user_id.GetUserEmail()));
   wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   base::WorkerPool::PostTask(
       FROM_HERE, base::Bind(&DeleteWallpaperInList, file_to_remove), false);
 }
 
 void WallpaperManagerBase::SetCommandLineForTesting(
     base::CommandLine* command_line) {
   command_line_for_testing_ = command_line;
   SetDefaultWallpaperPathsFromCommandLine(command_line);
 }
 
 base::CommandLine* WallpaperManagerBase::GetCommandLine() {
   base::CommandLine* command_line =
       command_line_for_testing_ ? command_line_for_testing_
                                 : base::CommandLine::ForCurrentProcess();
   return command_line;
 }
 
 void WallpaperManagerBase::LoadWallpaper(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const WallpaperInfo& info,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish) {
   base::FilePath wallpaper_dir;
   base::FilePath wallpaper_path;
 
   // Do a sanity check that file path information is not empty.
   if (info.type == user_manager::User::ONLINE ||
       info.type == user_manager::User::DEFAULT) {
     if (info.location.empty()) {
       if (base::SysInfo::IsRunningOnChromeOS()) {
-        NOTREACHED() << "User wallpaper info appears to be broken: " << user_id;
+        NOTREACHED() << "User wallpaper info appears to be broken: " << user_id.GetUserEmail();
       } else {
         // Filename might be empty on debug configurations when stub users
         // were created directly in Local State (for testing). Ignore such
         // errors i.e. allowsuch type of debug configurations on the desktop.
-        LOG(WARNING) << "User wallpaper info is empty: " << user_id;
+        LOG(WARNING) << "User wallpaper info is empty: " << user_id.GetUserEmail();
 
         // |on_finish| callback will get called on destruction.
         return;
       }
     }
   }
 
   if (info.type == user_manager::User::ONLINE) {
     std::string file_name = GURL(info.location).ExtractFileName();
     WallpaperResolution resolution = GetAppropriateResolution();
@@ skipping 34 matching lines @@
               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(user_id, on_finish.Pass());
   }
 }
 
 void WallpaperManagerBase::MoveCustomWallpapersSuccess(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   if (info.type == user_manager::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.
     info.location = base::FilePath(user_id_hash).Append(info.location).value();
     bool is_persistent =
         !user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
             user_id);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManagerBase::MoveLoggedInUserCustomWallpaper() {
   const user_manager::User* logged_in_user =
       user_manager::UserManager::Get()->GetLoggedInUser();
   if (logged_in_user) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManagerBase::MoveCustomWallpapersOnWorker,
-                   logged_in_user->email(), logged_in_user->username_hash(),
+                   logged_in_user->GetUserID(), logged_in_user->username_hash(),
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void WallpaperManagerBase::SaveLastLoadTime(const base::TimeDelta elapsed) {
   while (last_load_times_.size() >= kLastLoadsStatsMsMaxSize)
     last_load_times_.pop_front();
 
   if (elapsed > base::TimeDelta::FromMicroseconds(0)) {
     last_load_times_.push_back(elapsed);
@@ skipping 144 matching lines @@
 void WallpaperManagerBase::CreateSolidDefaultWallpaper() {
   loaded_wallpapers_for_test_++;
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(kDefaultWallpaperColor);
   const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
   default_wallpaper_image_.reset(new user_manager::UserImage(image));
 }
 
 }  // namespace wallpaper