Make image_decoder a Leaky LazyInstance

chrome/browser/chromeos/login/users/avatar/user_image_loader.cc

 // Copyright 2014 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/users/avatar/user_image_loader.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 13 matching lines @@
                                       int pixels_per_side,
                                       const LoadedCallback& loaded_cb)
     : file_path(file_path),
       pixels_per_side(pixels_per_side),
       loaded_cb(loaded_cb) {
 }
 
 UserImageLoader::ImageInfo::~ImageInfo() {
 }
 
+UserImageLoader::ImageData::ImageData(const ImageInfo& image_info,
+                                      const std::string& data)
+    : image_info(image_info), data(data.begin(), data.end()) {
+}
+
+UserImageLoader::ImageData::~ImageData() {
+}
+
 UserImageLoader::UserImageLoader(
     ImageDecoder::ImageCodec image_codec,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner)
     : foreground_task_runner_(base::MessageLoopProxy::current()),
       background_task_runner_(background_task_runner),
       image_codec_(image_codec) {
 }
 
 UserImageLoader::~UserImageLoader() {
 }
@@ skipping 28 matching lines @@
 
   // In case ReadFileToString() fails, |data| is empty and DecodeImage() calls
   // back to OnDecodeImageFailed().
   DecodeImage(data.Pass(), image_info);
 }
 
 void UserImageLoader::DecodeImage(const scoped_ptr<std::string> data,
                                   const ImageInfo& image_info) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
-  scoped_refptr<ImageDecoder> image_decoder =
-      new ImageDecoder(this, *data, image_codec_);
-  image_info_map_.insert(std::make_pair(image_decoder.get(), image_info));
-  image_decoder->Start(background_task_runner_);
+  ImageData image_data(image_info, *data);
+  image_data_queue_.push(image_data);
+  ImageDecoder::GetInstance()->Start(this, *data, image_codec_,
+                                     background_task_runner_, false);
 }
 
-void UserImageLoader::OnImageDecoded(const ImageDecoder* decoder,
-                                     const SkBitmap& decoded_image) {
+void UserImageLoader::OnImageDecoded(const SkBitmap& decoded_image) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
-  ImageInfoMap::iterator it = image_info_map_.find(decoder);
-  if (it == image_info_map_.end()) {
-    NOTREACHED();
-    return;
-  }
-  const std::string file_path = it->second.file_path;
-  const int target_size = it->second.pixels_per_side;
-  const LoadedCallback loaded_cb = it->second.loaded_cb;
-  image_info_map_.erase(it);
+  const ImageData& image_data = image_data_queue_.front();
+  const ImageInfo& image_info = image_data.image_info;
+  const std::string file_path = image_info.file_path;
+  const int target_size = image_info.pixels_per_side;
+  const LoadedCallback loaded_cb = image_info.loaded_cb;
+  std::vector<unsigned char> original_data = image_data.data;
+  image_data_queue_.pop();
 
   SkBitmap final_image = decoded_image;
 
   if (target_size > 0) {
     // Auto crop the image, taking the largest square in the center.
     int pixels_per_side =
         std::min(decoded_image.width(), decoded_image.height());
     int x = (decoded_image.width() - pixels_per_side) / 2;
     int y = (decoded_image.height() - pixels_per_side) / 2;
     SkBitmap cropped_image = SkBitmapOperations::CreateTiledBitmap(
         decoded_image, x, y, pixels_per_side, pixels_per_side);
     if (pixels_per_side > target_size) {
       // Also downsize the image to save space and memory.
       final_image =
           skia::ImageOperations::Resize(cropped_image,
                                         skia::ImageOperations::RESIZE_LANCZOS3,
                                         target_size,
                                         target_size);
     } else {
       final_image = cropped_image;
     }
   }
   // Make the SkBitmap immutable as we won't modify it. This is important
   // because otherwise it gets duplicated during painting, wasting memory.
   final_image.setImmutable();
   gfx::ImageSkia final_image_skia =
       gfx::ImageSkia::CreateFrom1xBitmap(final_image);
   final_image_skia.MakeThreadSafe();
-  user_manager::UserImage user_image(final_image_skia,
-                                     decoder->get_image_data());
+  user_manager::UserImage user_image(final_image_skia, original_data);
   user_image.set_file_path(file_path);
   if (image_codec_ == ImageDecoder::ROBUST_JPEG_CODEC)
     user_image.MarkAsSafe();
   foreground_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(loaded_cb, user_image));
 }
 
-void UserImageLoader::OnDecodeImageFailed(const ImageDecoder* decoder) {
+void UserImageLoader::OnDecodeImageFailed() {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
-  ImageInfoMap::iterator it = image_info_map_.find(decoder);
-  if (it == image_info_map_.end()) {
-    NOTREACHED();
-    return;
-  }
-  const LoadedCallback loaded_cb = it->second.loaded_cb;
-  image_info_map_.erase(it);
+  ImageInfo image_info = image_data_queue_.front().image_info;
+  const LoadedCallback loaded_cb = image_info.loaded_cb;
+  image_data_queue_.pop();
 
   foreground_task_runner_->PostTask(
       FROM_HERE, base::Bind(loaded_cb, user_manager::UserImage()));
 }
 
 }  // namespace chromeos