[cros] Encode user images when set from WebUI (regression fix).

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 402 matching lines @@
       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,
+          wallpaper_path, 0,
           base::Bind(&UserManagerImpl::OnCustomWallpaperLoaded,
                      base::Unretained(this), email, layout));
       return;
     }
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(index);
     WallpaperManager::Get()->SetLastSelectedUser(email);
   }
 }
 
@@ skipping 190 matching lines @@
   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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   image_loader_->Start(
-      path.value(), login::kMaxUserImageSize, true,
+      path.value(), login::kMaxUserImageSize,
       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,
+      path.value(), 0 /* Original size */,
       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_));
+    SaveUserImageInternal(
+        username,
+        User::kProfileImageIndex, profile_image_url_,
+        UserImage::CreateAndEncode(downloaded_profile_image_));
   } else {
     // No profile image - use the stub image (gray avatar).
     SetUserImage(username, User::kProfileImageIndex,
                  GURL(), UserImage(SkBitmap()));
     SaveImageToLocalState(username, "", User::kProfileImageIndex,
                           GURL(), false);
   }
 }
 
 void UserManagerImpl::DownloadProfileImage(const std::string& reason) {
@@ skipping 170 matching lines @@
             int image_id = User::kInvalidImageIndex;
             if (IsDefaultImagePath(image_path, &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, user_image_size, true,
+                  image_path, user_image_size,
                   base::Bind(&UserManagerImpl::SetUserImage,
                              base::Unretained(this),
                              email, image_index, GURL()));
             }
           } 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(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 |kProfileDataDownloadDelayMs|
               // after user logs in).
               DCHECK(!image_path.empty() ||
                      image_index == User::kProfileImageIndex);
               std::string image_url;
               image_properties->GetString(kImageURLNodeName, &image_url);
               GURL image_gurl(image_url);
               // Until image has been loaded, use the stub image (gray avatar).
               user->SetStubImage(image_index);
               user->SetImageURL(image_gurl);
               if (!image_path.empty()) {
                 // Load user image asynchronously.
                 image_loader_->Start(
-                    image_path, user_image_size, true,
+                    image_path, user_image_size,
                     base::Bind(&UserManagerImpl::SetUserImage,
                                base::Unretained(this),
                                email, image_index, image_gurl));
               }
             } else {
               NOTREACHED();
             }
           }
         }
 
@@ skipping 370 matching lines @@
 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,
+      wallpaper_thumbnail_path, 0,
       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.
@@ skipping 405 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos