Make image_decoder a Leaky LazyInstance

chrome/browser/apps/drive/drive_app_converter.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/apps/drive/drive_app_converter.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 class DriveAppConverter::IconFetcher : public net::URLFetcherDelegate,
                                        public ImageDecoder::Delegate {
  public:
   IconFetcher(DriveAppConverter* converter,
               const GURL& icon_url,
               int expected_size)
       : converter_(converter),
         icon_url_(icon_url),
         expected_size_(expected_size) {}
   ~IconFetcher() override {
-    if (image_decoder_.get())
-      image_decoder_->set_delegate(NULL);
   }
 
   void Start() {
     fetcher_.reset(
         net::URLFetcher::Create(icon_url_, net::URLFetcher::GET, this));
     fetcher_->SetRequestContext(converter_->profile_->GetRequestContext());
     fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
     fetcher_->Start();
   }
 
   const GURL& icon_url() const { return icon_url_; }
   const SkBitmap& icon() const { return icon_; }
 
  private:
   // net::URLFetcherDelegate overrides:
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     CHECK_EQ(fetcher_.get(), source);
     scoped_ptr<net::URLFetcher> fetcher(fetcher_.Pass());
 
     if (!fetcher->GetStatus().is_success() ||
         fetcher->GetResponseCode() != net::HTTP_OK) {
       converter_->OnIconFetchComplete(this);
       return;
     }
 
     std::string unsafe_icon_data;
     fetcher->GetResponseAsString(&unsafe_icon_data);
 
-    image_decoder_ =
-        new ImageDecoder(this, unsafe_icon_data, ImageDecoder::DEFAULT_CODEC);
-    image_decoder_->Start(
+    ImageDecoder::GetInstance()->Start(
+        this, unsafe_icon_data, ImageDecoder::DEFAULT_CODEC,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI));
   }
 
   // ImageDecoder::Delegate overrides:
-  void OnImageDecoded(const ImageDecoder* decoder,
-                      const SkBitmap& decoded_image) override {
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
     if (decoded_image.width() == expected_size_)
       icon_ = decoded_image;
     converter_->OnIconFetchComplete(this);
   }
 
-  void OnDecodeImageFailed(const ImageDecoder* decoder) override {
+  void OnDecodeImageFailed() override {
     converter_->OnIconFetchComplete(this);
   }
 
   DriveAppConverter* converter_;
   const GURL icon_url_;
   const int expected_size_;
 
   scoped_ptr<net::URLFetcher> fetcher_;
-  scoped_refptr<ImageDecoder> image_decoder_;
   SkBitmap icon_;
 
   DISALLOW_COPY_AND_ASSIGN(IconFetcher);
 };
 
 DriveAppConverter::DriveAppConverter(Profile* profile,
                                      const drive::DriveAppInfo& drive_app_info,
                                      const FinishedCallback& finished_callback)
     : profile_(profile),
       drive_app_info_(drive_app_info),
@@ skipping 96 matching lines @@
     return;
   }
 
   extension_ = crx_installer_->extension();
   is_new_install_ = success && crx_installer_->current_version().empty();
   PostInstallCleanUp();
 
   finished_callback_.Run(this, success);
   // |finished_callback_| could delete this.
 }