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"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
 static const char* imageOrientationFlipY = "flipY";
 static const char* imageBitmapOptionNone = "none";
 
 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;
+  sk_sp<SkColorSpace> latestColorSpace = nullptr;
+  SkColorType dstColorType = kN32_SkColorType;
+  SkColorType latestColorType = kN32_SkColorType;
 };
 
+ParsedOptions defaultOptions() {
+  return ParsedOptions();
+}
+
 // 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");
+      // TODO(zakerinasab): Replace sRGB with a call to
+      // ImageDecoder::globalTargetColorSpace() when the crash problem on Mac
+      // is fixed. crbug.com/668546.
+      if (RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled()) {
+        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.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 24 matching lines @@
     parsedOptions.resizeQuality = kHigh_SkFilterQuality;
   else if (options.resizeQuality() == "medium")
     parsedOptions.resizeQuality = kMedium_SkFilterQuality;
   else if (options.resizeQuality() == "pixelated")
     parsedOptions.resizeQuality = kNone_SkFilterQuality;
   else
     parsedOptions.resizeQuality = kLow_SkFilterQuality;
   return parsedOptions;
 }
 
 bool dstBufferSizeHasOverflow(ParsedOptions options) {

[dcheng, 2016/12/11 20:11:58]

Nit: not introduced by this CL, but this should be const ParsedOptions&

[zakerinasab1, 2016/12/12 18:35:21]

Done.

   CheckedNumeric<unsigned> totalBytes = options.cropRect.width();
   totalBytes *= options.cropRect.height();
-  totalBytes *= options.bytesPerPixel;
+  totalBytes *= SkColorTypeBytesPerPixel(options.latestColorType);
   if (!totalBytes.IsValid())
     return true;
 
   if (!options.shouldScaleInput)
     return false;
   totalBytes = options.resizeWidth;
   totalBytes *= options.resizeHeight;
-  totalBytes *= options.bytesPerPixel;
+  totalBytes *= SkColorTypeBytesPerPixel(options.latestColorType);
   if (!totalBytes.IsValid())
     return true;
 
   return false;
 }
 
 }  // namespace
 
 static PassRefPtr<Uint8Array> copySkImageData(SkImage* input,
                                               const SkImageInfo& info) {
@@ skipping 48 matching lines @@
                          srcAddr + bottomRowStartPosition);
       }
     }
   } else {
     if (kN32_SkColorType == kBGRA_8888_SkColorType)  // needs to swizzle
       for (unsigned i = 0; i < height * bytesPerRow; i += 4)
         std::swap(srcAddr[i], srcAddr[i + 2]);
   }
 }
 
-static sk_sp<SkImage> flipSkImageVertically(SkImage* input,
-                                            AlphaDisposition alphaOp) {
+static sk_sp<SkImage> flipSkImageVertically(
+    SkImage* input,
+    bool enforceAlphaPremultiply = false,

[dcheng, 2016/12/11 20:11:58]

Ditto about preferring enums over bools here as well: at the callsites, it's not
obvious what behavior the bool controls.

[zakerinasab1, 2016/12/12 18:35:21]

Done.

+    const ParsedOptions& options = defaultOptions()) {
   unsigned width = static_cast<unsigned>(input->width());
   unsigned height = static_cast<unsigned>(input->height());
-  SkImageInfo info = SkImageInfo::MakeN32(input->width(), input->height(),
-                                          (alphaOp == PremultiplyAlpha)
-                                              ? kPremul_SkAlphaType
-                                              : kUnpremul_SkAlphaType);
+  SkAlphaType alphaType = (enforceAlphaPremultiply || options.premultiplyAlpha)
+                              ? kPremul_SkAlphaType
+                              : kUnpremul_SkAlphaType;
+  SkImageInfo info = SkImageInfo::Make(input->width(), input->height(),
+                                       options.latestColorType, alphaType,
+                                       options.latestColorSpace);
+
   unsigned imageRowBytes = width * info.bytesPerPixel();
   RefPtr<Uint8Array> imagePixels = copySkImageData(input, info);
   if (!imagePixels)
     return nullptr;
   for (unsigned i = 0; i < height / 2; i++) {
     unsigned topFirstElement = i * imageRowBytes;
     unsigned topLastElement = (i + 1) * imageRowBytes;
     unsigned bottomFirstElement = (height - 1 - i) * imageRowBytes;
     std::swap_ranges(imagePixels->data() + topFirstElement,
                      imagePixels->data() + topLastElement,
                      imagePixels->data() + bottomFirstElement);
   }
   return newSkImageFromRaster(info, std::move(imagePixels), imageRowBytes);
 }
 
-static sk_sp<SkImage> premulSkImageToUnPremul(SkImage* input) {
-  SkImageInfo info = SkImageInfo::Make(input->width(), input->height(),
-                                       kN32_SkColorType, kUnpremul_SkAlphaType);
+static sk_sp<SkImage> premulSkImageToUnPremul(
+    SkImage* input,
+    const ParsedOptions& options = defaultOptions()) {
+  SkImageInfo info = SkImageInfo::Make(
+      input->width(), input->height(), options.latestColorType,
+      kUnpremul_SkAlphaType, options.latestColorSpace);
+
   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> unPremulSkImageToPremul(SkImage* input) {
-  SkImageInfo info = SkImageInfo::Make(input->width(), input->height(),
-                                       kN32_SkColorType, kPremul_SkAlphaType);
+static sk_sp<SkImage> unPremulSkImageToPremul(
+    SkImage* input,
+    const ParsedOptions& options = defaultOptions()) {
+  SkImageInfo info = SkImageInfo::Make(
+      input->width(), input->height(), options.latestColorType,
+      kPremul_SkAlphaType, options.latestColorSpace);
+
   RefPtr<Uint8Array> dstPixels = copySkImageData(input, info);
   if (!dstPixels)
     return nullptr;
   return newSkImageFromRaster(
       info, std::move(dstPixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
+// This code is borrowed from third_party/skia/src/codec/SkCodecPriv.h
+// If you need to change this, please check SkColorSpaceXform::ColorFormat
+// and SkColorType for proper coverage.
+static inline SkColorSpaceXform::ColorFormat getXformFormat(
+    SkColorType colorType) {
+  switch (colorType) {
+    case kRGBA_8888_SkColorType:
+      return SkColorSpaceXform::kRGBA_8888_ColorFormat;
+    case kBGRA_8888_SkColorType:
+      return SkColorSpaceXform::kBGRA_8888_ColorFormat;
+    case kRGBA_F16_SkColorType:
+      return SkColorSpaceXform::kRGBA_F16_ColorFormat;
+    default:
+      SkASSERT(false);

[dcheng, 2016/12/11 20:11:58]

I think we should be writing NOTREACHED in Blink code.

[zakerinasab1, 2016/12/12 18:35:21]

Done.

+      return SkColorSpaceXform::kRGBA_8888_ColorFormat;
+  }
+}
+
+static inline void updateLatestColorInformation(ParsedOptions& options) {
+  options.latestColorType = options.dstColorType;
+  options.latestColorSpace = options.dstColorSpace;
+}
+
+// TODO (zakrinasab). Rewrite this when SkImage::readPixels() respectes the
+// color space of the passed SkImageInfo (crbug.com/skia/6021) and SkImage
+// exposes SkColorSpace and SkColorType (crbug.com/skia/6022).
+
+static sk_sp<SkImage> applyColorSpaceConversion(const sk_sp<SkImage> image,

[dcheng, 2016/12/11 20:11:58]

This refs the SkImage unnecessarily, as this method does not take ownership of
|image|. Instead, pass the image by SkImage* (similar to
unPremulSkImageToPremul, etc)

(The general guideline in Chromium and Blink is that if ownership is transferred
or taken, pass by smart pointer. Otherwise, pass by raw pointer.)

[zakerinasab1, 2016/12/12 18:35:21]

I changed the function signature. PTAL.
Passing SkImage* and returning sk_sp<SkImage> results in SkAssert(SkRefCnt > 0)
errors. I suspect this might have something to do with in-place color conversion
that we do, i.e., we use the same memory buffer of the input SkImage to write
the new pixel values for the color corrected SkImage.

[dcheng, 2016/12/12 21:13:57]

Ah... another option is to pass by value (instead of const value); then you can
std::move() and be slightly more efficient.

This is fine though.

+                                                ParsedOptions& options) {
+  if (!options.dstColorSpace)
+    return image;
+  if (SkColorSpace::Equals(options.latestColorSpace.get(),
+                           options.dstColorSpace.get()))
+    return image;
+
+  // If we have the color space information of the source image, we can use
+  // SkColorSpaceXform. Otherwise, we need to draw the image on a canvas and
+  // take a snapshot.
+  if (options.latestColorSpace) {
+    SkImageInfo info = SkImageInfo::Make(
+        image->width(), image->height(), options.latestColorType,
+        image->alphaType(), options.latestColorSpace);
+    size_t size = image->width() * image->height() * info.bytesPerPixel();
+    auto srcPixels = WTF::makeUnique<uint8_t>(size);
+    if (!image->readPixels(info, &srcPixels,
+                           image->width() * info.bytesPerPixel(), 0, 0)) {
+      return image;
+    }
+
+    // For in-place color correction, bytes per pixel must be equal for source
+    // and destination color spaces.
+    std::unique_ptr<uint8_t> dstPixels = nullptr;
+    if (SkColorTypeBytesPerPixel(options.dstColorType) !=
+        SkColorTypeBytesPerPixel(options.latestColorType)) {
+      size = image->width() * image->height() *
+             SkColorTypeBytesPerPixel(options.latestColorType);
+      dstPixels = WTF::makeUnique<uint8_t>(size);
+    }
+
+    std::unique_ptr<SkColorSpaceXform> xform = SkColorSpaceXform::New(
+        options.latestColorSpace.get(), options.dstColorSpace.get());
+    xform->apply(getXformFormat(options.dstColorType),
+                 dstPixels ? &dstPixels : &srcPixels,
+                 getXformFormat(options.latestColorType), &srcPixels,
+                 image->width() * image->height(), kUnpremul_SkAlphaType);
+
+    SkImageInfo dstInfo =
+        SkImageInfo::Make(image->width(), image->height(), options.dstColorType,
+                          image->alphaType(), options.dstColorSpace);
+    sk_sp<SkData> data(SkData::MakeWithoutCopy(&dstPixels, size));
+    sk_sp<SkImage> coloredImage = SkImage::MakeRasterData(
+        dstInfo, data, image->width() * dstInfo.bytesPerPixel());
+    if (coloredImage) {
+      updateLatestColorInformation(options);
+      return coloredImage;
+    }
+    return image;
+  }
+
+  // Skia does not support drawing to unpremul surfaces/canvases.
+  sk_sp<SkImage> unPremulImage = nullptr;
+  if (image->alphaType() == kUnpremul_SkAlphaType)
+    unPremulImage = unPremulSkImageToPremul(image.get(), options);
+
+  // If the color space of the source SkImage is null, the following code
+  // does not do any color conversion even thought the new SkImage will be
+  // tagged by the new color space. If this is the case, the following code
+  // will tag a wrong color space to the SkImage. However, this cannot be
+  // addressed here and the code that creates the SkImage must tag the
+  // SkImage with proper color space.
+  SkImageInfo imageInfo = SkImageInfo::Make(
+      image->width(), image->height(), options.dstColorType,
+      unPremulImage ? unPremulImage->alphaType() : image->alphaType(),
+      options.dstColorSpace);
+  sk_sp<SkSurface> surface = SkSurface::MakeRaster(imageInfo);
+  surface->getCanvas()->drawImage(unPremulImage ? unPremulImage : image, 0, 0);
+  sk_sp<SkImage> coloredImage = surface->makeImageSnapshot();
+  updateLatestColorInformation(options);
+  return coloredImage;
+}
+
 sk_sp<SkImage> ImageBitmap::getSkImageFromDecoder(
-    std::unique_ptr<ImageDecoder> decoder) {
+    std::unique_ptr<ImageDecoder> decoder,
+    SkColorType* decodedColorType,
+    sk_sp<SkColorSpace> decodedColorSpace,
+    bool returnColorSpaceInformation) {
   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();
+  sk_sp<SkImage> image = frame->finalizePixelsAndGetImage();
+  if (returnColorSpaceInformation) {
+    *decodedColorType = frame->bitmap().colorType();
+    decodedColorSpace = sk_sp<SkColorSpace>(frame->bitmap().colorSpace());

[dcheng, 2016/12/11 20:11:58]

This parameter is passed by value, so the caller will never see this.

Since this is an optional out param, we can combine the bool and the output
param and just have the param be a sk_sp<SkColorpace>* decodedColorSpace.

Then we can DCHECK((decodedColorType && decodedColorSpace) || (!decodedCOlorType
&& decodedColorSpace)); to make sure the arguments always agree.

[zakerinasab1, 2016/12/12 18:35:21]

The parameter is fixed. The flag is needed as the input SkColorSpace might be
null and we still need to fill it with ptoper color space information.

+  }
+  return image;
 }
 
 bool ImageBitmap::isResizeOptionValid(const ImageBitmapOptions& options,
                                       ExceptionState& exceptionState) {
   if ((options.hasResizeWidth() && options.resizeWidth() == 0) ||
       (options.hasResizeHeight() && options.resizeHeight() == 0)) {
     exceptionState.throwDOMException(
         InvalidStateError,
         "The resizeWidth or/and resizeHeight is equal to 0.");
     return false;
@@ skipping 11 matching lines @@
     return false;
   }
   return true;
 }
 
 // The parameter imageFormat indicates whether the first parameter "image" is
 // unpremultiplied or not.  imageFormat = PremultiplyAlpha means the image is in
 // premuliplied format For example, if the image is already in unpremultiplied
 // format and we want the created ImageBitmap in the same format, then we don't
 // need to use the ImageDecoder to decode the image.
-static PassRefPtr<StaticBitmapImage> cropImage(
+static PassRefPtr<StaticBitmapImage> cropImageAndApplyColorSpaceConversion(
     Image* image,
-    const ParsedOptions& parsedOptions,
+    ParsedOptions& parsedOptions,
     AlphaDisposition imageFormat,
     ColorBehavior colorBehavior) {
   ASSERT(image);
   IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
   const IntRect srcRect = intersection(imgRect, parsedOptions.cropRect);
 
   // In the case when cropRect doesn't intersect the source image and it
   // requires a umpremul image We immediately return a transparent black image
   // with cropRect.size()
   if (srcRect.isEmpty() && !parsedOptions.premultiplyAlpha) {
@@ skipping 19 matching lines @@
         !skiaImage) &&
        image->data() && imageFormat == PremultiplyAlpha) ||
       colorBehavior.isIgnore()) {
     std::unique_ptr<ImageDecoder> decoder(ImageDecoder::create(
         image->data(), true,
         parsedOptions.premultiplyAlpha ? ImageDecoder::AlphaPremultiplied
                                        : ImageDecoder::AlphaNotPremultiplied,
         colorBehavior));
     if (!decoder)
       return nullptr;
-    skiaImage = ImageBitmap::getSkImageFromDecoder(std::move(decoder));
+    skiaImage = ImageBitmap::getSkImageFromDecoder(
+        std::move(decoder), &parsedOptions.latestColorType,
+        parsedOptions.latestColorSpace, true);
     if (!skiaImage)
       return nullptr;
   }
 
   if (parsedOptions.cropRect == srcRect && !parsedOptions.shouldScaleInput) {
     sk_sp<SkImage> croppedSkImage = skiaImage->makeSubset(srcRect);
-    if (parsedOptions.flipY)
-      return StaticBitmapImage::create(flipSkImageVertically(
-          croppedSkImage.get(), parsedOptions.premultiplyAlpha
-                                    ? PremultiplyAlpha
-                                    : DontPremultiplyAlpha));
+    if (parsedOptions.dstColorSpace) {
+      croppedSkImage = applyColorSpaceConversion(croppedSkImage, parsedOptions);
+    }
+    if (parsedOptions.flipY) {
+      return StaticBitmapImage::create(
+          flipSkImageVertically(croppedSkImage.get(), false, parsedOptions));
+    }
     // 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()));
     // Call preroll to trigger image decoding.
     croppedSkImage->preroll();
     return StaticBitmapImage::create(std::move(croppedSkImage));
   }
 
@@ skipping 21 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,
-                        ColorBehavior::ignore());
+    m_image = cropImageAndApplyColorSpaceConversion(
+        input.get(), parsedOptions, PremultiplyAlpha, ColorBehavior::ignore());
   } else {
-    m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                        ColorBehavior::transformToGlobalTarget());
+    m_image = cropImageAndApplyColorSpaceConversion(
+        input.get(), parsedOptions, PremultiplyAlpha,
+        ColorBehavior::transformToGlobalTarget());
   }
+
   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());
+    SkImageInfo imageInfo = SkImageInfo::Make(
+        skImage->width(), skImage->height(), parsedOptions.dstColorType,
+        kPremul_SkAlphaType, parsedOptions.dstColorSpace);
+    sk_sp<SkSurface> surface = SkSurface::MakeRaster(imageInfo);
     surface->getCanvas()->drawImage(skImage, 0, 0);
     m_image = StaticBitmapImage::create(surface->makeImageSnapshot());
   }
   if (!m_image)
     return;
   m_image->setOriginClean(
       !image->wouldTaintOrigin(document->getSecurityOrigin()));
   m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
@@ skipping 60 matching lines @@
   ParsedOptions parsedOptions =
       parseOptions(options, cropRect, IntSize(input->width(), input->height()));
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
   bool isPremultiplyAlphaReverted = false;
   if (!parsedOptions.premultiplyAlpha) {
     parsedOptions.premultiplyAlpha = true;
     isPremultiplyAlphaReverted = true;
   }
-  m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                      ColorBehavior::transformToGlobalTarget());
+  m_image = cropImageAndApplyColorSpaceConversion(
+      input.get(), parsedOptions, PremultiplyAlpha,
+      ColorBehavior::transformToGlobalTarget());
   if (!m_image)
     return;
   if (isPremultiplyAlphaReverted) {
     parsedOptions.premultiplyAlpha = false;
     m_image = StaticBitmapImage::create(
         premulSkImageToUnPremul(m_image->imageForCurrentFrame().get()));
   }
   if (!m_image)
     return;
   m_image->setOriginClean(canvas->originClean());
@@ skipping 162 matching lines @@
                                std::min(0, -parsedOptions.cropRect.y()));
   if (parsedOptions.cropRect.x() < 0)
     dstPoint.setX(-parsedOptions.cropRect.x());
   if (parsedOptions.cropRect.y() < 0)
     dstPoint.setY(-parsedOptions.cropRect.y());
   buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(),
                        srcRect, dstPoint);
   sk_sp<SkImage> skImage =
       buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown);
   if (parsedOptions.flipY)
-    skImage = flipSkImageVertically(skImage.get(), PremultiplyAlpha);
+    skImage = flipSkImageVertically(skImage.get(), true);
   if (!skImage)
     return;
   if (parsedOptions.shouldScaleInput) {
     sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
         parsedOptions.resizeWidth, parsedOptions.resizeHeight);
     if (!surface)
       return;
     SkPaint paint;
     paint.setFilterQuality(parsedOptions.resizeQuality);
     SkRect dstDrawRect =
         SkRect::MakeWH(parsedOptions.resizeWidth, parsedOptions.resizeHeight);
     surface->getCanvas()->drawImageRect(skImage, dstDrawRect, &paint);
     skImage = surface->makeImageSnapshot();
   }
   m_image = StaticBitmapImage::create(std::move(skImage));
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap,
                          Optional<IntRect> cropRect,
                          const ImageBitmapOptions& options) {
   RefPtr<Image> input = bitmap->bitmapImage();
   if (!input)
     return;
   ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size());
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
-  m_image = cropImage(
+  m_image = cropImageAndApplyColorSpaceConversion(
       input.get(), parsedOptions,
       bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha,
       ColorBehavior::transformToGlobalTarget());
   if (!m_image)
     return;
   m_image->setOriginClean(bitmap->originClean());
   m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image,
                          Optional<IntRect> cropRect,
                          const ImageBitmapOptions& options) {
   bool originClean = image->originClean();
   RefPtr<Image> input = image;
   ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size());
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
-  m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                      ColorBehavior::transformToGlobalTarget());
+  m_image = cropImageAndApplyColorSpaceConversion(
+      input.get(), parsedOptions, PremultiplyAlpha,
+      ColorBehavior::transformToGlobalTarget());
   if (!m_image)
     return;
 
   m_image->setOriginClean(originClean);
   m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image) {
   m_image = image;
 }
@@ skipping 135 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