Get rid of image_codec_ member from UserImageLoader

Because this does not have to be a member variable.

Along the way, get rid of unsafe_image_loader_ from
UserImageManagerImpl because there is no longer need
to maintain two instances of UserImageLoader.

BUG=587289
TEST=google profile image is loaded works as before in the login screen

Review URL: https://codereview.chromium.org/1730963003

Cr-Commit-Position: refs/heads/master@{#377214}

6 files changed, 42 insertions, 42 deletions

diff --git a/chrome/browser/chromeos/login/users/avatar/user_image_loader.cc b/chrome/browser/chromeos/login/users/avatar/user_image_loader.cc
index bd7a266..c7c3baa 100644
--- a/chrome/browser/chromeos/login/users/avatar/user_image_loader.cc
+++ b/chrome/browser/chromeos/login/users/avatar/user_image_loader.cc
@@ -25,9 +25,11 @@ namespace chromeos {
 
 UserImageLoader::ImageInfo::ImageInfo(const base::FilePath& file_path,
                                       int pixels_per_side,
+                                      ImageDecoder::ImageCodec image_codec,
                                       const LoadedCallback& loaded_cb)
     : file_path(file_path),
       pixels_per_side(pixels_per_side),
+      image_codec(image_codec),
       loaded_cb(loaded_cb) {}
 
 UserImageLoader::ImageInfo::~ImageInfo() {
@@ -47,31 +49,32 @@ UserImageLoader::UserImageRequest::~UserImageRequest() {
 }
 
 UserImageLoader::UserImageLoader(
-    ImageDecoder::ImageCodec image_codec,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner)
     : foreground_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      background_task_runner_(background_task_runner),
-      image_codec_(image_codec) {
-}
+      background_task_runner_(background_task_runner) {}
 
 UserImageLoader::~UserImageLoader() {
 }
 
 void UserImageLoader::StartWithFilePath(const base::FilePath& file_path,
+                                        ImageDecoder::ImageCodec image_codec,
                                         int pixels_per_side,
                                         const LoadedCallback& loaded_cb) {
   background_task_runner_->PostTask(
       FROM_HERE, base::Bind(&UserImageLoader::ReadAndDecodeImage, this,
-                            ImageInfo(file_path, pixels_per_side, loaded_cb)));
+                            ImageInfo(file_path, pixels_per_side, image_codec,
+                                      loaded_cb)));
 }
 
 void UserImageLoader::StartWithData(scoped_ptr<std::string> data,
+                                    ImageDecoder::ImageCodec image_codec,
                                     int pixels_per_side,
                                     const LoadedCallback& loaded_cb) {
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UserImageLoader::DecodeImage, this, base::Passed(&data),
-                 ImageInfo(base::FilePath(), pixels_per_side, loaded_cb)));
+                 ImageInfo(base::FilePath(), pixels_per_side, image_codec,
+                           loaded_cb)));
 }
 
 void UserImageLoader::ReadAndDecodeImage(const ImageInfo& image_info) {
@@ -92,7 +95,8 @@ void UserImageLoader::DecodeImage(const scoped_ptr<std::string> data,
 
   UserImageRequest* image_request =
       new UserImageRequest(image_info, *data, this);
-  ImageDecoder::StartWithOptions(image_request, *data, image_codec_, false);
+  ImageDecoder::StartWithOptions(image_request, *data, image_info.image_codec,
+                                 false);
 }
 
 void UserImageLoader::UserImageRequest::OnImageDecoded(
@@ -129,7 +133,7 @@ void UserImageLoader::UserImageRequest::OnImageDecoded(
   final_image_skia.MakeThreadSafe();
   user_manager::UserImage user_image(final_image_skia, image_data_);
   user_image.set_file_path(image_info_.file_path);
-  if (user_image_loader_->image_codec_ == ImageDecoder::ROBUST_JPEG_CODEC)
+  if (image_info_.image_codec == ImageDecoder::ROBUST_JPEG_CODEC)
     user_image.MarkAsSafe();
   user_image_loader_->foreground_task_runner_->PostTask(
       FROM_HERE, base::Bind(image_info_.loaded_cb, user_image));
diff --git a/chrome/browser/chromeos/login/users/avatar/user_image_loader.h b/chrome/browser/chromeos/login/users/avatar/user_image_loader.h
index 3f96a9d..fe93b52 100644
--- a/chrome/browser/chromeos/login/users/avatar/user_image_loader.h
+++ b/chrome/browser/chromeos/login/users/avatar/user_image_loader.h
@@ -36,19 +36,21 @@ class UserImageLoader : public base::RefCountedThreadSafe<UserImageLoader> {
 
   // All file I/O, decoding and resizing are done via |background_task_runner|.
   UserImageLoader(
-      ImageDecoder::ImageCodec image_codec,
       scoped_refptr<base::SequencedTaskRunner> background_task_runner);
 
-  // Load an image in the background and call |loaded_cb| with the resulting
-  // UserImage (which may be empty in case of error). If |pixels_per_side| is
-  // positive, the image is cropped to a square and shrunk so that it does not
-  // exceed |pixels_per_side|x|pixels_per_side|. The first variant of this
-  // method reads the image from |file_path| on disk, the second processes
-  // |data| read into memory already.
+  // Load an image with |image_codec| in the background and call |loaded_cb|
+  // with the resulting UserImage (which may be empty in case of error). If
+  // |pixels_per_side| is positive, the image is cropped to a square and
+  // shrunk so that it does not exceed
+  // |pixels_per_side|x|pixels_per_side|. The first variant of this method
+  // reads the image from |file_path| on disk, the second processes |data|
+  // read into memory already.
   void StartWithFilePath(const base::FilePath& file_path,
+                         ImageDecoder::ImageCodec image_codec,
                          int pixels_per_side,
                          const LoadedCallback& loaded_cb);
   void StartWithData(scoped_ptr<std::string> data,
+                     ImageDecoder::ImageCodec image_codec,
                      int pixels_per_side,
                      const LoadedCallback& loaded_cb);
 
@@ -59,11 +61,13 @@ class UserImageLoader : public base::RefCountedThreadSafe<UserImageLoader> {
   struct ImageInfo {
     ImageInfo(const base::FilePath& file_path,
               int pixels_per_side,
+              ImageDecoder::ImageCodec image_codec,
               const LoadedCallback& loaded_cb);
     ~ImageInfo();
 
     const base::FilePath file_path;
     const int pixels_per_side;
+    const ImageDecoder::ImageCodec image_codec;
     const LoadedCallback loaded_cb;
   };
 
@@ -105,9 +109,6 @@ class UserImageLoader : public base::RefCountedThreadSafe<UserImageLoader> {
   // are done.
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
-  // Specify how the file should be decoded in the utility process.
-  const ImageDecoder::ImageCodec image_codec_;
-
   DISALLOW_COPY_AND_ASSIGN(UserImageLoader);
 };
 
diff --git a/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.cc b/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.cc
index c8192a1d..9123586 100644
--- a/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.cc
+++ b/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.cc
@@ -315,12 +315,13 @@ void UserImageManagerImpl::Job::LoadImage(base::FilePath image_path,
   } else if (image_index_ == user_manager::User::USER_IMAGE_EXTERNAL ||
              image_index_ == user_manager::User::USER_IMAGE_PROFILE) {
     // Load the user image from a file referenced by |image_path|. This happens
-    // asynchronously. The JPEG image loader can be used here because
+    // asynchronously. ROBUST_JPEG_CODEC can be used here because
     // LoadImage() is called only for users whose user image has previously
     // been set by one of the Set*() methods, which transcode to JPEG format.
     DCHECK(!image_path_.empty());
     parent_->image_loader_->StartWithFilePath(
-        image_path_, 0,  // Do not crop.
+        image_path_, ImageDecoder::ROBUST_JPEG_CODEC,
+        0,  // Do not crop.
         base::Bind(&Job::OnLoadImageDone, weak_factory_.GetWeakPtr(), false));
   } else {
     NOTREACHED();
@@ -366,18 +367,19 @@ void UserImageManagerImpl::Job::SetToImageData(scoped_ptr<std::string> data) {
 
   image_index_ = user_manager::User::USER_IMAGE_EXTERNAL;
 
-  // This method uses the image_loader_, not the unsafe_image_loader_:
+  // This method uses ROBUST_JPEG_CODEC, not DEFAULT_CODEC:
   // * This is necessary because the method is used to update the user image
   //   whenever the policy for a user is set. In the case of device-local
   //   accounts, policy may change at any time, even if the user is not
-  //   currently logged in (and thus, the unsafe_image_loader_ may not be used).
+  //   currently logged in (and thus, DEFAULT_CODEC may not be used).
   // * This is possible because only JPEG |data| is accepted. No support for
   //   other image file formats is needed.
-  // * This is safe because the image_loader_ employs a hardened JPEG decoder
+  // * This is safe because ROBUST_JPEG_CODEC employs a hardened JPEG decoder
   //   that protects against malicious invalid image data being used to attack
   //   the login screen or another user session currently in progress.
   parent_->image_loader_->StartWithData(
-      std::move(data), login::kMaxUserImageSize,
+      std::move(data), ImageDecoder::ROBUST_JPEG_CODEC,
+      login::kMaxUserImageSize,
       base::Bind(&Job::OnLoadImageDone, weak_factory_.GetWeakPtr(), true));
 }
 
@@ -392,8 +394,8 @@ void UserImageManagerImpl::Job::SetToPath(const base::FilePath& path,
   image_url_ = image_url;
 
   DCHECK(!path.empty());
-  parent_->unsafe_image_loader_->StartWithFilePath(
-      path, resize ? login::kMaxUserImageSize : 0,
+  parent_->image_loader_->StartWithFilePath(
+      path, ImageDecoder::DEFAULT_CODEC, resize ? login::kMaxUserImageSize : 0,
       base::Bind(&Job::OnLoadImageDone, weak_factory_.GetWeakPtr(), true));
 }
 
@@ -485,10 +487,7 @@ UserImageManagerImpl::UserImageManagerImpl(
       blocking_pool->GetSequencedTaskRunnerWithShutdownBehavior(
           blocking_pool->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
-  image_loader_ = new UserImageLoader(ImageDecoder::ROBUST_JPEG_CODEC,
-                                      background_task_runner_);
-  unsafe_image_loader_ = new UserImageLoader(ImageDecoder::DEFAULT_CODEC,
-                                             background_task_runner_);
+  image_loader_ = new UserImageLoader(background_task_runner_);
 }
 
 UserImageManagerImpl::~UserImageManagerImpl() {}
diff --git a/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h b/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h
index fdffa19..0ccf9ee 100644
--- a/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h
+++ b/chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h
@@ -156,12 +156,9 @@ class UserImageManagerImpl
   // The user manager.
   user_manager::UserManager* user_manager_;
 
-  // Loader for JPEG user images.
+  // Loader for user images.
   scoped_refptr<UserImageLoader> image_loader_;
 
-  // Unsafe loader instance for all user images formats.
-  scoped_refptr<UserImageLoader> unsafe_image_loader_;
-
   // Whether the |profile_downloader_| is downloading the profile image for the
   // currently logged-in user (and not just the full name). Only valid when a
   // download is currently in progress.
diff --git a/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc b/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc
index 17dcda8..1b8fd8c 100644
--- a/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc
+++ b/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc
@@ -449,7 +449,7 @@ void WallpaperManager::OnPolicyFetched(const std::string& policy,
     return;
 
   wallpaper_loader_->StartWithData(
-      std::move(data),
+      std::move(data), ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::SetPolicyControlledWallpaper,
                  weak_factory_.GetWeakPtr(), account_id));
@@ -760,8 +760,7 @@ WallpaperManager::WallpaperManager()
       BrowserThread::GetBlockingPool()
           ->GetSequencedTaskRunnerWithShutdownBehavior(
               sequence_token_, base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
-  wallpaper_loader_ =
-      new UserImageLoader(ImageDecoder::ROBUST_JPEG_CODEC, task_runner_);
+  wallpaper_loader_ = new UserImageLoader(task_runner_);
 
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 }
@@ -955,7 +954,7 @@ void WallpaperManager::StartLoad(const AccountId& account_id,
         CustomWallpaperElement(wallpaper_path, gfx::ImageSkia());
   }
   wallpaper_loader_->StartWithFilePath(
-      wallpaper_path,
+      wallpaper_path, ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::OnWallpaperDecoded,
                  weak_factory_.GetWeakPtr(), account_id, info.layout,
@@ -976,7 +975,7 @@ void WallpaperManager::SetCustomizedDefaultWallpaperAfterCheck(
     // Either resized images do not exist or cached version is incorrect.
     // Need to start resize again.
     wallpaper_loader_->StartWithFilePath(
-        downloaded_file,
+        downloaded_file, ImageDecoder::ROBUST_JPEG_CODEC,
         0,  // Do not crop.
         base::Bind(&WallpaperManager::OnCustomizedDefaultWallpaperDecoded,
                    weak_factory_.GetWeakPtr(), wallpaper_url,
@@ -1052,7 +1051,7 @@ void WallpaperManager::StartLoadAndSetDefaultWallpaper(
     MovableOnDestroyCallbackHolder on_finish,
     scoped_ptr<user_manager::UserImage>* result_out) {
   wallpaper_loader_->StartWithFilePath(
-      path,
+      path, ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::OnDefaultWallpaperDecoded,
                  weak_factory_.GetWeakPtr(), path, layout,
diff --git a/chrome/browser/ui/webui/chromeos/image_source.cc b/chrome/browser/ui/webui/chromeos/image_source.cc
index 1a4fb9c..3e059d8 100644
--- a/chrome/browser/ui/webui/chromeos/image_source.cc
+++ b/chrome/browser/ui/webui/chromeos/image_source.cc
@@ -72,8 +72,7 @@ void ImageSource::StartDataRequest(
   }
 
   if (!image_loader_) {
-    image_loader_ = new UserImageLoader(ImageDecoder::DEFAULT_CODEC,
-                                        task_runner_);
+    image_loader_ = new UserImageLoader(task_runner_);
   }
 
   const base::FilePath asset_dir(FILE_PATH_LITERAL(chrome::kChromeOSAssetPath));
@@ -93,6 +92,7 @@ void ImageSource::StartDataRequestAfterPathExists(
   if (path_exists) {
     image_loader_->StartWithFilePath(
         image_path,
+        ImageDecoder::DEFAULT_CODEC,
         0,  // Do not crop.
         base::Bind(&ImageLoaded, got_data_callback));
   } else {