Color correct ImageBitmap(HTMLImageElement*) constructor

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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 "core/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
@@ skipping 13 matching lines @@
 namespace {
 
 struct ParsedOptions {
   bool flipY = false;
   bool premultiplyAlpha = true;
   bool shouldScaleInput = false;
   unsigned resizeWidth = 0;
   unsigned resizeHeight = 0;
   IntRect cropRect;
   SkFilterQuality resizeQuality = kLow_SkFilterQuality;
-  // This value should be changed in the future when we support
-  // createImageBitmap with higher bit depth, in the parseOptions() function.
-  // For now, it is always 4.
   int bytesPerPixel = 4;
+  sk_sp<SkColorSpace> dstColorSpace = nullptr;
+  SkColorType dstColorType = SkColorType::kUnknown_SkColorType;
 };
 
 // The following two functions are helpers used in cropImage
 static inline IntRect normalizeRect(const IntRect& rect) {
   return IntRect(std::min(rect.x(), rect.maxX()),
                  std::min(rect.y(), rect.maxY()),
                  std::max(rect.width(), -rect.width()),
                  std::max(rect.height(), -rect.height()));
 }
 
 ParsedOptions parseOptions(const ImageBitmapOptions& options,
                            Optional<IntRect> cropRect,
                            IntSize sourceSize) {
   ParsedOptions parsedOptions;
   if (options.imageOrientation() == imageOrientationFlipY) {
     parsedOptions.flipY = true;
   } else {
     parsedOptions.flipY = false;
     DCHECK(options.imageOrientation() == imageBitmapOptionNone);
   }
   if (options.premultiplyAlpha() == imageBitmapOptionNone) {
     parsedOptions.premultiplyAlpha = false;
   } else {
     parsedOptions.premultiplyAlpha = true;
     DCHECK(options.premultiplyAlpha() == "default" ||
            options.premultiplyAlpha() == "premultiply");
   }
 
+  if (options.colorSpaceConversion() != "none") {
+    if (!RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() ||
+        !RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+      DCHECK_EQ(options.colorSpaceConversion(), "default");
+      //parsedOptions.dstColorSpace = ImageDecoder::globalTargetColorSpace();

[zakerinasab, 2016/11/24 20:13:42]

@ccameron Can you take a look at this? When I do this call the browser crashes
on Mac on all image bitmap unit tests. Please see the Mac try-bot results for
patch set 3.

[xidachen, 2016/11/24 20:27:31]

I am fine with setting this to
SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named); + a comment or TODO saying
that it should be changed to use ImageDecoder::globalTargetColorSpace() once the
crash is fixed.

[zakerinasab, 2016/11/24 20:51:12]

Done.

+      parsedOptions.dstColorSpace =
+          SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
+      parsedOptions.dstColorType = SkColorType::kN32_SkColorType;
+    } else {
+      if (options.colorSpaceConversion() == "default" ||
+          options.colorSpaceConversion() == "srgb") {
+        parsedOptions.dstColorSpace =
+            SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
+        parsedOptions.dstColorType = SkColorType::kN32_SkColorType;
+      } else if (options.colorSpaceConversion() == "linear-rgb") {
+        parsedOptions.bytesPerPixel = 8;
+        parsedOptions.dstColorSpace =
+            SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
+        parsedOptions.dstColorType = SkColorType::kRGBA_F16_SkColorType;
+      } else {
+        NOTREACHED()
+            << "Invalid ImageBitmap creation attribute colorSpaceConversion: "
+            << options.colorSpaceConversion();
+      }
+    }
+  }
+
   int sourceWidth = sourceSize.width();
   int sourceHeight = sourceSize.height();
   if (!cropRect) {
     parsedOptions.cropRect = IntRect(0, 0, sourceWidth, sourceHeight);
   } else {
     parsedOptions.cropRect = normalizeRect(*cropRect);
   }
   if (!options.hasResizeWidth() && !options.hasResizeHeight()) {
     parsedOptions.resizeWidth = parsedOptions.cropRect.width();
     parsedOptions.resizeHeight = parsedOptions.cropRect.height();
@@ skipping 149 matching lines @@
   SkImageInfo info = SkImageInfo::Make(input->width(), input->height(),
                                        kN32_SkColorType, kPremul_SkAlphaType);
   RefPtr<Uint8Array> dstPixels = copySkImageData(input, info);
   if (!dstPixels)
     return nullptr;
   return newSkImageFromRaster(
       info, std::move(dstPixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
+static sk_sp<SkImage> applyColorSpaceConversion(
+    sk_sp<SkImage> image,
+    const ParsedOptions& parsedOptions) {
+  if (!parsedOptions.dstColorSpace)
+    return image;
+
+  SkImageInfo imageInfo = SkImageInfo::Make(
+      image->width(), image->height(), parsedOptions.dstColorType,
+      image->alphaType(), parsedOptions.dstColorSpace);
+  sk_sp<SkSurface> surface = SkSurface::MakeRaster(imageInfo);
+  surface->getCanvas()->drawImage(image, 0, 0);
+  return surface->makeImageSnapshot();
+}
+
 sk_sp<SkImage> ImageBitmap::getSkImageFromDecoder(
     std::unique_ptr<ImageDecoder> decoder) {
   if (!decoder->frameCount())
     return nullptr;
   ImageFrame* frame = decoder->frameBufferAtIndex(0);
   if (!frame || frame->getStatus() != ImageFrame::FrameComplete)
     return nullptr;
   DCHECK(!frame->bitmap().isNull() && !frame->bitmap().empty());
   return frame->finalizePixelsAndGetImage();
 }
@@ skipping 70 matching lines @@
         colorSpaceOp));
     if (!decoder)
       return nullptr;
     skiaImage = ImageBitmap::getSkImageFromDecoder(std::move(decoder));
     if (!skiaImage)
       return nullptr;
   }
 
   if (parsedOptions.cropRect == srcRect && !parsedOptions.shouldScaleInput) {
     sk_sp<SkImage> croppedSkImage = skiaImage->makeSubset(srcRect);
+    if (parsedOptions.dstColorSpace) {
+      croppedSkImage = applyColorSpaceConversion(croppedSkImage, parsedOptions);
+    }
     if (parsedOptions.flipY)
       return StaticBitmapImage::create(flipSkImageVertically(
           croppedSkImage.get(), parsedOptions.premultiplyAlpha
                                     ? PremultiplyAlpha
                                     : DontPremultiplyAlpha));
     // Special case: The first parameter image is unpremul but we need to turn
     // it into premul.
     if (parsedOptions.premultiplyAlpha && imageFormat == DontPremultiplyAlpha)
       return StaticBitmapImage::create(
           unPremulSkImageToPremul(croppedSkImage.get()));
@@ skipping 26 matching lines @@
     SkRect drawDstRect = SkRect::MakeXYWH(0, 0, parsedOptions.resizeWidth,
                                           parsedOptions.resizeHeight);
     SkPaint paint;
     paint.setFilterQuality(parsedOptions.resizeQuality);
     surface->getCanvas()->drawImageRect(skiaImage, drawSrcRect, drawDstRect,
                                         &paint);
   } else {
     surface->getCanvas()->drawImage(skiaImage, dstLeft, dstTop);
   }
   skiaImage = surface->makeImageSnapshot();
+  if (parsedOptions.dstColorSpace)
+    skiaImage = applyColorSpaceConversion(skiaImage, parsedOptions);
 
   if (parsedOptions.premultiplyAlpha) {
     if (imageFormat == DontPremultiplyAlpha)
       return StaticBitmapImage::create(
           unPremulSkImageToPremul(skiaImage.get()));
     return StaticBitmapImage::create(std::move(skiaImage));
   }
   return StaticBitmapImage::create(premulSkImageToUnPremul(skiaImage.get()));
 }
 
 ImageBitmap::ImageBitmap(HTMLImageElement* image,
                          Optional<IntRect> cropRect,
                          Document* document,
                          const ImageBitmapOptions& options) {
   RefPtr<Image> input = image->cachedImage()->getImage();
   ParsedOptions parsedOptions =
       parseOptions(options, cropRect, image->bitmapSourceSize());
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
-  if (options.colorSpaceConversion() == "none") {
-    m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                        ImageDecoder::ColorSpaceIgnored);
-  } else {
-    m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                        ImageDecoder::ColorSpaceApplied);
-  }
+  m_image =
+      cropImage(input.get(), parsedOptions, PremultiplyAlpha,
+                parsedOptions.dstColorSpace ? ImageDecoder::ColorSpaceApplied
+                                            : ImageDecoder::ColorSpaceIgnored);
   if (!m_image)
     return;
   // In the case where the source image is lazy-decoded, m_image may not be in
   // a decoded state, we trigger it here.
   sk_sp<SkImage> skImage = m_image->imageForCurrentFrame();
   SkPixmap pixmap;
   if (!skImage->isTextureBacked() && !skImage->peekPixels(&pixmap)) {
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(skImage->width(), skImage->height());
     surface->getCanvas()->drawImage(skImage, 0, 0);
@@ skipping 454 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink