Turn the utility process image decoder into a Mojo service.

skia/public/type_converters.cc

+// Copyright 2015 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 "skia/public/type_converters.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+namespace mojo {
+
+namespace {
+
+SkColorType MojoColorTypeToSk(skia::ColorType type) {
+  switch (type) {
+    case skia::COLOR_TYPE_UNKNOWN:
+      return kUnknown_SkColorType;
+    case skia::COLOR_TYPE_ALPHA_8:
+      return kAlpha_8_SkColorType;
+    case skia::COLOR_TYPE_RGB_565:
+      return kRGB_565_SkColorType;
+    case skia::COLOR_TYPE_ARGB_4444:
+      return kARGB_4444_SkColorType;
+    case skia::COLOR_TYPE_RGBA_8888:
+      return kRGBA_8888_SkColorType;
+    case skia::COLOR_TYPE_BGRA_8888:
+      return kBGRA_8888_SkColorType;
+    case skia::COLOR_TYPE_INDEX_8:
+      return kIndex_8_SkColorType;
+    case skia::COLOR_TYPE_GRAY_8:
+      return kGray_8_SkColorType;
+    default:
+      NOTREACHED();
+  }
+  return kUnknown_SkColorType;
+}
+
+SkAlphaType MojoAlphaTypeToSk(skia::AlphaType type) {
+  switch (type) {
+    case skia::ALPHA_TYPE_UNKNOWN:
+      return kUnknown_SkAlphaType;
+    case skia::ALPHA_TYPE_OPAQUE:
+      return kOpaque_SkAlphaType;
+    case skia::ALPHA_TYPE_PREMUL:
+      return kPremul_SkAlphaType;
+    case skia::ALPHA_TYPE_UNPREMUL:
+      return kUnpremul_SkAlphaType;
+    default:
+      NOTREACHED();
+  }
+  return kUnknown_SkAlphaType;
+}
+
+skia::ColorType SkColorTypeToMojo(SkColorType type) {
+  switch (type) {
+    case kUnknown_SkColorType:
+      return skia::COLOR_TYPE_UNKNOWN;
+    case kAlpha_8_SkColorType:
+      return skia::COLOR_TYPE_ALPHA_8;
+    case kRGB_565_SkColorType:
+      return skia::COLOR_TYPE_RGB_565;
+    case kARGB_4444_SkColorType:
+      return skia::COLOR_TYPE_ARGB_4444;
+    case kRGBA_8888_SkColorType:
+      return skia::COLOR_TYPE_RGBA_8888;
+    case kBGRA_8888_SkColorType:
+      return skia::COLOR_TYPE_BGRA_8888;
+    case kIndex_8_SkColorType:
+      return skia::COLOR_TYPE_INDEX_8;
+    case kGray_8_SkColorType:
+      return skia::COLOR_TYPE_GRAY_8;
+    default:
+      NOTREACHED();
+  }
+  return skia::COLOR_TYPE_UNKNOWN;
+}
+
+skia::AlphaType SkAlphaTypeToMojo(SkAlphaType type) {
+  switch (type) {
+    case kUnknown_SkAlphaType:
+      return skia::ALPHA_TYPE_UNKNOWN;
+    case kOpaque_SkAlphaType:
+      return skia::ALPHA_TYPE_OPAQUE;
+    case kPremul_SkAlphaType:
+      return skia::ALPHA_TYPE_PREMUL;
+    case kUnpremul_SkAlphaType:
+      return skia::ALPHA_TYPE_UNPREMUL;
+    default:
+      NOTREACHED();
+  }
+  return skia::ALPHA_TYPE_UNKNOWN;
+}
+
+}  // namespace
+
+SkBitmap TypeConverter<SkBitmap, skia::BitmapPtr>::Convert(

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

Why not take a skia::Bitmap?

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

Because almost nothing references it (or any other struct) in practice.
Everything takes and gives StructPtr<> wrappers.

FYI, //mojo/converters appears to be all over the place with respect to this.

[Sam McNally, 2015/04/09 08:35:30]

If the converter doesn't need to handle null input (or something fancy like
moving out of a StructPtr passed by value), I think we should prefer taking the
struct itself.

[Anand Mistry (off Chromium), 2015/04/10 02:56:27]

Ok. Done.

[Anand Mistry (off Chromium), 2015/05/13 05:44:05]

Sam: Actually, I had to revert this change. You need to use StructPtr<> in order
to use the type converter with an array, which is what leon's change needs to
do.

[Sam McNally, 2015/05/13 05:52:04]

OK, please handle the case of a null BitmapPtr.

[Anand Mistry (off Chromium), 2015/05/13 07:36:07]

Done.

+    const skia::BitmapPtr& image) {
+  SkBitmap bitmap;
+  if (!bitmap.tryAllocPixels(SkImageInfo::Make(
+          image->width, image->height, MojoColorTypeToSk(image->color_type),
+          MojoAlphaTypeToSk(image->alpha_type)))) {
+    return SkBitmap();
+  }
+  if (bitmap.getSize() != image->pixel_data.size()) {
+    return SkBitmap();
+  }
+
+  memcpy(bitmap.getPixels(), &image->pixel_data[0], bitmap.getSize());
+  return bitmap;
+}
+
+skia::BitmapPtr TypeConverter<skia::BitmapPtr, SkBitmap>::Convert(
+    const SkBitmap& bitmap) {
+  skia::BitmapPtr result = skia::Bitmap::New();
+  const SkImageInfo& info = bitmap.info();
+  result->color_type = SkColorTypeToMojo(info.fColorType);
+  result->alpha_type = SkAlphaTypeToMojo(info.fAlphaType);
+  result->width = info.fWidth;
+  result->height = info.fHeight;
+  SkAutoLockPixels lock(bitmap);
+  size_t size = bitmap.getSize();
+  result->pixel_data = mojo::Array<uint8_t>::New(size);
+  memcpy(&result->pixel_data[0], bitmap.getPixels(), size);
+  return result.Pass();
+}
+
+}  // namespace mojo