Speed up custom wallpaper switching time and wallpaper manager code refactor

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/user_manager_impl.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
-#include "base/string_number_conversions.h"
-#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cert_library.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cryptohome/async_method_caller.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/login/user_image.h"
-#include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 13 matching lines @@
 
 namespace chromeos {
 
 namespace {
 
 // Names of nodes with info about user image.
 const char kImagePathNodeName[] = "path";
 const char kImageIndexNodeName[] = "index";
 const char kImageURLNodeName[] = "url";
 
-const char kWallpaperTypeNodeName[] = "type";
-const char kWallpaperIndexNodeName[] = "index";
-const char kWallpaperDateNodeName[] = "date";
-
-// Default wallpaper index used in OOBE (first boot).
-// Defined here because Chromium default index differs.
-// Also see ash::WallpaperInfo kDefaultWallpapers in
-// desktop_background_resources.cc
-#if defined(GOOGLE_CHROME_BUILD)
-const int kDefaultOOBEWallpaperIndex = 16; // IDR_AURA_WALLPAPERS_3_URBAN0
-#else
-const int kDefaultOOBEWallpaperIndex = 0;  // IDR_AURA_WALLPAPERS_ROMAINGUY_0
-#endif
-
-const int kThumbnailWidth = 128;
-const int kThumbnailHeight = 80;
-
 // Delay betweeen user login and attempt to update user's profile data.
 const long kProfileDataDownloadDelayMs = 10000;
 
 // Delay betweeen subsequent profile refresh attempts (24 hrs).
 const long kProfileRefreshIntervalMs = 24L * 3600 * 1000;
 
 // Enum for reporting histograms about profile picture download.
 enum ProfileDownloadResult {
   kDownloadSuccessChanged,
   kDownloadSuccess,
@@ skipping 104 matching lines @@
 
 }  // namespace
 
 UserManagerImpl::UserManagerImpl()
     : ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_(new UserImageLoader)),
       logged_in_user_(NULL),
       session_started_(false),
       is_current_user_owner_(false),
       is_current_user_new_(false),
       is_current_user_ephemeral_(false),
-      current_user_wallpaper_type_(User::UNKNOWN),
-      ALLOW_THIS_IN_INITIALIZER_LIST(current_user_wallpaper_index_(
-          ash::GetInvalidWallpaperIndex())),
       ephemeral_users_enabled_(false),
       observed_sync_service_(NULL),
       last_image_set_async_(false),
       downloaded_profile_image_data_url_(chrome::kAboutBlankURL),
       downloading_profile_image_(false) {
   // UserManager instance should be used only on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MigrateWallpaperData();
   registrar_.Add(this, chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
@@ skipping 63 matching lines @@
     logged_in_user_ = *logged_in_user;
     users_.erase(logged_in_user);
   }
   // This user must be in the front of the user list.
   users_.insert(users_.begin(), logged_in_user_);
 
   if (is_current_user_new_) {
     SaveUserDisplayName(GetLoggedInUser().email(),
         UTF8ToUTF16(GetLoggedInUser().GetAccountName(true)));
     SetInitialUserImage(email);
-    SetInitialUserWallpaper(email);
+    WallpaperManager::Get()->SetInitialUserWallpaper(email);
   } else {
     int image_index = logged_in_user_->image_index();
     // If current user image is profile image, it needs to be refreshed.
     bool download_profile_image = image_index == User::kProfileImageIndex;
     if (download_profile_image)
       InitDownloadedProfileImage();
 
     // Download user's profile data (full name and optionally image) to see if
     // it has changed.
     BrowserThread::PostDelayedTask(
@@ skipping 21 matching lines @@
                               kHistogramImagesCount);
   }
 
   // Set up a repeating timer for refreshing the profile data.
   profile_download_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kProfileRefreshIntervalMs),
       this, &UserManagerImpl::DownloadProfileDataScheduled);
 
   if (!browser_restart) {
     // For GAIA login flow, logged in user wallpaper may not be loaded.
-    EnsureLoggedInUserWallpaperLoaded();
+    WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
   }
 
   NotifyOnLogin();
 }
 
 void UserManagerImpl::DemoUserLoggedIn() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
   is_current_user_ephemeral_ = true;
   logged_in_user_ = CreateUser(kDemoUser, /* is_ephemeral= */ true);
   SetInitialUserImage(kDemoUser);
-  SetInitialUserWallpaper(kDemoUser);
+  WallpaperManager::Get()->SetInitialUserWallpaper(kDemoUser);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::GuestUserLoggedIn() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_ephemeral_ = true;
-  SetInitialUserWallpaper(kGuestUser);
+  WallpaperManager::Get()->SetInitialUserWallpaper(kGuestUser);
   logged_in_user_ = CreateUser(kGuestUser, /* is_ephemeral= */ true);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::EphemeralUserLoggedIn(const std::string& email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
   is_current_user_ephemeral_ = true;
   logged_in_user_ = CreateUser(email, /* is_ephemeral= */ true);
   SetInitialUserImage(email);
-  SetInitialUserWallpaper(email);
+  WallpaperManager::Get()->SetInitialUserWallpaper(email);
   NotifyOnLogin();
 }
 
-void UserManagerImpl::InitializeWallpaper() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!IsUserLoggedIn()) {
-    if (!CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kDisableNewOobe)) {
-      if (!WizardController::IsDeviceRegistered() &&
-          !WizardController::IsZeroDelayEnabled()) {
-        // TODO(nkostylev): Add switch to disable wallpaper transition on OOBE.
-        // Should be used on test images so that they are not slowed down.
-        ash::Shell::GetInstance()->desktop_background_controller()->
-            SetDefaultWallpaper(kDefaultOOBEWallpaperIndex);
-      } else {
-        bool show_users = true;
-        bool result = CrosSettings::Get()->GetBoolean(
-            kAccountsPrefShowUserNamesOnSignIn, &show_users);
-        DCHECK(result) << "Unable to fetch setting "
-                       << kAccountsPrefShowUserNamesOnSignIn;
-        if (!show_users) {
-          ash::Shell::GetInstance()->desktop_background_controller()->
-              SetDefaultWallpaper(ash::GetSolidColorIndex());
-        }
-      }
-    }
-    return;
-  }
-  UserSelected(GetLoggedInUser().email());
-}
-
-void UserManagerImpl::UserSelected(const std::string& email) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (IsKnownUser(email)) {
-    User::WallpaperType type;
-    int index;
-    base::Time date;
-    GetUserWallpaperProperties(email, &type, &index, &date);
-    if (type == User::DAILY && date != base::Time::Now().LocalMidnight()) {
-      index = ash::GetNextWallpaperIndex(index);
-      SaveUserWallpaperProperties(email, User::DAILY, index);
-    } else if (type == User::CUSTOMIZED) {
-      std::string wallpaper_path =
-          GetWallpaperPathForUser(email, false).value();
-      // In customized mode, we use index pref to save the user selected
-      // wallpaper layout. See function SaveWallpaperToLocalState().
-      ash::WallpaperLayout layout = static_cast<ash::WallpaperLayout>(index);
-      // Load user image asynchronously.
-      image_loader_->Start(
-          wallpaper_path, 0, false,
-          base::Bind(&UserManagerImpl::OnCustomWallpaperLoaded,
-                     base::Unretained(this), email, layout));
-      return;
-    }
-    ash::Shell::GetInstance()->desktop_background_controller()->
-        SetDefaultWallpaper(index);
-    WallpaperManager::Get()->SetLastSelectedUser(email);
-  }
-}
-
 void UserManagerImpl::SessionStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   session_started_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_STARTED,
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
 }
 
 void UserManagerImpl::RemoveUser(const std::string& email,
@@ skipping 170 matching lines @@
 
   // TODO(bshe): We current disabled the customized wallpaper feature for
   // Ephemeral user. As we dont want to keep a copy of customized wallpaper in
   // memory. Need a smarter way to solve this.
   if (IsCurrentUserEphemeral())
     return;
   const chromeos::User& user = GetLoggedInUser();
   std::string username = user.email();
   DCHECK(!username.empty());
 
-  std::string file_path = GetWallpaperPathForUser(username, false).value();
+  std::string file_path = WallpaperManager::Get()->
+      GetWallpaperPathForUser(username, false).value();
   SaveWallpaperToLocalState(username, file_path, layout, User::CUSTOMIZED);
   // Load wallpaper from file.
-  UserSelected(username);
+  WallpaperManager::Get()->OnUserSelected(username);
 }
 
 void UserManagerImpl::SaveUserImageFromFile(const std::string& username,
                                             const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   image_loader_->Start(
       path.value(), login::kMaxUserImageSize, true,
       base::Bind(&UserManagerImpl::SaveUserImage,
                  base::Unretained(this), username));
 }
 
-void UserManagerImpl::SaveUserWallpaperFromFile(
-    const std::string& username,
-    const FilePath& path,
-    ash::WallpaperLayout layout,
-    base::WeakPtr<WallpaperDelegate> delegate) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // For wallpapers, save the image without resizing.
-  image_loader_->Start(
-      path.value(), 0 /* Original size */, false,
-      base::Bind(&UserManagerImpl::SaveUserWallpaperInternal,
-                 base::Unretained(this), username, layout, User::CUSTOMIZED,
-                 delegate));
-}
-
 void UserManagerImpl::SaveUserImageFromProfileImage(
     const std::string& username) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!downloaded_profile_image_.empty()) {
     // Profile image has already been downloaded, so save it to file right now.
     DCHECK(profile_image_url_.is_valid());
     SaveUserImageInternal(username,
                           User::kProfileImageIndex, profile_image_url_,
                           UserImage(downloaded_profile_image_));
   } else {
@@ skipping 126 matching lines @@
     LocalStateChanged(this));
 }
 
 FilePath UserManagerImpl::GetImagePathForUser(const std::string& username) {
   std::string filename = username + ".png";
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   return user_data_dir.AppendASCII(filename);
 }
 
-FilePath UserManagerImpl::GetWallpaperPathForUser(const std::string& username,
-                                                  bool is_thumbnail) {
-  std::string filename = username +
-      (is_thumbnail ? "_wallpaper_thumb.png" : "_wallpaper.png");
-  FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  return user_data_dir.AppendASCII(filename);
-}
-
 void UserManagerImpl::EnsureUsersLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!users_.empty())
     return;
   if (!g_browser_process)
     return;
 
   PrefService* local_state = g_browser_process->local_state();
   const ListValue* prefs_users =
       local_state->GetList(UserManager::kLoggedInUsers);
   const DictionaryValue* prefs_images =
       local_state->GetDictionary(UserManager::kUserImages);
   const DictionaryValue* prefs_display_names =
       local_state->GetDictionary(UserManager::kUserDisplayName);
   const DictionaryValue* prefs_display_emails =
       local_state->GetDictionary(UserManager::kUserDisplayEmail);
 
   int user_image_size = GetCurrentUserImageSize();
 
   if (prefs_users) {
     for (ListValue::const_iterator it = prefs_users->begin();
          it != prefs_users->end(); ++it) {
       std::string email;
       if ((*it)->GetAsString(&email)) {
         User* user = CreateUser(email, /* is_ephemeral= */ false);
         users_.push_back(user);
 
+        WallpaperManager::Get()->CacheIfCustomWallpaper(email);
+
         if (prefs_images) {
           // Get account image path.
           // TODO(avayvod): Reading image path as a string is here for
           // backward compatibility.
           std::string image_path;
           const base::DictionaryValue* image_properties;
           if (prefs_images->GetStringWithoutPathExpansion(email, &image_path)) {
             int image_id = User::kInvalidImageIndex;
             if (IsDefaultImagePath(image_path, &image_id)) {
               user->SetImage(UserImage(GetDefaultImage(image_id)), image_id);
@@ skipping 56 matching lines @@
         if (prefs_display_emails &&
             prefs_display_emails->GetStringWithoutPathExpansion(
                 email, &display_email)) {
           user->set_display_email(display_email);
         }
       }
     }
   }
 }
 
-void UserManagerImpl::EnsureLoggedInUserWallpaperLoaded() {
-  User::WallpaperType type;
-  int index;
-  base::Time last_modification_date;
-  GetLoggedInUserWallpaperProperties(&type, &index, &last_modification_date);
-
-  if (type != current_user_wallpaper_type_ ||
-      index != current_user_wallpaper_index_)
-    UserSelected(GetLoggedInUser().email());
-}
-
 void UserManagerImpl::RetrieveTrustedDevicePolicies() {
   ephemeral_users_enabled_ = false;
   owner_email_ = "";
 
   CrosSettings* cros_settings = CrosSettings::Get();
   // Schedule a callback if device policy has not yet been verified.
   if (CrosSettingsProvider::TRUSTED != cros_settings->PrepareTrustedValues(
       base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
                  base::Unretained(this)))) {
     return;
@@ skipping 81 matching lines @@
                           base::Bind(&UserManagerImpl::CheckOwnership,
                                      base::Unretained(this)));
 }
 
 void UserManagerImpl::SetInitialUserImage(const std::string& username) {
   // Choose a random default image.
   int image_id = base::RandInt(0, kDefaultImagesCount - 1);
   SaveUserDefaultImageIndex(username, image_id);
 }
 
-void UserManagerImpl::SetInitialUserWallpaper(const std::string& username) {
-  current_user_wallpaper_type_ = User::DEFAULT;
-  // TODO(bshe): Ideally, wallpaper should start to load as soon as user click
-  // "Add user".
-  if (username == kGuestUser)
-    current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
-  else
-    current_user_wallpaper_index_ = ash::GetDefaultWallpaperIndex();
-  SaveUserWallpaperProperties(username,
-                              current_user_wallpaper_type_,
-                              current_user_wallpaper_index_);
-
-  // Some browser tests do not have shell instance. And it is not necessary to
-  // create a wallpaper for these tests. Add HasInstance check to prevent tests
-  // crash and speed up the tests by avoid loading wallpaper.
-  if (ash::Shell::HasInstance()) {
-    ash::Shell::GetInstance()->desktop_background_controller()->
-        SetDefaultWallpaper(current_user_wallpaper_index_);
-  }
-}
-
 void UserManagerImpl::MigrateWallpaperData() {
   PrefService* local_state = g_browser_process->local_state();
   if (local_state) {
     const DictionaryValue* user_wallpapers =
           local_state->GetDictionary(kUserWallpapers);
     int index;
     const DictionaryValue* new_user_wallpapers =
         local_state->GetDictionary(kUserWallpapersProperties);
     if (new_user_wallpapers->empty()) {
       const UserList& users = GetUsers();
       for (UserList::const_iterator it = users.begin();
            it != users.end();
            ++it) {
         std::string username = (*it)->email();
         if (user_wallpapers->GetIntegerWithoutPathExpansion((username),
             &index)) {
           DictionaryPrefUpdate prefs_wallpapers_update(local_state,
                                                        kUserWallpapers);
           prefs_wallpapers_update->RemoveWithoutPathExpansion(username, NULL);
-          SaveUserWallpaperProperties(username, User::DEFAULT, index);
+          WallpaperManager::Get()->SaveUserWallpaperProperties(username,
+                                                               User::DEFAULT,
+                                                               index);
         } else {
           // Before M20, wallpaper index is not saved into LocalState unless
           // user specifically sets a wallpaper. After M20, the default
           // wallpaper index is saved to LocalState as soon as a new user login.
           // When migrating wallpaper index from M20 to M21, we only migrate
           // data that is in LocalState. This cause a problem when users login
           // on a M20 device and then update the device to M21. The default
           // wallpaper index failed to migrate because it was not saved into
           // LocalState. Then we assume that all users have index saved in
           // LocalState in M21. This is not true and it results an empty
           // wallpaper for those users as described in cr/130685. So here we use
           // default wallpaper for users that exist in user list but does not
           // have an index saved in LocalState.
-          SaveUserWallpaperProperties(username, User::DEFAULT,
-                                      ash::GetDefaultWallpaperIndex());
+          WallpaperManager::Get()->SaveUserWallpaperProperties(username,
+              User::DEFAULT, ash::GetDefaultWallpaperIndex());
         }
       }
     }
   }
 }
 
-void UserManagerImpl::GetLoggedInUserWallpaperProperties(
-    User::WallpaperType* type,
-    int* index,
-    base::Time* last_modification_date) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(logged_in_user_);
-
-  if (IsLoggedInAsStub()) {
-    *type = current_user_wallpaper_type_ = User::DEFAULT;
-    *index = current_user_wallpaper_index_ = ash::GetInvalidWallpaperIndex();
-    return;
-  }
-
-  GetUserWallpaperProperties(GetLoggedInUser().email(),
-                             type,
-                             index,
-                             last_modification_date);
-}
-
 void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
-    User::WallpaperType type,
-    int index) {
-  SaveUserWallpaperProperties(GetLoggedInUser().email(), type, index);
+    User::WallpaperType type, int index) {
+  WallpaperManager::Get()->SaveUserWallpaperProperties(
+      GetLoggedInUser().email(), type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
                                    int image_index,
                                    const GURL& image_url,
                                    const UserImage& user_image) {
   User* user = const_cast<User*>(FindUser(username));
   // User may have been removed by now.
   if (user) {
     // For existing users, a valid image index should have been set upon loading
@@ skipping 14 matching lines @@
       // Unless this is first-time setting with |SetInitialUserImage|,
       // send a notification about image change.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
           content::Source<UserManagerImpl>(this),
           content::Details<const User>(user));
     }
   }
 }
 
-void UserManagerImpl::GetUserWallpaperProperties(const std::string& username,
-    User::WallpaperType* type,
-    int* index,
-    base::Time* last_modification_date) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // Default to the values cached in memory.
-  *type = current_user_wallpaper_type_;
-  *index = current_user_wallpaper_index_;
-
-  // Override with values found in local store, if any.
-  if (!username.empty()) {
-    const DictionaryValue* user_wallpapers = g_browser_process->local_state()->
-        GetDictionary(UserManager::kUserWallpapersProperties);
-    const base::DictionaryValue* wallpaper_properties;
-    if (user_wallpapers->GetDictionaryWithoutPathExpansion(
-        username,
-        &wallpaper_properties)) {
-      *type = User::UNKNOWN;
-      *index = ash::GetInvalidWallpaperIndex();
-      wallpaper_properties->GetInteger(kWallpaperTypeNodeName,
-                                       reinterpret_cast<int*>(type));
-      wallpaper_properties->GetInteger(kWallpaperIndexNodeName, index);
-      std::string date_string;
-      int64 val;
-      if (!(wallpaper_properties->GetString(kWallpaperDateNodeName,
-                                            &date_string) &&
-            base::StringToInt64(date_string, &val)))
-        val = 0;
-      *last_modification_date = base::Time::FromInternalValue(val);
-    }
-  }
-}
-
-void UserManagerImpl::SaveUserWallpaperProperties(const std::string& username,
-                                                  User::WallpaperType type,
-                                                  int index) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  current_user_wallpaper_type_ = type;
-  current_user_wallpaper_index_ = index;
-  // Ephemeral users can not save data to local state. We just cache the index
-  // in memory for them.
-  if (IsCurrentUserEphemeral()) {
-    return;
-  }
-
-  PrefService* local_state = g_browser_process->local_state();
-  DictionaryPrefUpdate wallpaper_update(local_state,
-      UserManager::kUserWallpapersProperties);
-
-  base::DictionaryValue* wallpaper_properties = new base::DictionaryValue();
-  wallpaper_properties->Set(kWallpaperTypeNodeName,
-                            new base::FundamentalValue(type));
-  wallpaper_properties->Set(kWallpaperIndexNodeName,
-                            new base::FundamentalValue(index));
-  wallpaper_properties->SetString(kWallpaperDateNodeName,
-      base::Int64ToString(base::Time::Now().LocalMidnight().ToInternalValue()));
-  wallpaper_update->SetWithoutPathExpansion(username, wallpaper_properties);
-}
-
 void UserManagerImpl::SaveUserImageInternal(const std::string& username,
                                             int image_index,
                                             const GURL& image_url,
                                             const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetUserImage(username, image_index, image_url, user_image);
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
 
   FilePath image_path = GetImagePathForUser(username);
   DVLOG(1) << "Saving user image to " << image_path.value();
 
   last_image_set_async_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToFile,
                  base::Unretained(this),
                  username, user_image, image_path, image_index, image_url));
 }
 
-void UserManagerImpl::SaveUserWallpaperInternal(
-    const std::string& username,
-    ash::WallpaperLayout layout,
-    User::WallpaperType type,
-    base::WeakPtr<WallpaperDelegate> delegate,
-    const UserImage& user_image) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  const SkBitmap& wallpaper = user_image.image();
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&UserManagerImpl::GenerateUserWallpaperThumbnail,
-                 base::Unretained(this), username, type, delegate, wallpaper));
-
-  ash::Shell::GetInstance()->desktop_background_controller()->
-      SetCustomWallpaper(wallpaper, layout);
-
-  // Ignore for ephemeral users.
-  if (IsEphemeralUser(username))
-    return;
-
-  FilePath wallpaper_path = GetWallpaperPathForUser(username, false);
-  DVLOG(1) << "Saving user image to " << wallpaper_path.value();
-
-  last_image_set_async_ = true;
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&UserManagerImpl::SaveWallpaperToFile,
-                 base::Unretained(this), username, wallpaper, wallpaper_path,
-                 layout, User::CUSTOMIZED));
-}
-
-void UserManagerImpl::OnCustomWallpaperLoaded(const std::string& email,
-                                              ash::WallpaperLayout layout,
-                                              const UserImage& user_image) {
-  const SkBitmap& wallpaper = user_image.image();
-  ash::Shell::GetInstance()->desktop_background_controller()->
-      SetCustomWallpaper(wallpaper, layout);
-  // Starting to load wallpaper thumbnail
-  std::string wallpaper_thumbnail_path =
-      GetWallpaperPathForUser(email, true).value();
-  image_loader_->Start(
-      wallpaper_thumbnail_path, 0, false,
-      base::Bind(&UserManagerImpl::OnCustomWallpaperThumbnailLoaded,
-      base::Unretained(this), email));
-}
-
-void UserManagerImpl::OnCustomWallpaperThumbnailLoaded(
-    const std::string& email,
-    const UserImage& user_image) {
-  const SkBitmap& wallpaper = user_image.image();
-  User* user = const_cast<User*>(FindUser(email));
-  // User may have been removed by now.
-  if (user && !wallpaper.empty())
-    user->SetWallpaperThumbnail(wallpaper);
-}
-
-void UserManagerImpl::OnThumbnailUpdated(
-    base::WeakPtr<WallpaperDelegate> delegate) {
-  if (delegate)
-    delegate->SetCustomWallpaperThumbnail();
-}
-
-void UserManagerImpl::GenerateUserWallpaperThumbnail(
-    const std::string& username,
-    User::WallpaperType type,
-    base::WeakPtr<WallpaperDelegate> delegate,
-    const SkBitmap& wallpaper) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  SkBitmap thumbnail =
-      skia::ImageOperations::Resize(wallpaper,
-                                    skia::ImageOperations::RESIZE_LANCZOS3,
-                                    kThumbnailWidth, kThumbnailHeight);
-  logged_in_user_->SetWallpaperThumbnail(thumbnail);
-
-  // Notify thumbnail is ready.
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&UserManagerImpl::OnThumbnailUpdated,
-                 base::Unretained(this), delegate));
-
-  // Ignore for ephemeral users.
-  if (IsEphemeralUser(username))
-    return;
-
-  FilePath thumbnail_path = GetWallpaperPathForUser(username, true);
-  SaveBitmapToFile(UserImage(thumbnail), thumbnail_path);
-}
-
 void UserManagerImpl::SaveImageToFile(const std::string& username,
                                       const UserImage& user_image,
                                       const FilePath& image_path,
                                       int image_index,
                                       const GURL& image_url) {
   if (!SaveBitmapToFile(user_image, image_path))
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToLocalState,
                  base::Unretained(this),
                  username, image_path.value(), image_index, image_url, true));
 }
 
-void UserManagerImpl::SaveWallpaperToFile(const std::string& username,
-                                          const SkBitmap& wallpaper,
-                                          const FilePath& wallpaper_path,
-                                          ash::WallpaperLayout layout,
-                                          User::WallpaperType type) {
-  // TODO(bshe): We should save the original file unchanged instead of
-  // re-encoding it and saving it.
-  if (!SaveBitmapToFile(UserImage(wallpaper), wallpaper_path))
-    return;
-
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&UserManagerImpl::SaveWallpaperToLocalState,
-                 base::Unretained(this),
-                 username, wallpaper_path.value(), layout, type));
-}
-
 void UserManagerImpl::SaveImageToLocalState(const std::string& username,
                                             const std::string& image_path,
                                             int image_index,
                                             const GURL& image_url,
                                             bool is_async) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
@@ skipping 25 matching lines @@
   DVLOG(1) << "Saving path to user image in Local State.";
 
   NotifyLocalStateChanged();
 }
 
 void UserManagerImpl::SaveWallpaperToLocalState(const std::string& username,
     const std::string& wallpaper_path,
     ash::WallpaperLayout layout,
     User::WallpaperType type) {
   // TODO(bshe): We probably need to save wallpaper_path instead of index.
-  SaveUserWallpaperProperties(username, type, layout);
+  WallpaperManager::Get()->SaveUserWallpaperProperties(username, type, layout);
 }
 
 bool UserManagerImpl::SaveBitmapToFile(const UserImage& user_image,
                                        const FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   const UserImage::RawImage* encoded_image = NULL;
   if (user_image.has_animated_image()) {
     encoded_image = &user_image.animated_image();
   } else if (user_image.has_raw_image()) {
@@ skipping 227 matching lines @@
       prefs_users_update->Append(Value::CreateStringValue(user_email));
     else
       user_to_remove = it;
   }
 
   DictionaryPrefUpdate prefs_wallpapers_update(prefs,
                                                kUserWallpapersProperties);
   prefs_wallpapers_update->RemoveWithoutPathExpansion(email, NULL);
 
   // Remove user wallpaper thumbnail
-  FilePath wallpaper_thumb_path = GetWallpaperPathForUser(email, true);
+  FilePath wallpaper_thumb_path = WallpaperManager::Get()->
+      GetWallpaperPathForUser(email, true);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UserManagerImpl::DeleteUserImage,
                  base::Unretained(this),
                  wallpaper_thumb_path));
   // Remove user wallpaper
-  FilePath wallpaper_path = GetWallpaperPathForUser(email, false);
+  FilePath wallpaper_path = WallpaperManager::Get()->
+      GetWallpaperPathForUser(email, false);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UserManagerImpl::DeleteUserImage,
                  base::Unretained(this),
                  wallpaper_path));
 
   DictionaryPrefUpdate prefs_images_update(prefs, kUserImages);
   std::string image_path_string;
   prefs_images_update->GetStringWithoutPathExpansion(email, &image_path_string);
@@ skipping 22 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos