Convert 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 "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_utility_messages.h"
+#include "chrome/common/image_decoder.mojom.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
+#include "content/public/common/service_registry.h"
+#include "skia/public/type_converters.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::UtilityProcessHost;
 
 namespace {
 
 // static, Leaky to allow access from any thread.
 base::LazyInstance<ImageDecoder>::Leaky g_decoder = LAZY_INSTANCE_INITIALIZER;
 
 // How long to wait after the last request has been received before ending
 // batch mode.
 const int kBatchModeTimeoutSeconds = 5;
 
+void OnDecodeImageDone(
+    base::Callback<void(int)> fail_callback,
+    base::Callback<void(const SkBitmap&, int)> success_callback,
+    int request_id, skia::mojom::BitmapPtr image) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (image) {
+    SkBitmap bitmap = image.To<SkBitmap>();
+    if (!bitmap.empty()) {
+      success_callback.Run(bitmap, request_id);
+      return;
+    }
+  }
+  fail_callback.Run(request_id);
+}
+
 }  // namespace
 
 ImageDecoder::ImageDecoder()
     : image_request_id_counter_(0) {
   // A single ImageDecoder instance should live for the life of the program.
   // Explicitly add a reference so the object isn't deleted.
   AddRef();
 }
 
 ImageDecoder::~ImageDecoder() {
@@ skipping 86 matching lines @@
   }
 
   if (!batch_mode_timer_) {
     // Created here so it will call StopBatchMode() on the right thread.
     batch_mode_timer_.reset(new base::DelayTimer(
         FROM_HERE, base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds), this,
         &ImageDecoder::StopBatchMode));
   }
   batch_mode_timer_->Reset();
 
-  switch (image_codec) {
+  mojom::ImageCodec mojo_codec = mojom::ImageCodec::DEFAULT;
 #if defined(OS_CHROMEOS)
-    case ROBUST_JPEG_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
-          image_data, request_id));
-      break;
-    case ROBUST_PNG_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_RobustPNGDecodeImage(
-          image_data, request_id));
-      break;
+  if (image_codec == ROBUST_JPEG_CODEC)
+    mojo_codec = mojom::ImageCodec::ROBUST_JPEG;
+  if (image_codec == ROBUST_PNG_CODEC)
+    mojo_codec = mojom::ImageCodec::ROBUST_PNG;
 #endif  // defined(OS_CHROMEOS)
-    case DEFAULT_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
-          image_data, shrink_to_fit, request_id));
-      break;
-  }
+  (*decoder_)->DecodeImage(
+      mojo::Array<uint8_t>::From(image_data),
+      mojo_codec,
+      shrink_to_fit,
+      base::Bind(&OnDecodeImageDone,
+                 base::Bind(&ImageDecoder::OnDecodeImageFailed, this),
+                 base::Bind(&ImageDecoder::OnDecodeImageSucceeded, this),
+                 request_id));
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   base::AutoLock lock(map_lock_);
   for (auto it = image_request_id_map_.begin();
        it != image_request_id_map_.end();) {
     if (it->second == image_request) {
       image_request_id_map_.erase(it++);
     } else {
       ++it;
     }
   }
 }
 
 void ImageDecoder::StartBatchMode() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   utility_process_host_ =
       UtilityProcessHost::Create(
           this, base::ThreadTaskRunnerHandle::Get().get())->AsWeakPtr();
   utility_process_host_->SetName(l10n_util::GetStringUTF16(
       IDS_UTILITY_PROCESS_IMAGE_DECODER_NAME));
-  if (!utility_process_host_->StartBatchMode()) {
-     utility_process_host_.reset();
-     return;
+  decoder_.reset(new mojom::ImageDecoderPtr);
+  if (!utility_process_host_->StartMojoMode()) {
+    utility_process_host_.reset();

[jam, 2016/03/31 17:46:33]

(this already existed)
should also delete utility_process_host_.get() to avoid a leak right?

[Anand Mistry (off Chromium), 2016/04/01 05:35:11]

Oops, yeah, this should be a delete (the reset would be redundant). Note, this
works around crbug.com/431906.

+    return;
   }
+  content::ServiceRegistry* service_registry =
+      utility_process_host_->GetServiceRegistry();
+  service_registry->ConnectToRemoteService(mojo::GetProxy(decoder_.get()));
 }
 
 void ImageDecoder::StopBatchMode() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   {
     // Check for outstanding requests and wait for them to finish.
     base::AutoLock lock(map_lock_);
     if (!image_request_id_map_.empty()) {
       batch_mode_timer_->Reset();
       return;
     }
   }
 
   if (utility_process_host_) {
-    utility_process_host_->EndBatchMode();
+    // With Mojo, the utility process needs to be explicitly shut down by
+    // deleting the host.
+    delete utility_process_host_.get();
+    decoder_.reset();
     utility_process_host_.reset();
   }
 }
 
 void ImageDecoder::FailAllRequests() {
   RequestMap requests;
   {
     base::AutoLock lock(map_lock_);
     requests = image_request_id_map_;
   }
@@ skipping 11 matching lines @@
 void ImageDecoder::OnProcessCrashed(int exit_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   FailAllRequests();
 }
 
 void ImageDecoder::OnProcessLaunchFailed() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   FailAllRequests();
 }
 
-bool ImageDecoder::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ImageDecoder, 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;
+bool ImageDecoder::OnMessageReceived(const IPC::Message& message) {
+  return false;
 }
 
 void ImageDecoder::OnDecodeImageSucceeded(
     const SkBitmap& decoded_image,
     int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   base::AutoLock lock(map_lock_);
   auto it = image_request_id_map_.find(request_id);
   if (it == image_request_id_map_.end())
     return;
@@ skipping 43 matching lines @@
     auto it = image_request_id_map_.find(request_id);
     if (it == image_request_id_map_.end())
       return;
     image_request = it->second;
     image_request_id_map_.erase(it);
   }
 
   DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread());
   image_request->OnDecodeImageFailed();
 }