Make image_decoder a Leaky LazyInstance

chrome/browser/android/logo_service.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/android/logo_service.h"
 
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/image_decoder.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
@@ skipping 21 matching lines @@
   GURL google_base_url(UIThreadSearchTermsData(profile).GoogleBaseURLValue());
   const char kGoogleDoodleURLPath[] = "async/newtab_mobile";
   GURL::Replacements replacements;
   replacements.SetPathStr(kGoogleDoodleURLPath);
   return google_base_url.ReplaceComponents(replacements);
 }
 
 class LogoDecoderDelegate : public ImageDecoder::Delegate {
  public:
   LogoDecoderDelegate(
-      const scoped_refptr<ImageDecoder>& image_decoder,
       const base::Callback<void(const SkBitmap&)>& image_decoded_callback)
-      : image_decoder_(image_decoder),
-        image_decoded_callback_(image_decoded_callback),
+      : image_decoded_callback_(image_decoded_callback),
         weak_ptr_factory_(this) {
     // If the ImageDecoder crashes or otherwise never completes, call
     // OnImageDecodeTimedOut() eventually to ensure that image_decoded_callback_
     // is run.
     base::MessageLoopProxy::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&LogoDecoderDelegate::OnDecodeImageFailed,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   (const ImageDecoder*) NULL),
+        FROM_HERE, base::Bind(&LogoDecoderDelegate::OnDecodeImageFailed,
+                              weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kDecodeLogoTimeoutSeconds));
   }
 
-  ~LogoDecoderDelegate() override { image_decoder_->set_delegate(NULL); }

[dcheng, 2015/03/13 14:55:11]

This is an example of an instance where cancellation semantics are required.
Calling set_delegate(NULL) here prevented the old implementation of ImageDecoder
from calling a deleted delegate. However, there doesn't appear to be an
equivalent for the new code. So at the very least, we'll need to figure out a
solution for that.

[Theresa, 2015/03/13 15:22:16]

Could delegates be stored as weak ptrs in image_decoder, then checked to make
sure they still exist? Or do we want a more explicit cancellation mechanism e.g.
a method in image_decoder that removes a delegate from the IDMap?

+  ~LogoDecoderDelegate() override {}
 
   // ImageDecoder::Delegate:
-  void OnImageDecoded(const ImageDecoder* decoder,
-                      const SkBitmap& decoded_image) override {
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
     image_decoded_callback_.Run(decoded_image);
     delete this;
   }
 
-  void OnDecodeImageFailed(const ImageDecoder* decoder) override {
+  void OnDecodeImageFailed() override {
     image_decoded_callback_.Run(SkBitmap());
     delete this;
   }
 
  private:
-  scoped_refptr<ImageDecoder> image_decoder_;
   base::Callback<void(const SkBitmap&)> image_decoded_callback_;
   base::WeakPtrFactory<LogoDecoderDelegate> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LogoDecoderDelegate);
 };
 
 class ChromeLogoDelegate : public search_provider_logos::LogoDelegate {
  public:
   ChromeLogoDelegate() {}
   ~ChromeLogoDelegate() override {}
 
   // search_provider_logos::LogoDelegate:
   void DecodeUntrustedImage(
       const scoped_refptr<base::RefCountedString>& encoded_image,
       base::Callback<void(const SkBitmap&)> image_decoded_callback) override {
-    scoped_refptr<ImageDecoder> image_decoder = new ImageDecoder(
-        NULL,
-        encoded_image->data(),
-        ImageDecoder::DEFAULT_CODEC);
     LogoDecoderDelegate* delegate =
-        new LogoDecoderDelegate(image_decoder, image_decoded_callback);
-    image_decoder->set_delegate(delegate);
-    image_decoder->Start(base::MessageLoopProxy::current());
+        new LogoDecoderDelegate(image_decoded_callback);
+    ImageDecoder::GetInstance()->Start(
+        delegate, encoded_image->data(), ImageDecoder::DEFAULT_CODEC,
+        base::MessageLoopProxy::current(), false);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeLogoDelegate);
 };
 
 }  // namespace
 
 // LogoService ----------------------------------------------------------------
 
@@ skipping 51 matching lines @@
 }
 
 LogoServiceFactory::~LogoServiceFactory() {}
 
 KeyedService* LogoServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   Profile* profile = static_cast<Profile*>(context);
   DCHECK(!profile->IsOffTheRecord());
   return new LogoService(profile);
 }