This CL replaces e-mail with AccountId in wallpaper manager code.

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 @@
 // Enqueued but not started request might be updated by subsequent load
 // request. Therefore it's created empty, and updated being enqueued.
 //
 // 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)
-      : user_id_(user_id),
+  PendingWallpaper(const base::TimeDelta delay, const AccountId& account_id)
+      : account_id_(account_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 46 matching lines @@
 
     timer.Stop();  // Erase reference to self.
 
     WallpaperManager* manager = WallpaperManager::Get();
     if (manager->pending_inactive_ == this)
       manager->pending_inactive_ = NULL;
 
     started_load_at_ = base::Time::Now();
 
     if (default_) {
-      manager->DoSetDefaultWallpaper(user_id_, on_finish_.Pass());
+      manager->DoSetDefaultWallpaper(account_id_, on_finish_.Pass());
     } else if (!user_wallpaper_.isNull()) {
       ash::Shell::GetInstance()
           ->desktop_background_controller()
           ->SetWallpaperImage(user_wallpaper_, info_.layout);
     } else if (!wallpaper_path_.empty()) {
       manager->task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
-                     user_id_,
-                     info_,
-                     wallpaper_path_,
-                     true /* update wallpaper */,
+          base::Bind(&WallpaperManager::GetCustomWallpaperInternal, account_id_,
+                     info_, wallpaper_path_, true /* update wallpaper */,
                      base::Passed(on_finish_.Pass()),
                      manager->weak_factory_.GetWeakPtr()));
     } else if (!info_.location.empty()) {
-      manager->LoadWallpaper(user_id_, info_, true, on_finish_.Pass());
+      manager->LoadWallpaper(account_id_, info_, true, on_finish_.Pass());
     } else {
       // PendingWallpaper was created and never initialized?
       NOTREACHED();
       // Error. Do not record time.
       started_load_at_ = base::Time();
     }
     on_finish_.reset();
   }
 
   // This method is called by callback, when load request is finished.
@@ skipping 14 matching lines @@
     }
     if (manager->pending_inactive_ == this) {
       // ProcessRequest() was never executed.
       manager->pending_inactive_ = NULL;
     }
 
     // Destroy self.
     manager->RemovePendingWallpaperFromList(this);
   }
 
-  std::string user_id_;
+  AccountId account_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()->GetAccountId());
 }
 
 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(login::SignInAccountId().GetUserEmail());
+      SetDefaultWallpaperDelayed(login::SignInAccountId());
     else
       InitializeRegisteredDeviceWallpaper();
     return;
   }
-  SetUserWallpaperDelayed(user_manager->GetLoggedInUser()->email());
+  SetUserWallpaperDelayed(user_manager->GetLoggedInUser()->GetAccountId());
 }
 
 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) {
-  if (wallpaper_cache_.find(user_id) != wallpaper_cache_.end())
-    wallpaper_cache_.erase(user_id);
+void WallpaperManager::RemoveUserWallpaperInfo(const AccountId& account_id) {
+  if (wallpaper_cache_.find(account_id) != wallpaper_cache_.end())
+    wallpaper_cache_.erase(account_id);
 
   PrefService* prefs = g_browser_process->local_state();
   // PrefService could be NULL in tests.
   if (!prefs)
     return;
   WallpaperInfo info;
-  GetUserWallpaperInfo(user_id, &info);
+  GetUserWallpaperInfo(account_id, &info);
   DictionaryPrefUpdate prefs_wallpapers_info_update(
       prefs, wallpaper::kUsersWallpaperInfo);
-  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
-  DeleteUserWallpapers(user_id, info.location);
+  prefs_wallpapers_info_update->RemoveWithoutPathExpansion(
+      account_id.GetUserEmail(), NULL);
+  DeleteUserWallpapers(account_id, info.location);
 }
 
 void WallpaperManager::OnPolicyFetched(const std::string& policy,
-                                       const std::string& user_id,
+                                       const AccountId& account_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));
+                 weak_factory_.GetWeakPtr(), account_id));
 }
 
 void WallpaperManager::SetCustomWallpaper(
-    const std::string& user_id,
+    const AccountId& account_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())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
-  if (type != user_manager::User::POLICY && IsPolicyControlled(user_id))
+  if (type != user_manager::User::POLICY && IsPolicyControlled(account_id))
     return;
 
   base::FilePath wallpaper_path = GetCustomWallpaperPath(
       wallpaper::kOriginalWallpaperSubDir, user_id_hash, file);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
   if (image.isNull()) {
-    SetDefaultWallpaperDelayed(user_id);
+    SetDefaultWallpaperDelayed(account_id);
     return;
   }
 
-  const user_manager::User* user = user_manager::UserManager::Get()->FindUser(
-      AccountId::FromUserEmail(user_id));
+  const user_manager::User* user =
+      user_manager::UserManager::Get()->FindUser(account_id);
   CHECK(user);
   const bool is_persistent =
       !user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
-          AccountId::FromUserEmail(user_id)) ||
+          account_id) ||
       (type == user_manager::User::POLICY &&
        user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
 
   WallpaperInfo wallpaper_info = {
       wallpaper_path.value(),
       layout,
       type,
       // Date field is not used.
       base::Time::Now().LocalMidnight()
   };
@@ skipping 18 matching lines @@
 
   std::string relative_path = base::FilePath(user_id_hash).Append(file).value();
   // User's custom wallpaper path is determined by relative path and the
   // appropriate wallpaper resolution in GetCustomWallpaperInternal.
   WallpaperInfo info = {
       relative_path,
       layout,
       type,
       base::Time::Now().LocalMidnight()
   };
-  SetUserWallpaperInfo(user_id, info, is_persistent);
+  SetUserWallpaperInfo(account_id, info, is_persistent);
   if (update_wallpaper) {
-    GetPendingWallpaper(user_id, false)->ResetSetWallpaperImage(image, info);
+    GetPendingWallpaper(account_id, false)->ResetSetWallpaperImage(image, info);
   }
 
-  wallpaper_cache_[user_id] = CustomWallpaperElement(wallpaper_path, image);
+  wallpaper_cache_[account_id] = CustomWallpaperElement(wallpaper_path, image);
 }
 
-void WallpaperManager::SetDefaultWallpaperNow(const std::string& user_id) {
-  GetPendingWallpaper(user_id, false)->ResetSetDefaultWallpaper();
+void WallpaperManager::SetDefaultWallpaperNow(const AccountId& account_id) {
+  GetPendingWallpaper(account_id, false)->ResetSetDefaultWallpaper();
 }
 
-void WallpaperManager::SetDefaultWallpaperDelayed(const std::string& user_id) {
-  GetPendingWallpaper(user_id, true)->ResetSetDefaultWallpaper();
+void WallpaperManager::SetDefaultWallpaperDelayed(const AccountId& account_id) {
+  GetPendingWallpaper(account_id, true)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::DoSetDefaultWallpaper(
-    const std::string& user_id,
+    const AccountId& account_id,
     MovableOnDestroyCallbackHolder on_finish) {
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
-  wallpaper_cache_.erase(user_id);
+  wallpaper_cache_.erase(account_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;
 
   WallpaperResolution resolution = GetAppropriateResolution();
   const bool use_small = (resolution == WALLPAPER_RESOLUTION_SMALL);
 
   const base::FilePath* file = NULL;
 
-  const user_manager::User* user = user_manager::UserManager::Get()->FindUser(
-      AccountId::FromUserEmail(user_id));
+  const user_manager::User* user =
+      user_manager::UserManager::Get()->FindUser(account_id);
 
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) {
     file =
         use_small ? &guest_small_wallpaper_file_ : &guest_large_wallpaper_file_;
   } else if (user && user->GetType() == user_manager::USER_TYPE_CHILD) {
     file =
         use_small ? &child_small_wallpaper_file_ : &child_large_wallpaper_file_;
   } else {
     file = use_small ? &default_small_wallpaper_file_
                      : &default_large_wallpaper_file_;
@@ skipping 16 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 AccountId& account_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(account_id.GetUserEmail(),
+                                            wallpaper_info_dict);
 }
 
-void WallpaperManager::ScheduleSetUserWallpaper(const std::string& user_id,
+void WallpaperManager::ScheduleSetUserWallpaper(const AccountId& account_id,
                                                 bool delayed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Some unit tests come here without a UserManager or without a pref system.
   if (!user_manager::UserManager::IsInitialized() ||
       !g_browser_process->local_state()) {
     return;
   }
 
-  const AccountId account_id = AccountId::FromUserEmail(user_id);
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
 
   // User is unknown or there is no visible background in kiosk mode.
   if (!user || user->GetType() == user_manager::USER_TYPE_KIOSK_APP)
     return;
 
   // Guest user or regular user in ephemeral mode.
   if ((user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
            account_id) &&
        user->HasGaiaAccount()) ||
       user->GetType() == user_manager::USER_TYPE_GUEST) {
     LOG(ERROR) << "User is ephemeral or guest! Fallback to default wallpaper.";
-    InitInitialUserWallpaper(user_id, false);
-    GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
+    InitInitialUserWallpaper(account_id, false);
+    GetPendingWallpaper(account_id, delayed)->ResetSetDefaultWallpaper();
     return;
   }
 
-  last_selected_user_ = user_id;
+  last_selected_user_ = account_id;
 
   WallpaperInfo info;
 
-  if (!GetUserWallpaperInfo(user_id, &info)) {
-    InitInitialUserWallpaper(user_id, true);
-    GetUserWallpaperInfo(user_id, &info);
+  if (!GetUserWallpaperInfo(account_id, &info)) {
+    InitInitialUserWallpaper(account_id, true);
+    GetUserWallpaperInfo(account_id, &info);
   }
 
   gfx::ImageSkia user_wallpaper;
   current_user_wallpaper_info_ = info;
-  if (GetWallpaperFromCache(user_id, &user_wallpaper)) {
-    GetPendingWallpaper(user_id, delayed)
+  if (GetWallpaperFromCache(account_id, &user_wallpaper)) {
+    GetPendingWallpaper(account_id, delayed)
         ->ResetSetWallpaperImage(user_wallpaper, info);
   } else {
     if (info.location.empty()) {
       // Uses default built-in wallpaper when file is empty. Eventually, we
       // will only ship one built-in wallpaper in ChromeOS image.
-      GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
+      GetPendingWallpaper(account_id, delayed)->ResetSetDefaultWallpaper();
       return;
     }
 
     if (info.type == user_manager::User::CUSTOMIZED ||
         info.type == user_manager::User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       // Wallpaper is not resized when layout is
       // wallpaper::WALLPAPER_LAYOUT_CENTER.
       // Original wallpaper should be used in this case.
       // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
       if (info.layout == wallpaper::WALLPAPER_LAYOUT_CENTER)
         sub_dir = wallpaper::kOriginalWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.location);
-      CustomWallpaperMap::iterator it = wallpaper_cache_.find(user_id);
+      CustomWallpaperMap::iterator it = wallpaper_cache_.find(account_id);
       // Do not try to load the wallpaper if the path is the same. Since loading
       // could still be in progress, we ignore the existence of the image.
       if (it != wallpaper_cache_.end() && it->second.first == wallpaper_path)
         return;
 
       // Set the new path and reset the existing image - the image will be
       // added once it becomes available.
-      wallpaper_cache_[user_id] =
+      wallpaper_cache_[account_id] =
           CustomWallpaperElement(wallpaper_path, gfx::ImageSkia());
       loaded_wallpapers_for_test_++;
 
-      GetPendingWallpaper(user_id, delayed)
+      GetPendingWallpaper(account_id, delayed)
           ->ResetSetCustomWallpaper(info, wallpaper_path);
       return;
     }
 
     // Load downloaded ONLINE or converted DEFAULT wallpapers.
-    GetPendingWallpaper(user_id, delayed)->ResetLoadWallpaper(info);
+    GetPendingWallpaper(account_id, delayed)->ResetLoadWallpaper(info);
   }
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(
-    const std::string& user_id,
+    const AccountId& account_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;
 
   // This is an API call and we do not know the path. So we set the image, but
   // no path.
-  wallpaper_cache_[user_id] = CustomWallpaperElement(base::FilePath(), image);
+  wallpaper_cache_[account_id] =
+      CustomWallpaperElement(base::FilePath(), image);
 
   if (update_wallpaper) {
     GetPendingWallpaper(last_selected_user_, false /* Not delayed */)
         ->ResetSetWallpaperImage(image, info);
   }
 }
 
 
 // WallpaperManager, private: --------------------------------------------------
 
@@ skipping 16 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 AccountId& account_id,
     bool delayed) {
   if (!pending_inactive_) {
     loading_.push_back(new WallpaperManager::PendingWallpaper(
         (delayed ? GetWallpaperLoadDelay()
                  : base::TimeDelta::FromMilliseconds(0)),
-        user_id));
+        account_id));
     pending_inactive_ = loading_.back().get();
   }
   return pending_inactive_;
 }
 
 void WallpaperManager::RemovePendingWallpaperFromList(
     PendingWallpaper* pending) {
   DCHECK(loading_.size() > 0);
   for (WallpaperManager::PendingList::iterator i = loading_.begin();
        i != loading_.end();
@@ skipping 17 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(login::SignInAccountId().GetUserEmail());
+    SetDefaultWallpaperDelayed(login::SignInAccountId());
     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]->GetAccountId());
   }
 }
 
-bool WallpaperManager::GetUserWallpaperInfo(const std::string& user_id,
+bool WallpaperManager::GetUserWallpaperInfo(const AccountId& account_id,
                                             WallpaperInfo* info) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
-          AccountId::FromUserEmail(user_id))) {
+          account_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(account_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 AccountId& account_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()) {
     // Updates user pref to default wallpaper.
     WallpaperInfo info = {"",
                           wallpaper::WALLPAPER_LAYOUT_CENTER_CROPPED,
                           user_manager::User::DEFAULT,
                           base::Time::Now().LocalMidnight()};
-    SetUserWallpaperInfo(user_id, info, true);
+    SetUserWallpaperInfo(account_id, info, true);
 
     if (update_wallpaper)
-      DoSetDefaultWallpaper(user_id, on_finish.Pass());
+      DoSetDefaultWallpaper(account_id, on_finish.Pass());
     return;
   }
 
   // Update the image, but keep the path which was set earlier.
-  wallpaper_cache_[user_id].second = user_image.image();
+  wallpaper_cache_[account_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 AccountId& account_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,
-                                                       gfx::ImageSkia());
+    wallpaper_cache_[account_id] =
+        CustomWallpaperElement(wallpaper_path, gfx::ImageSkia());
   }
-  wallpaper_loader_->Start(wallpaper_path.value(),
-                           0,  // Do not crop.
-                           base::Bind(&WallpaperManager::OnWallpaperDecoded,
-                                      weak_factory_.GetWeakPtr(),
-                                      user_id,
-                                      info.layout,
-                                      update_wallpaper,
-                                      base::Passed(on_finish.Pass())));
+  wallpaper_loader_->Start(
+      wallpaper_path.value(),
+      0,  // Do not crop.
+      base::Bind(&WallpaperManager::OnWallpaperDecoded,
+                 weak_factory_.GetWeakPtr(), account_id, info.layout,
+                 update_wallpaper, base::Passed(on_finish.Pass())));
 }
 
 void WallpaperManager::SetCustomizedDefaultWallpaperAfterCheck(
     const GURL& wallpaper_url,
     const base::FilePath& downloaded_file,
     scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files) {
   PrefService* pref_service = g_browser_process->local_state();
 
   std::string current_url =
       pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
@@ skipping 38 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->GetAccountId());
 }
 
 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(EmptyAccountId(),
                           MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 }  // namespace chromeos