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

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.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 "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 
 #include <numeric>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 117 matching lines @@
 //
 // PendingWallpaper is owned by WallpaperManager, but reference to this object
 // is passed to other threads by PostTask() calls, therefore it is
 // RefCountedThreadSafe.
 class WallpaperManager::PendingWallpaper :
     public base::RefCountedThreadSafe<PendingWallpaper> {
  public:
   // Do LoadWallpaper() - image not found in cache.
   PendingWallpaper(
       const base::TimeDelta delay,
-      const std::string& user_id)
+      const user_manager::UserID& user_id)
       : user_id_(user_id),
         default_(false),
         on_finish_(new MovableOnDestroyCallback(
             base::Bind(&WallpaperManager::PendingWallpaper::OnWallpaperSet,
                        this))) {
     timer.Start(
         FROM_HERE,
         delay,
         base::Bind(&WallpaperManager::PendingWallpaper::ProcessRequest, this));
   }
@@ skipping 98 matching lines @@
     }
     if (manager->pending_inactive_ == this) {
       // ProcessRequest() was never executed.
       manager->pending_inactive_ = NULL;
     }
 
     // Destroy self.
     manager->RemovePendingWallpaperFromList(this);
   }
 
-  std::string user_id_;
+  const user_manager::UserID user_id_;
   wallpaper::WallpaperInfo info_;
   gfx::ImageSkia user_wallpaper_;
   base::FilePath wallpaper_path_;
 
   // Load default wallpaper instead of user image.
   bool default_;
 
   // This is "on destroy" callback that will call OnWallpaperSet() when
   // image will be loaded.
   wallpaper::MovableOnDestroyCallbackHolder on_finish_;
@@ skipping 59 matching lines @@
     return;
 
   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 WallpaperManager::InitializeWallpaper() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // Apply device customization.
   if (ShouldUseCustomizedDefaultWallpaper()) {
     SetDefaultWallpaperPath(GetCustomizedWallpaperDefaultRescaledFileName(
                                 wallpaper::kSmallWallpaperSuffix),
@@ skipping 17 matching lines @@
   // Zero delays is also set in autotests.
   if (WizardController::IsZeroDelayEnabled()) {
     // Ensure tests have some sort of wallpaper.
     ash::Shell::GetInstance()->desktop_background_controller()->
         CreateEmptyWallpaper();
     return;
   }
 
   if (!user_manager->IsUserLoggedIn()) {
     if (!StartupUtils::IsDeviceRegistered())
-      SetDefaultWallpaperDelayed(chromeos::login::kSignInUser);
+      SetDefaultWallpaperDelayed(chromeos::login::GetSignInUserID());
     else
       InitializeRegisteredDeviceWallpaper();
     return;
   }
-  SetUserWallpaperDelayed(user_manager->GetLoggedInUser()->email());
+  SetUserWallpaperDelayed(user_manager->GetLoggedInUser()->GetUserID());
 }
 
 void WallpaperManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   switch (type) {
     case chrome::NOTIFICATION_LOGIN_USER_CHANGED: {
       ClearDisposableWallpaperCache();
       BrowserThread::PostDelayedTask(
@@ skipping 26 matching lines @@
             base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
         should_cache_wallpaper_ = false;
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
-void WallpaperManager::RemoveUserWallpaperInfo(const std::string& user_id) {
+void WallpaperManager::RemoveUserWallpaperInfo(const user_manager::UserID& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(
       prefs, wallpaper::kUsersWallpaperInfo);
-  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(), NULL);
   DeleteUserWallpapers(user_id, info.location);
 }
 
 void WallpaperManager::OnPolicyFetched(const std::string& policy,
-                                       const std::string& user_id,
+                                       const user_manager::UserID& user_id,
                                        scoped_ptr<std::string> data) {
   if (!data)
     return;
 
   wallpaper_loader_->Start(
       data.Pass(),
       0,  // Do not crop.
       base::Bind(&WallpaperManager::SetPolicyControlledWallpaper,
                  weak_factory_.GetWeakPtr(),
                  user_id));
 }
 
 void WallpaperManager::SetCustomWallpaper(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& user_id_hash,
     const std::string& file,
     wallpaper::WallpaperLayout layout,
     user_manager::User::WallpaperType type,
     const gfx::ImageSkia& image,
     bool update_wallpaper) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
@@ skipping 58 matching lines @@
       base::Time::Now().LocalMidnight()
   };
   SetUserWallpaperInfo(user_id, info, is_persistent);
   if (update_wallpaper) {
     GetPendingWallpaper(user_id, false)->ResetSetWallpaperImage(image, info);
   }
 
   wallpaper_cache_[user_id] = CustomWallpaperElement(wallpaper_path, image);
 }
 
-void WallpaperManager::SetDefaultWallpaperNow(const std::string& user_id) {
+void WallpaperManager::SetDefaultWallpaperNow(const user_manager::UserID& user_id) {
   GetPendingWallpaper(user_id, false)->ResetSetDefaultWallpaper();
 }
 
-void WallpaperManager::SetDefaultWallpaperDelayed(const std::string& user_id) {
+void WallpaperManager::SetDefaultWallpaperDelayed(const user_manager::UserID& user_id) {
   GetPendingWallpaper(user_id, true)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::DoSetDefaultWallpaper(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     MovableOnDestroyCallbackHolder on_finish) {
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   wallpaper_cache_.erase(user_id);
   // Some browser tests do not have a shell instance. As no wallpaper is needed
   // in these tests anyway, avoid loading one, preventing crashes and speeding
   // up the tests.
   if (!ash::Shell::HasInstance())
     return;
@@ skipping 34 matching lines @@
   }
   // 1x1 wallpaper is actually solid color, so it should be stretched.
   if (default_wallpaper_image_->image().width() == 1 &&
       default_wallpaper_image_->image().height() == 1)
     layout = wallpaper::WALLPAPER_LAYOUT_STRETCH;
 
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
       default_wallpaper_image_->image(), layout);
 }
 
-void WallpaperManager::SetUserWallpaperInfo(const std::string& user_id,
+void WallpaperManager::SetUserWallpaperInfo(const user_manager::UserID& user_id,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   current_user_wallpaper_info_ = info;
   if (!is_persistent)
     return;
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate wallpaper_update(local_state,
                                         wallpaper::kUsersWallpaperInfo);
 
   base::DictionaryValue* wallpaper_info_dict = new base::DictionaryValue();
   wallpaper_info_dict->SetString(kNewWallpaperDateNodeName,
       base::Int64ToString(info.date.ToInternalValue()));
   wallpaper_info_dict->SetString(kNewWallpaperLocationNodeName, info.location);
   wallpaper_info_dict->SetInteger(kNewWallpaperLayoutNodeName, info.layout);
   wallpaper_info_dict->SetInteger(kNewWallpaperTypeNodeName, info.type);
-  wallpaper_update->SetWithoutPathExpansion(user_id, wallpaper_info_dict);
+  wallpaper_update->SetWithoutPathExpansion(user_id.GetUserEmail(), wallpaper_info_dict);
 }
 
-void WallpaperManager::ScheduleSetUserWallpaper(const std::string& user_id,
+void WallpaperManager::ScheduleSetUserWallpaper(const user_manager::UserID& user_id,
                                                 bool delayed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Some unit tests come here without a UserManager or without a pref system.q
   if (!user_manager::UserManager::IsInitialized() ||
       !g_browser_process->local_state()) {
     return;
   }
 
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
@@ skipping 61 matching lines @@
           ->ResetSetCustomWallpaper(info, wallpaper_path);
       return;
     }
 
     // Load downloaded ONLINE or converted DEFAULT wallpapers.
     GetPendingWallpaper(user_id, delayed)->ResetLoadWallpaper(info);
   }
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const gfx::ImageSkia& image,
     wallpaper::WallpaperLayout layout,
     bool update_wallpaper) {
   DCHECK(user_manager::UserManager::Get()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   WallpaperInfo info;
   info.layout = layout;
@@ skipping 30 matching lines @@
       BrowserThread::GetBlockingPool()
           ->GetSequencedTaskRunnerWithShutdownBehavior(
               sequence_token_, base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   wallpaper_loader_ =
       new UserImageLoader(ImageDecoder::ROBUST_JPEG_CODEC, task_runner_);
 
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 }
 
 WallpaperManager::PendingWallpaper* WallpaperManager::GetPendingWallpaper(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     bool delayed) {
   if (!pending_inactive_) {
     loading_.push_back(new WallpaperManager::PendingWallpaper(
         (delayed ? GetWallpaperLoadDelay()
                  : base::TimeDelta::FromMilliseconds(0)),
         user_id));
     pending_inactive_ = loading_.back().get();
   }
   return pending_inactive_;
 }
@@ skipping 23 matching lines @@
   bool show_users = true;
   bool result = CrosSettings::Get()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn, &show_users);
   DCHECK(result) << "Unable to fetch setting "
                  << kAccountsPrefShowUserNamesOnSignIn;
   const user_manager::UserList& users =
       user_manager::UserManager::Get()->GetUsers();
   int public_session_user_index = FindPublicSession(users);
   if ((!show_users && public_session_user_index == -1) || users.empty()) {
     // Boot into sign in form, preload default wallpaper.
-    SetDefaultWallpaperDelayed(chromeos::login::kSignInUser);
+    SetDefaultWallpaperDelayed(chromeos::login::GetSignInUserID());
     return;
   }
 
   if (!disable_boot_animation) {
     int index = public_session_user_index != -1 ? public_session_user_index : 0;
     // Normal boot, load user wallpaper.
     // If normal boot animation is disabled wallpaper would be set
     // asynchronously once user pods are loaded.
-    SetUserWallpaperDelayed(users[index]->email());
+    SetUserWallpaperDelayed(users[index]->GetUserID());
   }
 }
 
-bool WallpaperManager::GetUserWallpaperInfo(const std::string& user_id,
+bool WallpaperManager::GetUserWallpaperInfo(const user_manager::UserID& user_id,
                                             WallpaperInfo* info) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (user_manager::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* info_dict;
   if (!g_browser_process->local_state()
            ->GetDictionary(wallpaper::kUsersWallpaperInfo)
-           ->GetDictionaryWithoutPathExpansion(user_id, &info_dict)) {
+           ->GetDictionaryWithoutPathExpansion(user_id.GetUserEmail(), &info_dict)) {
     return false;
   }
 
   // Use temporary variables to keep |info| untouched in the error case.
   std::string location;
   if (!info_dict->GetString(kNewWallpaperLocationNodeName, &location))
     return false;
   int layout;
   if (!info_dict->GetInteger(kNewWallpaperLayoutNodeName, &layout))
     return false;
   int type;
   if (!info_dict->GetInteger(kNewWallpaperTypeNodeName, &type))
     return false;
   std::string date_string;
   if (!info_dict->GetString(kNewWallpaperDateNodeName, &date_string))
     return false;
   int64 date_val;
   if (!base::StringToInt64(date_string, &date_val))
     return false;
 
   info->location = location;
   info->layout = static_cast<wallpaper::WallpaperLayout>(layout);
   info->type = static_cast<user_manager::User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
 void WallpaperManager::OnWallpaperDecoded(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     wallpaper::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     const user_manager::UserImage& user_image) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
   if (user_image.image().isNull()) {
@@ skipping 12 matching lines @@
   // Update the image, but keep the path which was set earlier.
   wallpaper_cache_[user_id].second = user_image.image();
 
   if (update_wallpaper) {
     ash::Shell::GetInstance()
         ->desktop_background_controller()
         ->SetWallpaperImage(user_image.image(), layout);
   }
 }
 
-void WallpaperManager::StartLoad(const std::string& user_id,
+void WallpaperManager::StartLoad(const user_manager::UserID& user_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
   if (update_wallpaper) {
     // We are now about to change the wallpaper, so update the path and remove
     // the existing image.
     wallpaper_cache_[user_id] = CustomWallpaperElement(wallpaper_path,
@@ skipping 58 matching lines @@
                           rescaled_files->path_rescaled_large(),
                           large_wallpaper_image.Pass());
   VLOG(1) << "Customized default wallpaper applied.";
 }
 
 size_t WallpaperManager::GetPendingListSizeForTesting() const {
   return loading_.size();
 }
 
 void WallpaperManager::UserChangedChildStatus(user_manager::User* user) {
-  SetUserWallpaperNow(user->email());
+  SetUserWallpaperNow(user->GetUserID());
 }
 
 void WallpaperManager::OnDefaultWallpaperDecoded(
     const base::FilePath& path,
     const wallpaper::WallpaperLayout layout,
     scoped_ptr<user_manager::UserImage>* result_out,
     MovableOnDestroyCallbackHolder on_finish,
     const user_manager::UserImage& user_image) {
   result_out->reset(new user_manager::UserImage(user_image));
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
@@ skipping 49 matching lines @@
   } else {
     if (large_wallpaper_image) {
       default_wallpaper_image_.reset(
           new user_manager::UserImage(*large_wallpaper_image));
       default_wallpaper_image_->set_file_path(
           default_large_wallpaper_file.value());
     }
   }
 
   if (need_update_screen) {
-    DoSetDefaultWallpaper(std::string(),
+    DoSetDefaultWallpaper(user_manager::UserID(std::string(), std::string()),
                           MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 }  // namespace chromeos