Added support for animated/nonanimated user image.

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 17 matching lines @@
 #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/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 296 matching lines @@
   is_current_user_ephemeral_ = true;
   logged_in_user_ = CreateUser(email);
   SetInitialUserImage(email);
   SetInitialUserWallpaper(email);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::StubUserLoggedIn() {
   is_current_user_ephemeral_ = true;
   logged_in_user_ = new User(kStubUser, false);
-  logged_in_user_->SetImage(GetDefaultImage(kStubDefaultImageIndex),
+  logged_in_user_->SetImage(UserImage(GetDefaultImage(kStubDefaultImageIndex)),
                             kStubDefaultImageIndex);
 }
 
 void UserManagerImpl::UserSelected(const std::string& email) {
   if (IsKnownUser(email)) {
     User::WallpaperType type;
     int index;
     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,
+          wallpaper_path, 0, false,
           base::Bind(&UserManagerImpl::LoadCustomWallpaperThumbnail,
               base::Unretained(this), email, layout));
       return;
     }
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(index);
   }
 }
 
 void UserManagerImpl::SessionStarted() {
@@ skipping 123 matching lines @@
 
 std::string UserManagerImpl::GetUserDisplayEmail(
     const std::string& username) const {
   const User* user = FindUser(username);
   return user ? user->display_email() : username;
 }
 
 void UserManagerImpl::SaveUserDefaultImageIndex(const std::string& username,
                                                 int image_index) {
   DCHECK(image_index >= 0 && image_index < kDefaultImagesCount);
-  SetUserImage(username, image_index, GetDefaultImage(image_index));
+  SetUserImage(username, image_index, UserImage(GetDefaultImage(image_index)));
   SaveImageToLocalState(username, "", image_index, false);
 }
 
 void UserManagerImpl::SaveUserImage(const std::string& username,
-                                    const SkBitmap& image) {
-  SaveUserImageInternal(username, User::kExternalImageIndex, image);
+                                    const UserImage& user_image) {
+  SaveUserImageInternal(username, User::kExternalImageIndex, user_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,
+      path.value(), login::kUserImageSize, true,
       base::Bind(&UserManagerImpl::SaveUserImage,
                  base::Unretained(this), username));
 }
 
 void UserManagerImpl::SaveUserWallpaperFromFile(const std::string& username,
                                                 const FilePath& path,
                                                 ash::WallpaperLayout layout,
                                                 WallpaperDelegate* delegate) {
   // For wallpapers, save the image without resizing.
   image_loader_->Start(
-      path.value(), 0 /* Original size */,
+      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) {
   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_);
+                          UserImage(downloaded_profile_image_));
   } else {
     // No profile image - use the stub image (gray avatar).
-    SetUserImage(username, User::kProfileImageIndex, SkBitmap());
+    SetUserImage(username, User::kProfileImageIndex, UserImage(SkBitmap()));
     SaveImageToLocalState(username, "", User::kProfileImageIndex, false);
   }
 }
 
 void UserManagerImpl::DownloadProfileImage(const std::string& reason) {
   if (profile_image_downloader_.get()) {
     // Another download is already in progress
     return;
   }
 
@@ skipping 149 matching lines @@
 
         if (prefs_images) {
           // Get account image path.
           // TODO(avayvod): Reading image path as a string is here for
           // backward compatibility.
           std::string image_path;
           base::DictionaryValue* image_properties;
           if (prefs_images->GetStringWithoutPathExpansion(email, &image_path)) {
             int image_id = User::kInvalidImageIndex;
             if (IsDefaultImagePath(image_path, &image_id)) {
-              user->SetImage(GetDefaultImage(image_id), image_id);
+              user->SetImage(UserImage(GetDefaultImage(image_id)), image_id);
             } else {
               int image_index = User::kExternalImageIndex;
               // Until image has been loaded, use the stub image.
               user->SetStubImage(image_index);
               DCHECK(!image_path.empty());
               // Load user image asynchronously.
               image_loader_->Start(
-                  image_path, 0,
+                  image_path, 0, true,
                   base::Bind(&UserManagerImpl::SetUserImage,
                              base::Unretained(this), email, image_index));
             }
           } else if (prefs_images->GetDictionaryWithoutPathExpansion(
                          email, &image_properties)) {
             int image_index = User::kInvalidImageIndex;
             image_properties->GetString(kImagePathNodeName, &image_path);
             image_properties->GetInteger(kImageIndexNodeName, &image_index);
             if (image_index >= 0 && image_index < kDefaultImagesCount) {
-              user->SetImage(GetDefaultImage(image_index), image_index);
+              user->SetImage(UserImage(GetDefaultImage(image_index)),
+                             image_index);
             } else if (image_index == User::kExternalImageIndex ||
                        image_index == User::kProfileImageIndex) {
               // Path may be empty for profile images (meaning that the image
               // hasn't been downloaded for the first time yet, in which case a
               // download will be scheduled for |kProfileImageDownloadDelayMs|
               // after user logs in).
               DCHECK(!image_path.empty() ||
                      image_index == User::kProfileImageIndex);
               // Until image has been loaded, use the stub image (gray avatar).
               user->SetStubImage(image_index);
               if (!image_path.empty()) {
                 // Load user image asynchronously.
                 image_loader_->Start(
-                    image_path, 0,
+                    image_path, 0, true,
                     base::Bind(&UserManagerImpl::SetUserImage,
                                base::Unretained(this), email, image_index));
               }
             } else {
               NOTREACHED();
             }
           }
         }
 
         std::string display_email;
@@ skipping 175 matching lines @@
 }
 
 void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
     User::WallpaperType type,
     int index) {
   SaveUserWallpaperProperties(GetLoggedInUser().email(), type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
                                    int image_index,
-                                   const SkBitmap& image) {
+                                   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
     // them from Local State.
     DCHECK(user->image_index() != User::kInvalidImageIndex ||
            is_current_user_new_);
     bool image_changed = user->image_index() != User::kInvalidImageIndex;
-    if (!image.empty())
-      user->SetImage(image, image_index);
+    if (!user_image.image().empty())
+      user->SetImage(user_image, image_index);
     else
       user->SetStubImage(image_index);
     // For the logged-in user with a profile picture, initialize
     // |downloaded_profile_picture_|.
     if (user == logged_in_user_ && image_index == User::kProfileImageIndex)
       InitDownloadedProfileImage();
     if (image_changed) {
       // Unless this is first-time setting with |SetInitialUserImage|,
       // send a notification about image change.
       content::NotificationService::current()->Notify(
@@ skipping 52 matching lines @@
   base::DictionaryValue* wallpaper_properties = new base::DictionaryValue();
   wallpaper_properties->Set(kWallpaperTypeNodeName,
                             new base::FundamentalValue(type));
   wallpaper_properties->Set(kWallpaperIndexNodeName,
                             new base::FundamentalValue(index));
   wallpaper_update->SetWithoutPathExpansion(username, wallpaper_properties);
 }
 
 void UserManagerImpl::SaveUserImageInternal(const std::string& username,
                                             int image_index,
-                                            const SkBitmap& image) {
+                                            const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  SetUserImage(username, image_index, image);
+  SetUserImage(username, image_index, 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, image, image_path, image_index));
+                 username, user_image, image_path, image_index));
 }
 
 void UserManagerImpl::SaveUserWallpaperInternal(const std::string& username,
                                                 ash::WallpaperLayout layout,
                                                 User::WallpaperType type,
                                                 WallpaperDelegate* delegate,
-                                                const SkBitmap& wallpaper) {
+                                                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::LoadCustomWallpaperThumbnail(const std::string& email,
-                                                   ash::WallpaperLayout layout,
-                                                   const SkBitmap& wallpaper) {
+void UserManagerImpl::LoadCustomWallpaperThumbnail(
+    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);
   // Load wallpaper thumbnail
   std::string wallpaper_path = GetWallpaperPathForUser(email, true).value();
   image_loader_->Start(
-      wallpaper_path, 0,
+      wallpaper_path, 0, false,
       base::Bind(&UserManagerImpl::OnCustomWallpaperThumbnailLoaded,
       base::Unretained(this), email));
 }
 
 void UserManagerImpl::OnCustomWallpaperThumbnailLoaded(
     const std::string& email,
-    const SkBitmap& wallpaper) {
+    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(WallpaperDelegate* delegate) {
   if (delegate)
     delegate->SetCustomWallpaperThumbnail();
 }
@@ skipping 15 matching lines @@
       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(thumbnail, thumbnail_path);
+  SaveBitmapToFile(UserImage(thumbnail), thumbnail_path);
 }
 
 void UserManagerImpl::SaveImageToFile(const std::string& username,
-                                      const SkBitmap& image,
+                                      const UserImage& user_image,
                                       const FilePath& image_path,
                                       int image_index) {
-  if (!SaveBitmapToFile(image, image_path))
+  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, 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(wallpaper, wallpaper_path))
+  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));
 }
 
@@ skipping 31 matching lines @@
 }
 
 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,
+bool UserManagerImpl::SaveBitmapToFile(const UserImage& user_image,
                                        const FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<unsigned char> encoded_image;
-  if (!gfx::PNGCodec::EncodeBGRASkBitmap(image, false, &encoded_image)) {
+  if (user_image.has_raw_image()) {
+    encoded_image = user_image.raw_image();
+  } else if (!gfx::PNGCodec::EncodeBGRASkBitmap(user_image.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;
   }
@@ skipping 189 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos