color: Convert BitmapImage to sRGB ahead of time

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

Index: third_party/WebKit/Source/core/frame/ImageBitmap.cpp
diff --git a/third_party/WebKit/Source/core/frame/ImageBitmap.cpp b/third_party/WebKit/Source/core/frame/ImageBitmap.cpp
index fac34953d2aa09bc9ed0cb8c96fe37fe4f8d33ec..16984c24f7742418f24966159a97d4406e3ee9e0 100644
--- a/third_party/WebKit/Source/core/frame/ImageBitmap.cpp
+++ b/third_party/WebKit/Source/core/frame/ImageBitmap.cpp
@@ -16,6 +16,7 @@
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorSpaceXformCanvas.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
@@ -45,6 +46,7 @@ struct ParsedOptions {
   SkFilterQuality resize_quality = kLow_SkFilterQuality;
   CanvasColorParams color_params;
   bool color_canvas_extensions_enabled = false;
+  bool convert_to_srgb = false;

[Justin Novosad, 2017/06/09 14:08:34]

This new member is confusing IMHO because it potentially conflicts with the
color space stored in color_params, and it may not be clear which of the two is
the ground truth.  I think the cleaner solution is to tweak the code that sets
the color space in color_params.  That might be the only code you need to touch
to fix this issue.

[ccameron, 2017/06/09 17:01:33]

I removed this and replaced it with "color_params.UsesOutputSpaceBlending &&
ColorCorrectRenderingEnabled".

 };
 
 ParsedOptions DefaultOptions() {
@@ -78,8 +80,16 @@ ParsedOptions ParseOptions(const ImageBitmapOptions& options,
   }
 
   if (options.colorSpaceConversion() != kImageBitmapOptionNone) {
-    parsed_options.color_canvas_extensions_enabled =
-        RuntimeEnabledFeatures::ColorCanvasExtensionsEnabled();
+    if (RuntimeEnabledFeatures::ColorCanvasExtensionsEnabled()) {
+      parsed_options.color_canvas_extensions_enabled = true;
+    } else {
+      // When canvas color extensions are not enabled, all images may be
+      // converted ahead of time to sRGB, since that is what their destination
+      // will always be sRGB.
+      parsed_options.convert_to_srgb =
+          RuntimeEnabledFeatures::ColorCorrectRenderingEnabled();
+    }
+
     if (!parsed_options.color_canvas_extensions_enabled) {
       DCHECK_EQ(options.colorSpaceConversion(), kImageBitmapOptionDefault);
     } else {
@@ -302,6 +312,10 @@ static sk_sp<SkImage> UnPremulSkImageToPremul(
 
 static void ApplyColorSpaceConversion(sk_sp<SkImage>& image,
                                       ParsedOptions& options) {
+  if (options.convert_to_srgb) {
+    image = image->makeColorSpace(SkColorSpace::MakeSRGB(),
+                                  SkTransferFunctionBehavior::kIgnore);
+  }
   if (!options.color_canvas_extensions_enabled)
     return;
 
@@ -480,6 +494,14 @@ static PassRefPtr<StaticBitmapImage> CropImageAndApplyColorSpaceConversion(
   if (src_rect.IsEmpty())
     return StaticBitmapImage::Create(surface->makeImageSnapshot());
 
+  SkCanvas* canvas = surface->getCanvas();
+  std::unique_ptr<SkCanvas> color_transform_canvas;
+  if (parsed_options.convert_to_srgb) {
+    color_transform_canvas =
+        SkCreateColorSpaceXformCanvas(canvas, SkColorSpace::MakeSRGB());
+    canvas = color_transform_canvas.get();
+  }
+
   SkScalar dst_left = std::min(0, -parsed_options.crop_rect.X());
   SkScalar dst_top = std::min(0, -parsed_options.crop_rect.Y());
   if (parsed_options.crop_rect.X() < 0)
@@ -487,8 +509,8 @@ static PassRefPtr<StaticBitmapImage> CropImageAndApplyColorSpaceConversion(
   if (parsed_options.crop_rect.Y() < 0)
     dst_top = -parsed_options.crop_rect.Y();
   if (parsed_options.flip_y) {
-    surface->getCanvas()->translate(0, surface->height());
-    surface->getCanvas()->scale(1, -1);
+    canvas->translate(0, surface->height());
+    canvas->scale(1, -1);
   }
   if (parsed_options.should_scale_input) {
     SkRect draw_src_rect = SkRect::MakeXYWH(
@@ -498,10 +520,9 @@ static PassRefPtr<StaticBitmapImage> CropImageAndApplyColorSpaceConversion(
                                             parsed_options.resize_height);
     SkPaint paint;
     paint.setFilterQuality(parsed_options.resize_quality);
-    surface->getCanvas()->drawImageRect(skia_image, draw_src_rect,
-                                        draw_dst_rect, &paint);
+    canvas->drawImageRect(skia_image, draw_src_rect, draw_dst_rect, &paint);
   } else {
-    surface->getCanvas()->drawImage(skia_image, dst_left, dst_top);
+    canvas->drawImage(skia_image, dst_left, dst_top);
   }
   skia_image = surface->makeImageSnapshot();
   ApplyColorSpaceConversion(skia_image, parsed_options);
@@ -552,7 +573,14 @@ ImageBitmap::ImageBitmap(ImageElementBase* image,
         SkImageInfo::Make(sk_image->width(), sk_image->height(), dst_color_type,
                           kPremul_SkAlphaType, dst_color_space);

[Justin Novosad, 2017/06/09 14:08:34]

We should just tweak the dst_color_space used here instead of setting up a
ColorSpaceXformCanvas below.

[ccameron, 2017/06/09 17:01:33]

Updated this to still use the xform canvas, but to also use
parsed_options.color_params.GetSkColorSpace, since there's no reason to
hard-code sRGB.

     sk_sp<SkSurface> surface = SkSurface::MakeRaster(image_info);
-    surface->getCanvas()->drawImage(sk_image, 0, 0);
+    SkCanvas* canvas = surface->getCanvas();
+    std::unique_ptr<SkCanvas> color_transform_canvas;
+    if (parsed_options.convert_to_srgb) {
+      color_transform_canvas =
+          SkCreateColorSpaceXformCanvas(canvas, SkColorSpace::MakeSRGB());
+      canvas = color_transform_canvas.get();
+    }
+    canvas->drawImage(sk_image, 0, 0);
     image_ = StaticBitmapImage::Create(surface->makeImageSnapshot());
   }
   if (!image_)
@@ -912,7 +940,14 @@ ImageBitmap::ImageBitmap(ImageData* data,
     paint.setFilterQuality(parsed_options.resize_quality);
     SkRect dst_draw_rect = SkRect::MakeWH(parsed_options.resize_width,
                                           parsed_options.resize_height);
-    surface->getCanvas()->drawImageRect(sk_image, dst_draw_rect, &paint);
+    SkCanvas* canvas = surface->getCanvas();
+    std::unique_ptr<SkCanvas> color_transform_canvas;
+    if (parsed_options.convert_to_srgb) {
+      color_transform_canvas =
+          SkCreateColorSpaceXformCanvas(canvas, SkColorSpace::MakeSRGB());
+      canvas = color_transform_canvas.get();
+    }
+    canvas->drawImageRect(sk_image, dst_draw_rect, &paint);
     sk_image = surface->makeImageSnapshot();
   }
   ApplyColorSpaceConversion(sk_image, parsed_options);