Merge color options into ColorBehavior

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 257 matching lines @@
 }
 
 // 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(
     Image* image,
     const ParsedOptions& parsedOptions,
-    AlphaDisposition imageFormat = PremultiplyAlpha,
-    ImageDecoder::ColorSpaceOption colorSpaceOp =
-        ImageDecoder::ColorSpaceTransformed) {
+    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) {
     SkImageInfo info =
         SkImageInfo::Make(parsedOptions.resizeWidth, parsedOptions.resizeHeight,
                           kN32_SkColorType, kUnpremul_SkAlphaType);
     RefPtr<ArrayBuffer> dstBuffer = ArrayBuffer::createOrNull(
         static_cast<unsigned>(info.width()) * info.height(),
         info.bytesPerPixel());
     if (!dstBuffer)
       return nullptr;
     RefPtr<Uint8Array> dstPixels =
         Uint8Array::create(dstBuffer, 0, dstBuffer->byteLength());
     return StaticBitmapImage::create(newSkImageFromRaster(
         info, std::move(dstPixels),
         static_cast<unsigned>(info.width()) * info.bytesPerPixel()));
   }
 
   sk_sp<SkImage> skiaImage = image->imageForCurrentFrame();
   // Attempt to get raw unpremultiplied image data, executed only when skiaImage
   // is premultiplied.
   if ((((!parsedOptions.premultiplyAlpha && !skiaImage->isOpaque()) ||
         !skiaImage) &&
        image->data() && imageFormat == PremultiplyAlpha) ||
-      colorSpaceOp == ImageDecoder::ColorSpaceIgnored) {
+      colorBehavior.isIgnore()) {
     std::unique_ptr<ImageDecoder> decoder(ImageDecoder::create(
         image->data(), true,
         parsedOptions.premultiplyAlpha ? ImageDecoder::AlphaPremultiplied
                                        : ImageDecoder::AlphaNotPremultiplied,
-        colorSpaceOp, colorSpaceOp == ImageDecoder::ColorSpaceTransformed
-                          ? ImageDecoder::globalTargetColorSpace()
-                          : nullptr));
+        colorBehavior));
     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.flipY)
@@ skipping 57 matching lines @@
                          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);
+                        ColorBehavior::ignore());
   } else {
     m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                        ImageDecoder::ColorSpaceTransformed);
+                        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());
@@ skipping 70 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);
+  m_image = cropImage(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 190 matching lines @@
 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(input.get(), parsedOptions, bitmap->isPremultiplied()
-                                                      ? PremultiplyAlpha
-                                                      : DontPremultiplyAlpha);
+  m_image = cropImage(
+      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);
+  m_image = cropImage(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