Add ColorspaceConversion to createImageBitmap(HTMLImageElement)

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/image-decoders/ImageDecoder.h"
@@ skipping 84 matching lines @@
         return nullptr;
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     if (!frame || frame->getStatus() != ImageFrame::FrameComplete)
         return nullptr;
     SkBitmap bitmap = frame->bitmap();
     if (!frameIsValid(bitmap))
         return nullptr;
     return adoptRef(SkImage::NewFromBitmap(bitmap));
 }
 
-static PassRefPtr<StaticBitmapImage> cropImage(Image* image, const IntRect& cropRect, bool flipY, bool premultiplyAlpha, AlphaDisposition alphaOp = DontPremultiplyAlpha)
+static PassRefPtr<StaticBitmapImage> cropImage(Image* image, const IntRect& cropRect, bool flipY, bool premultiplyAlpha, AlphaDisposition alphaOp = DontPremultiplyAlpha, ImageDecoder::GammaAndColorProfileOption colorspaceOp = ImageDecoder::GammaAndColorProfileApplied)
 {
     ASSERT(image);
 
     IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
     const IntRect srcRect = intersection(imgRect, 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() && !premultiplyAlpha) {
         SkImageInfo info = SkImageInfo::Make(cropRect.width(), cropRect.height(), kN32_SkColorType, kUnpremul_SkAlphaType);
         OwnPtr<uint8_t[]> dstPixels = adoptArrayPtr(new uint8_t[cropRect.width() * cropRect.height() * info.bytesPerPixel()]());
         return StaticBitmapImage::create(newSkImageFromRaster(info, dstPixels.release(), cropRect.width() * info.bytesPerPixel()));
     }
 
     RefPtr<SkImage> skiaImage = image->imageForCurrentFrame();
     // Attempt to get raw unpremultiplied image data, executed only when skiaImage is premultiplied.
-    if (((!premultiplyAlpha && !skiaImage->isOpaque()) || !skiaImage) && image->data() && alphaOp == DontPremultiplyAlpha) {
-        // TODO(xidachen): GammaAndColorProfileApplied needs to be changed when working on color-space conversion
-        OwnPtr<ImageDecoder> decoder(ImageDecoder::create(
-            *(image->data()), ImageDecoder::AlphaNotPremultiplied,
-            ImageDecoder::GammaAndColorProfileApplied));
+    if ((((!premultiplyAlpha && !skiaImage->isOpaque()) || !skiaImage) && image->data() && alphaOp == DontPremultiplyAlpha) || colorspaceOp == ImageDecoder::GammaAndColorProfileIgnored) {
+        OwnPtr<ImageDecoder> decoder(ImageDecoder::create(*(image->data()),
+            premultiplyAlpha ? ImageDecoder::AlphaPremultiplied : ImageDecoder::AlphaNotPremultiplied,

[Justin Novosad, 2016/03/30 16:03:20]

Not new to this CL, but could you clarify the difference between alphaOp and
premultiplyAlpha? I am have trouble following this. Code needs to be cleaned-up
for readability.

[xidachen, 2016/03/30 17:36:03]

The parameter "premultiplyAlpha" indicates whether we want the created
ImageBitmap to be in premultiplied or unpremultiplied format.

"alphaOp" is specifically designed for createImageBitmap from ImageBitmap and
Blob. For example, when we do ImageBitmap2 = createImageBitmap(ImageBitmap1,
premultiplyAlpha=false), and ImageBitmap1 is already unpremultiplied format, we
don't want to use decoder to decode it again.

[xidachen, 2016/03/30 17:45:30]

Maybe change the "alphaOp" to "imageFormat" to indicate the format of the first
parameter "image", whether it is premultiplied or unpremultiplied?

+            colorspaceOp));
         if (!decoder)
             return nullptr;
         decoder->setData(image->data(), true);
         skiaImage = ImageBitmap::getSkImageFromDecoder(decoder.release());
         if (!skiaImage)
             return nullptr;
     }
 
     if (cropRect == srcRect) {
         if (flipY)
@@ skipping 25 matching lines @@
         return StaticBitmapImage::create(skiaImage.release());
     return StaticBitmapImage::create(premulSkImageToUnPremul(skiaImage.get()));
 }
 
 ImageBitmap::ImageBitmap(HTMLImageElement* image, const IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
 {
     bool flipY;
     bool premultiplyAlpha;
     parseOptions(options, flipY, premultiplyAlpha);
 
-    m_image = cropImage(image->cachedImage()->getImage(), cropRect, flipY, premultiplyAlpha);
+    if (options.colorspaceConversion() == "none")
+        m_image = cropImage(image->cachedImage()->getImage(), cropRect, flipY, premultiplyAlpha, DontPremultiplyAlpha, ImageDecoder::GammaAndColorProfileIgnored);
+    else
+        m_image = cropImage(image->cachedImage()->getImage(), cropRect, flipY, premultiplyAlpha, DontPremultiplyAlpha, ImageDecoder::GammaAndColorProfileApplied);
     if (!m_image)
         return;
     m_image->setOriginClean(!image->wouldTaintOrigin(document->getSecurityOrigin()));
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLVideoElement* video, const IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
 {
     IntSize playerSize;
     if (video->webMediaPlayer())
@@ skipping 279 matching lines @@
 FloatSize ImageBitmap::elementSize(const FloatSize&) const
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
 }
 
 } // namespace blink