Refactor ImageBitmap constructor from ImageData to be color managed

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

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 558 matching lines @@
                              color_format32, src_pixel.get(), 1,
                              SkAlphaType::kPremul_SkAlphaType);
 
     int compare = std::memcmp(converted_pixel.get(), transformed_pixel.get(),
                               image_info.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
 }
 
 TEST_F(ImageBitmapTest, ImageBitmapColorSpaceConversionImageData) {
-  unsigned char data_buffer[4] = {255, 0, 0, 255};
+  sk_sp<SkColorSpace> src_rgb_color_space = SkColorSpace::MakeSRGB();
+  unsigned char data_buffer[4] = {32, 96, 160, 255};
   DOMUint8ClampedArray* data = DOMUint8ClampedArray::Create(data_buffer, 4);
-  ImageData* image_data =
-      ImageData::Create(IntSize(1, 1), NotShared<DOMUint8ClampedArray>(data));
+  ImageDataColorSettings color_settings;
+  ImageData* image_data = ImageData::Create(
+      IntSize(1, 1), NotShared<DOMUint8ClampedArray>(data), &color_settings);
   std::unique_ptr<uint8_t[]> src_pixel(new uint8_t[4]());
   memcpy(src_pixel.get(), image_data->data()->Data(), 4);
 
   Optional<IntRect> crop_rect = IntRect(0, 0, 1, 1);
   sk_sp<SkColorSpace> color_space = nullptr;
-  SkColorSpaceXform::ColorFormat color_format32 =
-      (SkColorType::kN32_SkColorType == kBGRA_8888_SkColorType)
-          ? SkColorSpaceXform::ColorFormat::kBGRA_8888_ColorFormat
-          : SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
   SkColorType color_type = SkColorType::kN32_SkColorType;
-  SkColorSpaceXform::ColorFormat color_format = color_format32;
+  SkColorSpaceXform::ColorFormat color_format =
+      SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
 
   for (uint8_t i =
            static_cast<uint8_t>(ColorSpaceConversion::DEFAULT_COLOR_CORRECTED);
-       i <= static_cast<uint8_t>(ColorSpaceConversion::LINEAR_RGB); i++) {
+       i <= static_cast<uint8_t>(ColorSpaceConversion::LAST); i++) {
     ColorSpaceConversion color_space_conversion =
         static_cast<ColorSpaceConversion>(i);
     ImageBitmapOptions options =
         PrepareBitmapOptionsAndSetRuntimeFlags(color_space_conversion);
     ImageBitmap* image_bitmap =
         ImageBitmap::Create(image_data, crop_rect, options);
 
     SkImage* converted_image =
         image_bitmap->BitmapImage()->ImageForCurrentFrame().get();
 
     switch (color_space_conversion) {
       case ColorSpaceConversion::NONE:
         NOTREACHED();
         break;
       case ColorSpaceConversion::DEFAULT_COLOR_CORRECTED:
       case ColorSpaceConversion::SRGB:
         color_space = SkColorSpace::MakeSRGB();
-        color_format = color_format32;
         break;
       case ColorSpaceConversion::LINEAR_RGB:
         color_space = SkColorSpace::MakeSRGBLinear();
         color_type = SkColorType::kRGBA_F16_SkColorType;
         color_format = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
         break;
+      case ColorSpaceConversion::P3:
+        color_space =
+            SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma,
+                                  SkColorSpace::kDCIP3_D65_Gamut);
+        color_type = SkColorType::kRGBA_F16_SkColorType;
+        color_format = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
+        break;
+      case ColorSpaceConversion::REC2020:
+        color_space =
+            SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma,
+                                  SkColorSpace::kRec2020_Gamut);
+        color_type = SkColorType::kRGBA_F16_SkColorType;
+        color_format = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
+        break;
       default:
         NOTREACHED();
     }
 
     SkImageInfo image_info = SkImageInfo::Make(
         1, 1, color_type, SkAlphaType::kUnpremul_SkAlphaType, color_space);
     std::unique_ptr<uint8_t[]> converted_pixel(
         new uint8_t[image_info.bytesPerPixel()]());
     converted_image->readPixels(
         image_info, converted_pixel.get(),
         converted_image->width() * image_info.bytesPerPixel(), 0, 0);
 
     // Transform the source pixel and check if the pixel from image bitmap has
     // the same color information.
     std::unique_ptr<SkColorSpaceXform> color_space_xform =
-        SkColorSpaceXform::New(image_data->GetSkColorSpace().get(),
-                               color_space.get());
+        SkColorSpaceXform::New(src_rgb_color_space.get(), color_space.get());
     std::unique_ptr<uint8_t[]> transformed_pixel(
         new uint8_t[image_info.bytesPerPixel()]());
-    color_space_xform->apply(color_format, transformed_pixel.get(),
-                             color_format32, src_pixel.get(), 1,
-                             SkAlphaType::kUnpremul_SkAlphaType);
+    color_space_xform->apply(
+        color_format, transformed_pixel.get(),
+        SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat, src_pixel.get(),
+        1, SkAlphaType::kUnpremul_SkAlphaType);
+
+    LOG(ERROR) << "ColorSpaceConversion: " << (int)(i);
+    std::stringstream str, str2;
+    for (int p = 0; p < image_info.bytesPerPixel(); p++) {
+      str << (int)(converted_pixel[p]) << ", ";
+      str2 << (int)(transformed_pixel[p]) << ", ";
+    }
+    LOG(ERROR) << "converted_pixel: " << str.str();
+    LOG(ERROR) << "transformed_pixel: " << str2.str();
+
     int compare = std::memcmp(converted_pixel.get(), transformed_pixel.get(),
                               image_info.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
 }
 
 }  // namespace blink