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 <set>
 
 #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;
 
 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
@@ skipping 184 matching lines @@
   }
 
   last_request_ = base::TimeTicks::Now();
   {
     base::AutoLock lock(map_lock_);
     auto it = image_request_id_map_.find(request_id);
     if (it != image_request_id_map_.end())
       it->second->SetStarted();
   }
 
-  switch (image_codec) {
-    case ROBUST_JPEG_CODEC:
-      utility_process_host_->Send(
-          new ChromeUtilityMsg_RobustJPEGDecodeImage(image_data, request_id));
-      break;
-    case DEFAULT_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
-          image_data, shrink_to_fit, request_id));
-      break;
+  if (switches::MojoUtilityServicesEnabled()) {
+    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,
+                                     request_id));
+  } else {
+    switch (image_codec) {
+      case ROBUST_JPEG_CODEC:
+        utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
+            image_data, request_id));
+        break;
+      case DEFAULT_CODEC:
+        utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
+            image_data, shrink_to_fit, request_id));
+        break;
+    }
   }
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   std::set<scoped_refptr<Job>> jobs;
 
   {
     base::AutoLock lock(map_lock_);
     for (const auto& request : image_request_id_map_) {
       if (request.second->image_request() == image_request) {
         jobs.insert(request.second);
         // Don't erase the job from the map here, but let Job::Cancel do it
         // instead. This is mainly to maintain consistency with how decode
         // success/fail are handled.
       }
     }
   }
 
   // Will block if |OnImageDecoded| or |OnDecodeImageFailed| is running.
   for (auto& job : jobs)
     job->Cancel();
 }
 
 void ImageDecoder::StartBatchMode() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   utility_process_host_ =
       UtilityProcessHost::Create(this, base::MessageLoopProxy::current().get())
           ->AsWeakPtr();
-  if (!utility_process_host_->StartBatchMode()) {
-     utility_process_host_.reset();
-     return;
+  if (switches::MojoUtilityServicesEnabled()) {
+    decoder_.reset();
+    if (!utility_process_host_->StartMojoMode()) {
+       utility_process_host_.reset();

[Sam McNally, 2015/04/08 08:09:00]

3 space indent?

[Anand Mistry (off Chromium), 2015/04/09 05:25:03]

Done.

+       return;
+    }
+    content::ServiceRegistry* service_registry =
+        utility_process_host_->GetServiceRegistry();
+    service_registry->ConnectToRemoteService(&decoder_);
+  } else {
+    if (!utility_process_host_->StartBatchMode()) {
+       utility_process_host_.reset();
+       return;
+    }
   }
   batch_mode_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds),
       this, &ImageDecoder::StopBatchMode);
 }
 
 void ImageDecoder::StopBatchMode() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if ((base::TimeTicks::Now() - last_request_)
       < base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds)) {
     return;
   }
 
   if (utility_process_host_) {
-    utility_process_host_->EndBatchMode();
+    if (!switches::MojoUtilityServicesEnabled())
+      utility_process_host_->EndBatchMode();
     utility_process_host_.reset();
+    decoder_.reset();
   }
   batch_mode_timer_.Stop();
 
   // There could be outstanding request that are taking too long. Fail these so
   // that there aren't any dangling requests.
   FailAllSentRequests();
 }
 
 void ImageDecoder::FailAllSentRequests() {
   RequestMap requests;
@@ skipping 63 matching lines @@
     base::AutoLock lock(map_lock_);
     auto it = image_request_id_map_.find(request_id);
     if (it != image_request_id_map_.end()) {
       job = it->second;
     }
   }
   if (job)
     job->NotifyDecodeFailed();
 }
 
+void ImageDecoder::OnDecodeImageDone(int request_id, skia::BitmapPtr image) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (image) {
+    SkBitmap bitmap = image.To<SkBitmap>();
+    if (!bitmap.empty()) {
+      OnDecodeImageSucceeded(bitmap, request_id);
+      return;
+    }
+  }
+  OnDecodeImageFailed(request_id);
+}
+
 void ImageDecoder::RemoveJob(const scoped_refptr<Job>& job) {
   base::AutoLock lock(map_lock_);
   for (auto it = image_request_id_map_.begin();
        it != image_request_id_map_.end();) {
     if (it->second == job) {
       image_request_id_map_.erase(it++);
       break;
     } else {
       ++it;
     }
   }
 }