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(
+    const skia::BitmapPtr& image) {
+  SkBitmap bitmap;
+  if (image.is_null())
+    return 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) {
+  if (bitmap.isNull())
+    return nullptr;
+
+  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);

[reed1, 2015/05/14 15:50:39]

A couple of notes:

1. there is no code to handle Index8 colortable bitmaps here.
2. lockPixels can fail, with bitmap.getPixels() returning NULL.

3. bitmap.readPixels() is the modern way to get a copy of the pixels out of a
bitmap. It requires the caller to allocate space for the pixels ahead of time,
but that should not be a problem here.

[Anand Mistry (off Chromium), 2015/05/15 06:51:23]

The goal here is to serialize the SkBitmap without performing any conversions. I
think it's also worth noting that this code is pretty much a reflection of
what's in
https://code.google.com/p/chromium/codesearch#chromium/src/ui/gfx/ipc/gfx_par...,
which has all the issues you've mentioned. I'm not sure what the correct thing
to do here is. Since no existing IPC uses Index8 (since the current IPC doesn't
support it), I wonder if it's ok to punt on support for that until it's actually
needed.

+  size_t size = bitmap.getSize();
+  result->pixel_data = mojo::Array<uint8_t>::New(size);
+  memcpy(&result->pixel_data[0], bitmap.getPixels(), size);

[reed1, 2015/05/14 15:52:12]

4. this explicitly is forcing a decode if the bitmap was backed by JPEG or PNG
or whatever. Is that required, or could we logically send the encoded form
through mojo? It could be much much smaller.

[Anand Mistry (off Chromium), 2015/05/15 06:51:23]

Actually, we want to force a decode. The two immediate users of this (this CL
and https://codereview.chromium.org/1085783002/) do untrusted image decoding in
a sandboxed process. Even for any other user, I don't think we can trust passing
a JPEG or PNG here.

+  return result.Pass();
+}
+
+}  // namespace mojo