Make image_decoder a Leaky LazyInstance

chrome/browser/chromeos/app_mode/kiosk_app_data.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/app_mode/kiosk_app_data.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 173 matching lines @@
   std::string name_;
   SkBitmap icon_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxLoader);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // KioskAppData::IconLoader
 // Loads locally stored icon data and decode it.
 
-class KioskAppData::IconLoader : public ImageDecoder::Delegate {
+class KioskAppData::IconLoader {
  public:
   enum LoadResult {
     SUCCESS,
     FAILED_TO_LOAD,
     FAILED_TO_DECODE,
   };
 
   IconLoader(const base::WeakPtr<KioskAppData>& client,
              const base::FilePath& icon_path)
       : client_(client),
         icon_path_(icon_path),
         load_result_(SUCCESS) {}
 
   void Start() {
     base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
     base::SequencedWorkerPool::SequenceToken token = pool->GetSequenceToken();
     task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
         token,
         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&IconLoader::LoadOnBlockingPool,
                                       base::Unretained(this)));
   }
 
  private:
   friend class base::RefCountedThreadSafe<IconLoader>;
 
-  ~IconLoader() override {}
+  ~IconLoader() {}
+
+  class IconImageRequest : public ImageDecoder::ImageRequest {
+   public:
+    IconImageRequest(
+        const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+        IconLoader* icon_loader)
+        : ImageRequest(task_runner), icon_loader_(icon_loader) {}
+
+    void OnImageDecoded(const SkBitmap& decoded_image) override {
+      icon_loader_->icon_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
+      icon_loader_->icon_.MakeThreadSafe();
+      icon_loader_->ReportResultOnBlockingPool(SUCCESS);
+      delete this;
+    }
+
+    void OnDecodeImageFailed() override {
+      icon_loader_->ReportResultOnBlockingPool(FAILED_TO_DECODE);
+      delete this;
+    }
+
+   private:
+    ~IconImageRequest() override {}
+    IconLoader* icon_loader_;
+  };
 
   // Loads the icon from locally stored |icon_path_| on the blocking pool
   void LoadOnBlockingPool() {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     std::string data;
     if (!base::ReadFileToString(base::FilePath(icon_path_), &data)) {
       ReportResultOnBlockingPool(FAILED_TO_LOAD);
       return;
     }
     raw_icon_ = base::RefCountedString::TakeString(&data);
 
-    scoped_refptr<ImageDecoder> image_decoder = new ImageDecoder(
-        this, raw_icon_->data(), ImageDecoder::DEFAULT_CODEC);
-    image_decoder->Start(task_runner_);
+    IconImageRequest* image_request = new IconImageRequest(task_runner_, this);
+    ImageDecoder::Start(image_request, raw_icon_->data(),
+                        ImageDecoder::DEFAULT_CODEC, false);
   }
 
   void ReportResultOnBlockingPool(LoadResult result) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     load_result_ = result;
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&IconLoader::ReportResultOnUIThread,
@@ skipping 10 matching lines @@
       client_->OnIconLoadFailure();
   }
 
   void ReportResultOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     NotifyClient();
     delete this;
   }
 
-  // ImageDecoder::Delegate overrides:
-  void OnImageDecoded(const ImageDecoder* decoder,
-                      const SkBitmap& decoded_image) override {
-    icon_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
-    icon_.MakeThreadSafe();
-    ReportResultOnBlockingPool(SUCCESS);
-  }
-
-  void OnDecodeImageFailed(const ImageDecoder* decoder) override {
-    ReportResultOnBlockingPool(FAILED_TO_DECODE);
-  }
-
   base::WeakPtr<KioskAppData> client_;
   base::FilePath icon_path_;
 
   LoadResult load_result_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   gfx::ImageSkia icon_;
   scoped_refptr<base::RefCountedString> raw_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(IconLoader);
@@ skipping 10 matching lines @@
       : client_(client) {}
 
   void Start(const std::string& app_id,
              const std::string& manifest,
              const GURL& icon_url,
              net::URLRequestContextGetter* context_getter) {
     scoped_refptr<extensions::WebstoreInstallHelper> webstore_helper =
         new extensions::WebstoreInstallHelper(this,
                                               app_id,
                                               manifest,
-                                              "",  // No icon data.
                                               icon_url,
                                               context_getter);
     webstore_helper->Start();
   }
 
  private:
   friend class base::RefCounted<WebstoreDataParser>;
 
   ~WebstoreDataParser() override {}
 
@@ skipping 323 matching lines @@
 
   SkBitmap icon = crx_loader->icon();
   if (icon.empty())
     icon = *extensions::util::GetDefaultAppIcon().bitmap();
   SetCache(crx_loader->name(), icon);
 
   SetStatus(STATUS_LOADED);
 }
 
 }  // namespace chromeos