color: Add ColorCanvasExtensions runtime flag

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 <memory>
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
@@ skipping 26 matching lines @@
 
 struct ParsedOptions {
   bool flip_y = false;
   bool premultiply_alpha = true;
   bool should_scale_input = false;
   unsigned resize_width = 0;
   unsigned resize_height = 0;
   IntRect crop_rect;
   SkFilterQuality resize_quality = kLow_SkFilterQuality;
   CanvasColorParams color_params;
-  bool color_correct_rendering_enabled = false;
-  bool use_global_target_color_space = false;
+  bool color_canvas_extensions_enabled = false;
 };
 
 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()),
@@ skipping 13 matching lines @@
   }
   if (options.premultiplyAlpha() == kImageBitmapOptionNone) {
     parsed_options.premultiply_alpha = false;
   } else {
     parsed_options.premultiply_alpha = true;
     DCHECK(options.premultiplyAlpha() == kImageBitmapOptionDefault ||
            options.premultiplyAlpha() == kImageBitmapOptionPremultiply);
   }
 
   if (options.colorSpaceConversion() != kImageBitmapOptionNone) {
-    parsed_options.color_correct_rendering_enabled =
-        RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
-        RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-    if (!parsed_options.color_correct_rendering_enabled) {
+    parsed_options.color_canvas_extensions_enabled =
+        RuntimeEnabledFeatures::colorCanvasExtensionsEnabled();
+    if (!parsed_options.color_canvas_extensions_enabled) {
       DCHECK_EQ(options.colorSpaceConversion(), kImageBitmapOptionDefault);
-      if (RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled()) {
-        parsed_options.use_global_target_color_space = true;
-      }
     } else {
       if (options.colorSpaceConversion() == kImageBitmapOptionDefault ||
           options.colorSpaceConversion() ==
               kSRGBImageBitmapColorSpaceConversion) {
         parsed_options.color_params.SetCanvasColorSpace(kSRGBCanvasColorSpace);
       } else if (options.colorSpaceConversion() ==
                  kLinearRGBImageBitmapColorSpaceConversion) {
         parsed_options.color_params.SetCanvasColorSpace(kSRGBCanvasColorSpace);
         parsed_options.color_params.SetCanvasPixelFormat(kF16CanvasPixelFormat);
       } else if (options.colorSpaceConversion() ==
@@ skipping 200 matching lines @@
   RefPtr<Uint8Array> dst_pixels = CopySkImageData(input, info);
   if (!dst_pixels)
     return nullptr;
   return NewSkImageFromRaster(
       info, std::move(dst_pixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
 static void ApplyColorSpaceConversion(sk_sp<SkImage>& image,
                                       ParsedOptions& options) {
-  if (!options.color_correct_rendering_enabled &&
-      !options.use_global_target_color_space)
+  if (!options.color_canvas_extensions_enabled)
     return;
 
   sk_sp<SkColorSpace> dst_color_space = nullptr;
   SkColorType dst_color_type = kN32_SkColorType;
-  if (options.use_global_target_color_space) {
-    dst_color_space = ColorBehavior::GlobalTargetColorSpace().ToSkColorSpace();
-  } else {
-    dst_color_space = options.color_params.GetSkColorSpace();
-    dst_color_type = options.color_params.GetSkColorType();
-  }
+  dst_color_space = options.color_params.GetSkColorSpace();
+  dst_color_type = options.color_params.GetSkColorType();
   if (SkColorSpace::Equals(image->colorSpace(), dst_color_space.get()))
     return;
 
   SkImageInfo dst_info =
       SkImageInfo::Make(image->width(), image->height(), dst_color_type,
                         image->alphaType(), dst_color_space);
 
   size_t size = image->width() * image->height() * dst_info.bytesPerPixel();
   sk_sp<SkData> dst_data = SkData::MakeUninitialized(size);
   if (dst_data->size() != size)
@@ skipping 215 matching lines @@
 
   if (!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> sk_image = image_->ImageForCurrentFrame();
   SkPixmap pixmap;
   if (!sk_image->isTextureBacked() && !sk_image->peekPixels(&pixmap)) {
     sk_sp<SkColorSpace> dst_color_space = nullptr;
     SkColorType dst_color_type = kN32_SkColorType;
-    if (parsed_options.use_global_target_color_space) {
-      dst_color_space =
-          ColorBehavior::GlobalTargetColorSpace().ToSkColorSpace();
-    } else if (parsed_options.color_correct_rendering_enabled) {
+    if (parsed_options.color_canvas_extensions_enabled) {
       dst_color_space = parsed_options.color_params.GetSkColorSpace();
       dst_color_type = parsed_options.color_params.GetSkColorType();
     }
     SkImageInfo image_info =
         SkImageInfo::Make(sk_image->width(), sk_image->height(), dst_color_type,
                           kPremul_SkAlphaType, dst_color_space);
     sk_sp<SkSurface> surface = SkSurface::MakeRaster(image_info);
     surface->getCanvas()->drawImage(sk_image, 0, 0);
     image_ = StaticBitmapImage::Create(surface->makeImageSnapshot());
   }
@@ skipping 297 matching lines @@
     } else {
       image_ = StaticBitmapImage::Create(sk_image);
     }
     if (!image_)
       return;
     image_->SetPremultiplied(parsed_options.premultiply_alpha);
     return;
   }
 
   CanvasColorParams canvas_color_params;
-  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
-      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+  if (RuntimeEnabledFeatures::colorCanvasExtensionsEnabled()) {
     ImageDataColorSettings color_settings;
     data->getColorSettings(color_settings);
     CanvasColorSpace canvas_color_space =
         ImageData::GetCanvasColorSpace(color_settings.colorSpace());
     CanvasPixelFormat canvas_pixel_format = kRGBA8CanvasPixelFormat;
     if (ImageData::GetImageDataStorageFormat(color_settings.storageFormat()) !=
         kUint8ClampedArrayStorageFormat) {
       canvas_pixel_format = kF16CanvasPixelFormat;
     }
     canvas_color_params =
@@ skipping 239 matching lines @@
 void ImageBitmap::AdjustDrawRects(FloatRect* src_rect,
                                   FloatRect* dst_rect) const {}
 
 FloatSize ImageBitmap::ElementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink