Turn the utility process image decoder into a Mojo service.

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_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
+#include "content/public/common/service_registry.h"
+#include "services/image_decoder/public/interfaces/image_decoder.mojom.h"
+#include "skia/public/type_converters.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) {
 }
 
 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() {}

[sky, 2015/04/01 15:00:45]

I'm not familiar with this class. What thread is the destructor run on?

[Anand Mistry (off Chromium), 2015/04/02 04:29:45]

Most likely the task_runner_ thread (usually UI) since the last reference to
this should be the success/failed callback. However, this is why
decoder_.reset() exists in the Mojo callback and error handler below. The
response callback holds a reference and ensures this doesn't get deleted unless
either the callback or error handler has run. Subtle,  I know. Maybe I should
split the Mojo part into a helper class to make it less subtle.

[sky, 2015/04/02 17:20:10]

I'm ok with that, as long as you add DCHECKs and better documentation indicating
this.

[Theresa, 2015/04/13 18:52:27]

I'm pretty sure this method actually never gets run anymore. We explicitly call
AddRef() in the constructor to leak a reference so that the single ImageDecoder
object lives for the life of the program.

I did a really quick, simple test where I added NOTREACHED(); to this destructor
and ran the UserImageManager browser tests, and they all still passed.

 
 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_));
 }
 
 bool ImageDecoder::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 12 matching lines @@
   if (delegate_)
     delegate_->OnImageDecoded(this, decoded_image);
 }
 
 void ImageDecoder::OnDecodeImageFailed() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   if (delegate_)
     delegate_->OnDecodeImageFailed(this);
 }
 
+void ImageDecoder::OnDecodeImageDone(bool success, skia::BitmapPtr image) {

[sky, 2015/04/01 15:00:45]

Order doesn't match header.

[Anand Mistry (off Chromium), 2015/04/02 04:29:45]

You mean ordering of functions? Fixed that.

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  decoder_.reset();
+  if (delegate_ && success && image) {
+    SkBitmap bitmap = image.To<SkBitmap>();
+    if (!bitmap.empty()) {
+      task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&ImageDecoder::OnDecodeImageSucceeded, this, bitmap));
+      return;
+    }
+  }
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&ImageDecoder::OnDecodeImageFailed, this));
+}
+
+void ImageDecoder::OnConnectionError() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Destroys the local Mojo endpoint, which releases Mojo's references to this
+  // object from the DecodeImage callback. Also, we need to make sure this is
+  // destroyed on the IO thread since Mojo is thread-hostile.
+  decoder_.reset();
+}
+
 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));
+
+  if (switches::MojoUtilityServicesEnabled()) {
+    if (!utility_process_host->StartMojoMode()) {
+      OnDecodeImageDone(false, nullptr);
+      return;
+    }
+    content::ServiceRegistry* service_registry =
+        utility_process_host->GetServiceRegistry();
+    service_registry->ConnectToRemoteService(&decoder_);
+    decoder_.set_error_handler(this);
+
+    decoder_->DecodeImage(
+        mojo::Array<uint8_t>::From(image_data),
+        image_codec_ == ROBUST_JPEG_CODEC ? services::IMAGE_CODEC_ROBUST_JPEG
+                                          : services::IMAGE_CODEC_DEFAULT,
+        shrink_to_fit_, base::Bind(&ImageDecoder::OnDecodeImageDone, this));
   } else {
-    utility_process_host->Send(
-        new ChromeUtilityMsg_DecodeImage(image_data, shrink_to_fit_));
+    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_));
+    }
   }
 }