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 183 matching lines @@
 class KioskAppData::IconLoader : public ImageDecoder::Delegate {
  public:
   enum LoadResult {
     SUCCESS,
     FAILED_TO_LOAD,
     FAILED_TO_DECODE,
   };
 
   IconLoader(const base::WeakPtr<KioskAppData>& client,
              const base::FilePath& icon_path)
-      : client_(client),
+      : Delegate(task_runner_),
+        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,
@@ skipping 10 matching lines @@
   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_);
+    ImageDecoder::Start(this, 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 11 matching lines @@
   }
 
   void ReportResultOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     NotifyClient();
     delete this;
   }
 
   // ImageDecoder::Delegate overrides:
-  void OnImageDecoded(const ImageDecoder* decoder,
-                      const SkBitmap& decoded_image) override {
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
     icon_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
     icon_.MakeThreadSafe();
     ReportResultOnBlockingPool(SUCCESS);
   }
 
-  void OnDecodeImageFailed(const ImageDecoder* decoder) override {
+  void OnDecodeImageFailed() 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_;
@@ skipping 13 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