Make image_decoder a Leaky LazyInstance

chrome/browser/image_decoder.cc

 // Copyright (c) 2012 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/image_decoder.h"
 
 #include "base/bind.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 
 using content::BrowserThread;
 using content::UtilityProcessHost;
 
-ImageDecoder::ImageDecoder(Delegate* delegate,
-                           const std::string& image_data,
-                           ImageCodec image_codec)
-    : delegate_(delegate),
-      image_data_(image_data.begin(), image_data.end()),
-      image_codec_(image_codec),
-      task_runner_(NULL),
-      shrink_to_fit_(false) {
+// static, Leaky to allow access from any thread.
+base::LazyInstance<ImageDecoder>::Leaky image_decoder_instance_ =
+    LAZY_INSTANCE_INITIALIZER;
+
+// static
+ImageDecoder* ImageDecoder::GetInstance() {
+  return image_decoder_instance_.Pointer();
 }
 
-ImageDecoder::ImageDecoder(Delegate* delegate,
-                           const std::vector<char>& image_data,
-                           ImageCodec image_codec)
-    : delegate_(delegate),
-      image_data_(image_data.begin(), image_data.end()),
-      image_codec_(image_codec),
-      task_runner_(NULL),
-      shrink_to_fit_(false) {
+ImageDecoder::ImageDecoder() : image_decoder_impl_(new ImageDecoderImpl()) {
 }
 
-ImageDecoder::~ImageDecoder() {}
-
-void ImageDecoder::Start(scoped_refptr<base::SequencedTaskRunner> task_runner) {
-  task_runner_ = task_runner;
-  BrowserThread::PostTask(
-     BrowserThread::IO, FROM_HERE,
-     base::Bind(&ImageDecoder::DecodeImageInSandbox, this, image_data_));
+ImageDecoder::~ImageDecoder() {
 }
 
-bool ImageDecoder::OnMessageReceived(const IPC::Message& message) {
+ImageDecoder::Delegate::Delegate(
+    const scoped_refptr<base::SequencedTaskRunner>& t)
+    : t(t) {
+}
+
+ImageDecoder::Delegate::~Delegate() {

[dcheng, 2015/03/20 00:14:45]

Call RemoveDelegate(this) here. Deleting this should automatically cancel. This
removes the need for subclasses like LogoDecoderDelegate to manually call it.

[Theresa, 2015/03/20 19:09:01]

Done.

+}
+
+void ImageDecoder::Start(Delegate* delegate,
+                         const std::string& image_data,
+                         ImageCodec image_codec,
+                         bool shrink_to_fit) {
+  DCHECK(delegate);
+  DCHECK(delegate->task_runner());
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &ImageDecoder::ImageDecoderImpl::DecodeImageInSandbox,
+          GetInstance()->image_decoder_impl_, delegate,
+          std::vector<unsigned char>(image_data.begin(), image_data.end()),
+          image_codec, shrink_to_fit));
+}
+
+void ImageDecoder::RemoveDelegate(Delegate* delegate) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ImageDecoder::ImageDecoderImpl::RemoveDelegate,
+                 GetInstance()->image_decoder_impl_, delegate));
+}
+
+// ImageDecoder::ImageDecoderImpl Methods
+
+ImageDecoder::ImageDecoderImpl::ImageDecoderImpl()
+    : delegate_id_counter_(0),
+      last_request_(base::TimeTicks::Now()),
+      batch_mode_started_(false) {
+}
+
+ImageDecoder::ImageDecoderImpl::~ImageDecoderImpl() {
+}
+
+void ImageDecoder::ImageDecoderImpl::DecodeImageInSandbox(
+    Delegate* delegate,
+    const std::vector<unsigned char>& image_data,
+    ImageCodec image_codec,
+    bool shrink_to_fit) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!batch_mode_started_) {
+    StartBatchMode();
+  }
+
+  last_request_ = base::TimeTicks::Now();
+  delegate_id_map_.AddWithID(delegate, delegate_id_counter_);
+
+  switch (image_codec) {
+    case ROBUST_JPEG_CODEC:
+      utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
+          image_data, delegate_id_counter_));
+      break;
+    case DEFAULT_CODEC:
+      utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
+          image_data, shrink_to_fit, delegate_id_counter_));
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  ++delegate_id_counter_;
+}
+
+void ImageDecoder::ImageDecoderImpl::RemoveDelegate(Delegate* delegate) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  std::vector<int> canceled_requests;
+
+  for (IDMap<Delegate>::iterator iter(&delegate_id_map_); !iter.IsAtEnd();
+       iter.Advance()) {
+    if (iter.GetCurrentValue() == delegate) {
+      canceled_requests.push_back(iter.GetCurrentKey());
+    }
+  }
+
+  for (auto id : canceled_requests) {
+    delegate_id_map_.Remove(id);
+  }
+}
+
+void ImageDecoder::ImageDecoderImpl::StartBatchMode() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  utility_process_host_ =
+      UtilityProcessHost::Create(this, base::MessageLoopProxy::current().get())
+          ->AsWeakPtr();
+  utility_process_host_->StartBatchMode();
+  batch_mode_started_ = true;
+  batch_mode_timer_.Start(FROM_HERE, kBatchModeTimeout, this,
+                          &ImageDecoder::ImageDecoderImpl::StopBatchMode);
+}
+
+void ImageDecoder::ImageDecoderImpl::StopBatchMode() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if ((base::TimeTicks::Now() - last_request_) < kBatchModeTimeout) {
+    return;
+  }
+
+  if (utility_process_host_) {
+    utility_process_host_->EndBatchMode();
+    utility_process_host_.reset();
+  }
+  batch_mode_started_ = false;
+  batch_mode_timer_.Stop();
+}
+
+bool ImageDecoder::ImageDecoderImpl::OnMessageReceived(
+    const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ImageDecoder, message)
+  IPC_BEGIN_MESSAGE_MAP(ImageDecoder::ImageDecoderImpl, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Succeeded,
                         OnDecodeImageSucceeded)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Failed,
                         OnDecodeImageFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void ImageDecoder::OnDecodeImageSucceeded(const SkBitmap& decoded_image) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  if (delegate_)
-    delegate_->OnImageDecoded(this, decoded_image);
+void ImageDecoder::ImageDecoderImpl::OnDecodeImageSucceeded(
+    const SkBitmap& decoded_image,
+    int id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (delegate_id_map_.Lookup(id)) {
+    Delegate* delegate = delegate_id_map_.Lookup(id);
+    delegate->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&Delegate::OnImageDecoded,
+                              base::Unretained(delegate), decoded_image));
+
+    delegate_id_map_.Remove(id);
+  }
 }
 
-void ImageDecoder::OnDecodeImageFailed() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  if (delegate_)
-    delegate_->OnDecodeImageFailed(this);
-}
+void ImageDecoder::ImageDecoderImpl::OnDecodeImageFailed(int id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (delegate_id_map_.Lookup(id)) {
+    Delegate* delegate = delegate_id_map_.Lookup(id);
+    delegate->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Delegate::OnDecodeImageFailed, base::Unretained(delegate)));
 
-void ImageDecoder::DecodeImageInSandbox(
-    const std::vector<unsigned char>& image_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  UtilityProcessHost* utility_process_host;
-  utility_process_host = UtilityProcessHost::Create(this, task_runner_.get());
-  if (image_codec_ == ROBUST_JPEG_CODEC) {
-    utility_process_host->Send(
-        new ChromeUtilityMsg_RobustJPEGDecodeImage(image_data));
-  } else {
-    utility_process_host->Send(
-        new ChromeUtilityMsg_DecodeImage(image_data, shrink_to_fit_));
+    delegate_id_map_.Remove(id);
   }
 }