Implement user selected wallpaper feature.

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"
@@ skipping 36 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/url_constants.h"
 #include "crypto/nss_util.h"
+#include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 using content::BrowserThread;
 
 typedef GoogleServiceAuthError AuthError;
 
 namespace chromeos {
 
 namespace {
 
 // Incognito user is represented by an empty string (since some code already
 // depends on that and it's hard to figure out what).
 const char kGuestUser[] = "";
 
 // Stub user email (for test paths).
 const char kStubUser[] = "stub-user@example.com";
 
 // Names of nodes with info about user image.
 const char kImagePathNodeName[] = "path";
 const char kImageIndexNodeName[] = "index";
 
 const char kWallpaperTypeNodeName[] = "type";
 const char kWallpaperIndexNodeName[] = "index";
 
+const int kThumbnailWidth = 128;
+const int kThumbnailHeight = 80;
+
 // Index of the default image used for the |kStubUser| user.
 const int kStubDefaultImageIndex = 0;
 
 // Delay betweeen user login and attempt to update user's profile image.
 const long kProfileImageDownloadDelayMs = 10000;
 
 // Enum for reporting histograms about profile picture download.
 enum ProfileDownloadResult {
   kDownloadSuccessChanged,
   kDownloadSuccess,
@@ skipping 361 matching lines @@
 void UserManagerImpl::UserSelected(const std::string& email) {
   if (IsKnownUser(email)) {
     int index;
     User::WallpaperType type;
     GetUserWallpaperProperties(email, type, index);
     if (type == User::RANDOM) {
       // Generate a new random wallpaper index if the selected user chose
       // RANDOM wallpaper.
       index = ash::GetRandomWallpaperIndex();
       SaveUserWallpaperProperties(email, User::RANDOM, 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,
+          base::Bind(&UserManagerImpl::LoadCustomWallpaperThumbnail,
+              base::Unretained(this),
+              email,
+              layout));
+      return;
     }
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(index);
   }
 }
 
 void UserManagerImpl::SessionStarted() {
   session_started_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_STARTED,
@@ skipping 129 matching lines @@
   DCHECK(image_index >= 0 && image_index < kDefaultImagesCount);
   SetUserImage(username, image_index, GetDefaultImage(image_index));
   SaveImageToLocalState(username, "", image_index, false);
 }
 
 void UserManagerImpl::SaveUserImage(const std::string& username,
                                     const SkBitmap& image) {
   SaveUserImageInternal(username, User::kExternalImageIndex, image);
 }
 
+void UserManagerImpl::SetLoggedInUserCustomWallpaperLayout(
+    ash::WallpaperLayout layout) {
+  // 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();
+  SaveWallpaperToLocalState(username, file_path, layout, User::CUSTOMIZED);
+  // Load wallpaper from file.
+  UserSelected(username);
+}
+
 void UserManagerImpl::SaveUserImageFromFile(const std::string& username,
                                             const FilePath& path) {
   image_loader_->Start(
       path.value(), login::kUserImageSize,
       base::Bind(&UserManagerImpl::SaveUserImage,
                  base::Unretained(this), username));
 }
 
+void UserManagerImpl::SaveUserWallpaperFromFile(const std::string& username,
+                                                const FilePath& path,
+                                                ash::WallpaperLayout layout) {
+  // For wallpapers, save the image without resize.
+  LOG(ERROR) << "---------------Start to load file--------" << path.value();
+  image_loader_->Start(
+      path.value(), 0 /* Original size */,
+      base::Bind(&UserManagerImpl::SaveUserWallpaperInternal,
+                 base::Unretained(this), username, layout, User::CUSTOMIZED));
+}
+
 void UserManagerImpl::SaveUserImageFromProfileImage(
     const std::string& username) {
   if (!downloaded_profile_image_.empty()) {
     // Profile image has already been downloaded, so save it to file right now.
     SaveUserImageInternal(username, User::kProfileImageIndex,
                           downloaded_profile_image_);
   } else {
     // No profile image - use the stub image (gray avatar).
     SetUserImage(username, User::kProfileImageIndex, SkBitmap());
     SaveImageToLocalState(username, "", User::kProfileImageIndex, false);
@@ skipping 117 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);
@@ skipping 153 matching lines @@
       content::Details<const User>(logged_in_user_));
 
   LoadKeyStore();
 
   // Schedules current user ownership check on file thread.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&UserManagerImpl::CheckOwnership,
                                      base::Unretained(this)));
 }
 
+void UserManagerImpl::NotifyThumbnailUpdated() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_LOGIN_USER_WALLPAPER_THUMBNAIL_UPDATED,
+      content::Source<UserManagerImpl>(this),
+      content::NotificationService::NoDetails());
+}
+
 void UserManagerImpl::LoadKeyStore() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (key_store_loaded_)
     return;
 
   // Ensure we've opened the real user's key/certificate database.
   crypto::OpenPersistentNSSDB();
 
   // Only load the Opencryptoki library into NSS if we have this switch.
   // TODO(gspencer): Remove this switch once cryptohomed work is finished:
@@ skipping 95 matching lines @@
 }
 
 void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
     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() || !IsUserLoggedIn()) {
+  if (IsCurrentUserEphemeral() || !IsUserLoggedIn())
     return;
-  }
 
   const chromeos::User& user = GetLoggedInUser();
   std::string username = user.email();
   DCHECK(!username.empty());
 
   SaveUserWallpaperProperties(username, type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
                                    int image_index,
@@ skipping 93 matching lines @@
   last_image_set_async_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToFile,
                  base::Unretained(this),
                  username, image, image_path, image_index));
 }
 
+void UserManagerImpl::SaveUserWallpaperInternal(const std::string& username,
+                                                ash::WallpaperLayout layout,
+                                                User::WallpaperType type,
+                                                const SkBitmap& wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UserManagerImpl::GenerateUserWallpaperThumbnail,
+                 base::Unretained(this),
+                 username, type, 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::LoadCustomWallpaperThumbnail(const std::string& email,
+                                                   ash::WallpaperLayout layout,
+                                                   const SkBitmap& wallpaper) {
+  ash::Shell::GetInstance()->desktop_background_controller()->
+      SetCustomWallpaper(wallpaper, layout);
+  // Load wallpaper thumbnail
+  std::string wallpaper_path = GetWallpaperPathForUser(email, true).value();
+  image_loader_->Start(
+      wallpaper_path, 0,
+      base::Bind(&UserManagerImpl::OnCustomWallpaperThumbnailLoaded,
+      base::Unretained(this), email));
+}
+
+void UserManagerImpl::OnCustomWallpaperThumbnailLoaded(
+    const std::string& email,
+    const SkBitmap& wallpaper) {
+  User* user = const_cast<User*>(FindUser(email));
+  // User may have been removed by now.
+  if (user && !wallpaper.empty())
+    user->SetWallpaperThumbnail(wallpaper);
+}
+
+void UserManagerImpl::GenerateUserWallpaperThumbnail(
+    const std::string& username,
+    User::WallpaperType type,
+    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::NotifyThumbnailUpdated,
+                 base::Unretained(this)));
+
+  // Ignore for ephemeral users.
+  if (IsEphemeralUser(username))
+    return;
+
+  FilePath thumbnail_path = GetWallpaperPathForUser(username, true);
+  SaveBitmapToFile(thumbnail, thumbnail_path);
+}
+
 void UserManagerImpl::SaveImageToFile(const std::string& username,
                                       const SkBitmap& image,
                                       const FilePath& image_path,
                                       int image_index) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  std::vector<unsigned char> encoded_image;
-  if (!gfx::PNGCodec::EncodeBGRASkBitmap(image, false, &encoded_image)) {
-    LOG(ERROR) << "Failed to PNG encode the image.";
+  if (!SaveBitmapToFile(image, image_path))
     return;
-  }
-
-  if (file_util::WriteFile(image_path,
-                           reinterpret_cast<char*>(&encoded_image[0]),
-                           encoded_image.size()) == -1) {
-    LOG(ERROR) << "Failed to save image to file.";
-    return;
-  }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToLocalState,
                  base::Unretained(this),
                  username, image_path.value(), image_index, 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-encode
+  // it and save it.
+  if (!SaveBitmapToFile(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,
                                             bool is_async) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
 
@@ skipping 13 matching lines @@
   base::DictionaryValue* image_properties = new base::DictionaryValue();
   image_properties->Set(kImagePathNodeName, new StringValue(image_path));
   image_properties->Set(kImageIndexNodeName,
                         new base::FundamentalValue(image_index));
   images_update->SetWithoutPathExpansion(username, image_properties);
   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);
+}
+
+bool UserManagerImpl::SaveBitmapToFile(const SkBitmap& image,
+                                       const FilePath& image_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  std::vector<unsigned char> encoded_image;
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(image, false, &encoded_image)) {
+    LOG(ERROR) << "Failed to PNG encode the image.";
+    return false;
+  }
+
+  if (file_util::WriteFile(image_path,
+                           reinterpret_cast<char*>(&encoded_image[0]),
+                           encoded_image.size()) == -1) {
+    LOG(ERROR) << "Failed to save image to file.";
+    return false;
+  }
+  return true;
+}
+
 void UserManagerImpl::InitDownloadedProfileImage() {
   DCHECK(logged_in_user_);
   if (downloaded_profile_image_.empty() && !logged_in_user_->image_is_stub()) {
     VLOG(1) << "Profile image initialized";
     downloaded_profile_image_ = logged_in_user_->image();
     downloaded_profile_image_data_url_ =
         web_ui_util::GetImageDataUrl(downloaded_profile_image_);
   }
 }
 
@@ skipping 126 matching lines @@
     if (email != user_email)
       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);
+  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);
+  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);
   prefs_images_update->RemoveWithoutPathExpansion(email, NULL);
 
   DictionaryPrefUpdate prefs_oauth_update(prefs, kUserOAuthTokenStatus);
   int oauth_status;
   prefs_oauth_update->GetIntegerWithoutPathExpansion(email, &oauth_status);
   prefs_oauth_update->RemoveWithoutPathExpansion(email, NULL);
 
@@ skipping 13 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos