Make image_decoder a Leaky LazyInstance

chrome/browser/chromeos/extensions/wallpaper_function_base.cc

 // Copyright 2013 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/extensions/wallpaper_function_base.h"
 
 #include "base/synchronization/cancellation_flag.h"
 #include "chrome/browser/image_decoder.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/login/login_state.h"
@@ skipping 24 matching lines @@
     if (layout.compare(kWallpaperLayoutArrays[i]) == 0)
       return static_cast<wallpaper::WallpaperLayout>(i);
   }
   // Default to use CENTER layout.
   return wallpaper::WALLPAPER_LAYOUT_CENTER;
 }
 
 }  // namespace wallpaper_api_util
 
 class WallpaperFunctionBase::UnsafeWallpaperDecoder
-    : public ImageDecoder::Delegate {
+    : public ImageDecoder::ImageRequest {
  public:
   explicit UnsafeWallpaperDecoder(scoped_refptr<WallpaperFunctionBase> function)
-      : function_(function) {
-  }
+      : ImageRequest(
+            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
+        function_(function) {}
 
   void Start(const std::vector<char>& image_data) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     // This function can only be called after user login. It is fine to use
     // unsafe image decoder here. Before user login, a robust jpeg decoder will
     // be used.
     CHECK(chromeos::LoginState::Get()->IsUserLoggedIn());
-    unsafe_image_decoder_ = new ImageDecoder(this, image_data,
-                                             ImageDecoder::DEFAULT_CODEC);
-    unsafe_image_decoder_->set_shrink_to_fit(true);
-
-    scoped_refptr<base::MessageLoopProxy> task_runner =
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
-    unsafe_image_decoder_->Start(task_runner);
+    std::string image_data_str(image_data.begin(), image_data.end());
+    ImageDecoder::StartWithOptions(this, image_data_str,
+                                   ImageDecoder::DEFAULT_CODEC, true);
   }
 
   void Cancel() {
     cancel_flag_.Set();
   }
 
-  void OnImageDecoded(const ImageDecoder* decoder,
-                      const SkBitmap& decoded_image) override {
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
     // Make the SkBitmap immutable as we won't modify it. This is important
     // because otherwise it gets duplicated during painting, wasting memory.
     SkBitmap immutable(decoded_image);
     immutable.setImmutable();
     gfx::ImageSkia final_image = gfx::ImageSkia::CreateFrom1xBitmap(immutable);
     final_image.MakeThreadSafe();
     if (cancel_flag_.IsSet()) {
       function_->OnCancel();
       delete this;
       return;
     }
     function_->OnWallpaperDecoded(final_image);
     delete this;
   }
 
-  void OnDecodeImageFailed(const ImageDecoder* decoder) override {
+  void OnDecodeImageFailed() override {
     function_->OnFailure(
         l10n_util::GetStringUTF8(IDS_WALLPAPER_MANAGER_INVALID_WALLPAPER));
     delete this;
   }
 
  private:
   scoped_refptr<WallpaperFunctionBase> function_;
-  scoped_refptr<ImageDecoder> unsafe_image_decoder_;
   base::CancellationFlag cancel_flag_;
 
   DISALLOW_COPY_AND_ASSIGN(UnsafeWallpaperDecoder);
 };
 
 WallpaperFunctionBase::UnsafeWallpaperDecoder*
     WallpaperFunctionBase::unsafe_wallpaper_decoder_;
 
 WallpaperFunctionBase::WallpaperFunctionBase() {
 }
@@ skipping 13 matching lines @@
   unsafe_wallpaper_decoder_ = NULL;
   SetError(wallpaper_api_util::kCancelWallpaperMessage);
   SendResponse(false);
 }
 
 void WallpaperFunctionBase::OnFailure(const std::string& error) {
   unsafe_wallpaper_decoder_ = NULL;
   SetError(error);
   SendResponse(false);
 }