Add unit test for color managed ImageBitamp(ImageBitmap) constructor

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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/frame/ImageBitmap.h"
 
 #include "SkPixelRef.h"  // FIXME: qualify this skia header file.
 #include "core/dom/Document.h"
 #include "core/fetch/MemoryCache.h"
+#include "core/frame/FrameView.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/loader/resource/ImageResourceContent.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/heap/Handle.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/network/ResourceRequest.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
     m_image = surface->makeImageSnapshot();
 
     sk_sp<SkSurface> surface2 = SkSurface::MakeRasterN32Premul(5, 5);
     surface2->getCanvas()->clear(0xAAAAAAAA);
     m_image2 = surface2->makeImageSnapshot();
 
     // Save the global memory cache to restore it upon teardown.
     m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create());
 
     // Save the state of experimental canvas features and color correct
-    // rendering flags to restore them on teardown.
+    // rendering flags to restore them on teardown. Each test that changes the
+    // flags must restore them to prevent affecting other ImageBitmap tests.
+    // This is an extra safety precaution to prevent such an error to leak from
+    // this test suite.
     experimentalCanvasFeatures =
         RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
     colorCorrectRendering =
         RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
     colorCorrectRenderingDefaultMode =
         RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled();
   }
   virtual void TearDown() {
     // Garbage collection is required prior to switching out the
     // test's memory cache; image resources are released, evicting
@@ skipping 128 matching lines @@
 enum class ColorSpaceConversion : uint8_t {
   NONE = 0,
   DEFAULT_NOT_COLOR_CORRECTED = 1,
   DEFAULT_COLOR_CORRECTED = 2,
   SRGB = 3,
   LINEAR_RGB = 4,
 
   LAST = LINEAR_RGB
 };
 
-static ImageBitmap* createImageBitmapWithColorSpaceConversion(
-    HTMLImageElement* image,
-    Optional<IntRect>& cropRect,
-    Document* document,
+struct ColorRenderingRuntimeFlagsStatus {
+  bool experimentalCanvasFeatures = false;
+  bool colorCorrectRendering = false;
+  bool colorCorrectRenderingDefaultMode = false;
+};
+
+static void ReadRuntimeFlags(ColorRenderingRuntimeFlagsStatus& flagsStatus) {
+  flagsStatus.experimentalCanvasFeatures =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
+  flagsStatus.colorCorrectRendering =
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
+  flagsStatus.colorCorrectRenderingDefaultMode =
+      RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled();
+}
+
+static void ResetRuntimeFlags(
+    const ColorRenderingRuntimeFlagsStatus& flagsStatus) {
+  RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
+      flagsStatus.experimentalCanvasFeatures);
+  RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
+      flagsStatus.colorCorrectRendering);
+  RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
+      flagsStatus.colorCorrectRenderingDefaultMode);
+}
+
+static ImageBitmapOptions prepareBitmapOptionsAndSetRuntimeFlags(
     const ColorSpaceConversion& colorSpaceConversion) {
   // Set the color space conversion in ImageBitmapOptions
   ImageBitmapOptions options;
   static const Vector<String> conversions = {"none", "default", "default",
                                              "srgb", "linear-rgb"};
   options.setColorSpaceConversion(
       conversions[static_cast<uint8_t>(colorSpaceConversion)]);
 
   // Set the runtime flags
   bool flag = (colorSpaceConversion !=
                ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED);
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(true);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(flag);
   RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(!flag);
 
-  // Create and return the ImageBitmap
-  return ImageBitmap::create(image, cropRect, &(image->document()), options);
+  return options;
 }
 
-TEST_F(ImageBitmapTest, ImageBitmapColorSpaceConversion) {
+TEST_F(ImageBitmapTest, ImageBitmapColorSpaceConversionHTMLImageElement) {
+  ColorRenderingRuntimeFlagsStatus flagsStatus;
+  ReadRuntimeFlags(flagsStatus);

[dcheng, 2016/12/19 18:36:43]

Shouldn't the helpers in SetUp/TearDown already manage this?

[zakerinasab1, 2016/12/19 19:41:59]

As I know it is possible for multiple tests to end up in the same process. Now
that you asked this I'm wondering if it does mean that we have a separate setup
and tear down for each test or we might have setup and tear down run once for
multiple tests inside a test suite. If it is the former case, and they run once
per test, then this extra check is not needed here.

[dcheng, 2016/12/19 19:47:17]

SetUp() and TearDown() are called for each test:
https://github.com/google/googletest/blob/master/googletest/docs/Primer.md#te...

So we can just rely on that to save/restore the flags.

+
   HTMLImageElement* imageElement =
       HTMLImageElement::create(*Document::create());
 
   SkPaint p;
   p.setColor(SK_ColorRED);
   sk_sp<SkColorSpace> srcRGBColorSpace =
       SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
 
   SkImageInfo rasterImageInfo =
-      SkImageInfo::MakeN32Premul(100, 100, srcRGBColorSpace);
+      SkImageInfo::MakeN32Premul(10, 10, srcRGBColorSpace);
   sk_sp<SkSurface> surface(SkSurface::MakeRaster(rasterImageInfo));
-  surface->getCanvas()->drawCircle(50, 50, 50, p);
+  surface->getCanvas()->drawCircle(5, 5, 5, p);
   sk_sp<SkImage> image = surface->makeImageSnapshot();
 
   std::unique_ptr<uint8_t[]> srcPixel(
       new uint8_t[rasterImageInfo.bytesPerPixel()]());
   image->readPixels(rasterImageInfo.makeWH(1, 1), srcPixel.get(),
-                    image->width() * rasterImageInfo.bytesPerPixel(), 50, 50);
+                    image->width() * rasterImageInfo.bytesPerPixel(), 5, 5);
 
   ImageResourceContent* originalImageResource =
       ImageResourceContent::create(StaticBitmapImage::create(image).get());
   imageElement->setImageResource(originalImageResource);
 
   Optional<IntRect> cropRect = IntRect(0, 0, image->width(), image->height());
 
   // Create and test the ImageBitmap objects.
   // We don't check "none" color space conversion as it requires the encoded
   // data in a format readable by ImageDecoder. Furthermore, the code path for
   // "none" color space conversion is not affected by this CL.
 
   sk_sp<SkColorSpace> colorSpace = nullptr;
   SkColorType colorType = SkColorType::kN32_SkColorType;
   SkColorSpaceXform::ColorFormat colorFormat32 =
       (colorType == kBGRA_8888_SkColorType)
           ? SkColorSpaceXform::ColorFormat::kBGRA_8888_ColorFormat
           : SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
   SkColorSpaceXform::ColorFormat colorFormat = colorFormat32;
 
   for (uint8_t i = static_cast<uint8_t>(
            ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED);
        i <= static_cast<uint8_t>(ColorSpaceConversion::LAST); i++) {
     ColorSpaceConversion colorSpaceConversion =
         static_cast<ColorSpaceConversion>(i);
-    ImageBitmap* imageBitmap = createImageBitmapWithColorSpaceConversion(
-        imageElement, cropRect, &(imageElement->document()),
-        colorSpaceConversion);
+    ImageBitmapOptions options =
+        prepareBitmapOptionsAndSetRuntimeFlags(colorSpaceConversion);
+    ImageBitmap* imageBitmap = ImageBitmap::create(
+        imageElement, cropRect, &(imageElement->document()), options);
+
+    // ColorBehavior::ignore() is used instead of
+    // ColorBehavior::transformToTargetForTesting() to avoid color conversion to
+    // display color profile, as we want to solely rely on the color correction
+    // that happens in ImageBitmap create method.
     SkImage* convertedImage =
         imageBitmap->bitmapImage()
             ->imageForCurrentFrame(ColorBehavior::ignore())
+            .get();
+
+    switch (colorSpaceConversion) {
+      case ColorSpaceConversion::NONE:
+        NOTREACHED();
+        break;
+      case ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED:
+        // TODO(zakerinasab): Replace sRGB with a call to
+        // ImageDecoder::globalTargetColorSpace() when the crash problem on Mac
+        // is fixed. crbug.com/668546.
+        colorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
+        colorFormat = colorFormat32;
+        break;
+      case ColorSpaceConversion::DEFAULT_COLOR_CORRECTED:
+      case ColorSpaceConversion::SRGB:
+        colorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
+        colorFormat = colorFormat32;
+        break;
+      case ColorSpaceConversion::LINEAR_RGB:
+        colorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
+        colorType = SkColorType::kRGBA_F16_SkColorType;
+        colorFormat = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
+        break;
+      default:
+        NOTREACHED();
+    }
+
+    SkImageInfo imageInfo = SkImageInfo::Make(
+        1, 1, colorType, SkAlphaType::kPremul_SkAlphaType, colorSpace);
+    std::unique_ptr<uint8_t[]> convertedPixel(
+        new uint8_t[imageInfo.bytesPerPixel()]());
+    convertedImage->readPixels(
+        imageInfo, convertedPixel.get(),
+        convertedImage->width() * imageInfo.bytesPerPixel(), 5, 5);
+
+    // Transform the source pixel and check if the image bitmap color conversion
+    // is done correctly.
+    std::unique_ptr<SkColorSpaceXform> colorSpaceXform =
+        SkColorSpaceXform::New(srcRGBColorSpace.get(), colorSpace.get());
+    std::unique_ptr<uint8_t[]> transformedPixel(
+        new uint8_t[imageInfo.bytesPerPixel()]());
+    colorSpaceXform->apply(colorFormat, transformedPixel.get(), colorFormat32,
+                           srcPixel.get(), 1, SkAlphaType::kPremul_SkAlphaType);
+
+    int compare = std::memcmp(convertedPixel.get(), transformedPixel.get(),
+                              imageInfo.bytesPerPixel());
+    ASSERT_EQ(compare, 0);
+  }
+  ResetRuntimeFlags(flagsStatus);
+}
+
+TEST_F(ImageBitmapTest, ImageBitmapColorSpaceConversionImageBitmap) {
+  ColorRenderingRuntimeFlagsStatus flagsStatus;
+  ReadRuntimeFlags(flagsStatus);
+
+  HTMLImageElement* imageElement =
+      HTMLImageElement::create(*Document::create());
+
+  SkPaint p;
+  p.setColor(SK_ColorRED);
+  sk_sp<SkColorSpace> srcRGBColorSpace =
+      SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
+
+  SkImageInfo rasterImageInfo =
+      SkImageInfo::MakeN32Premul(10, 10, srcRGBColorSpace);
+  sk_sp<SkSurface> surface(SkSurface::MakeRaster(rasterImageInfo));
+  surface->getCanvas()->drawCircle(5, 5, 5, p);
+  sk_sp<SkImage> image = surface->makeImageSnapshot();
+
+  std::unique_ptr<uint8_t[]> srcPixel(
+      new uint8_t[rasterImageInfo.bytesPerPixel()]());
+  image->readPixels(rasterImageInfo.makeWH(1, 1), srcPixel.get(),
+                    image->width() * rasterImageInfo.bytesPerPixel(), 5, 5);
+
+  ImageResourceContent* sourceImageResource =
+      ImageResourceContent::create(StaticBitmapImage::create(image).get());
+  imageElement->setImageResource(sourceImageResource);
+
+  Optional<IntRect> cropRect = IntRect(0, 0, image->width(), image->height());
+  ImageBitmapOptions options =
+      prepareBitmapOptionsAndSetRuntimeFlags(ColorSpaceConversion::SRGB);
+  ImageBitmap* sourceImageBitmap = ImageBitmap::create(
+      imageElement, cropRect, &(imageElement->document()), options);
+
+  sk_sp<SkColorSpace> colorSpace = nullptr;
+  SkColorType colorType = SkColorType::kN32_SkColorType;
+  SkColorSpaceXform::ColorFormat colorFormat32 =
+      (colorType == kBGRA_8888_SkColorType)
+          ? SkColorSpaceXform::ColorFormat::kBGRA_8888_ColorFormat
+          : SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
+  SkColorSpaceXform::ColorFormat colorFormat = colorFormat32;
+
+  for (uint8_t i = static_cast<uint8_t>(
+           ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED);
+       i <= static_cast<uint8_t>(ColorSpaceConversion::LAST); i++) {
+    ColorSpaceConversion colorSpaceConversion =
+        static_cast<ColorSpaceConversion>(i);
+    options = prepareBitmapOptionsAndSetRuntimeFlags(colorSpaceConversion);
+    ImageBitmap* imageBitmap =
+        ImageBitmap::create(sourceImageBitmap, cropRect, options);
+    // ColorBehavior::ignore() is used instead of
+    // ColorBehavior::transformToTargetForTesting() to avoid color conversion to
+    // display color profile, as we want to solely rely on the color correction
+    // that happens in ImageBitmap create method.
+    SkImage* convertedImage =
+        imageBitmap->bitmapImage()
+            ->imageForCurrentFrame(ColorBehavior::ignore())
             .get();
 
     switch (colorSpaceConversion) {
       case ColorSpaceConversion::NONE:
         NOTREACHED();
         break;
       case ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED:
         // TODO(zakerinasab): Replace sRGB with a call to
         // ImageDecoder::globalTargetColorSpace() when the crash problem on Mac
         // is fixed. crbug.com/668546.
@@ skipping 13 matching lines @@
       default:
         NOTREACHED();
     }
 
     SkImageInfo imageInfo = SkImageInfo::Make(
         1, 1, colorType, SkAlphaType::kPremul_SkAlphaType, colorSpace);
     std::unique_ptr<uint8_t[]> convertedPixel(
         new uint8_t[imageInfo.bytesPerPixel()]());
     convertedImage->readPixels(
         imageInfo, convertedPixel.get(),
-        convertedImage->width() * imageInfo.bytesPerPixel(), 50, 50);
+        convertedImage->width() * imageInfo.bytesPerPixel(), 5, 5);
 
     // Transform the source pixel and check if the image bitmap color conversion
     // is done correctly.
     std::unique_ptr<SkColorSpaceXform> colorSpaceXform =
         SkColorSpaceXform::New(srcRGBColorSpace.get(), colorSpace.get());
     std::unique_ptr<uint8_t[]> transformedPixel(
         new uint8_t[imageInfo.bytesPerPixel()]());
     colorSpaceXform->apply(colorFormat, transformedPixel.get(), colorFormat32,
                            srcPixel.get(), 1, SkAlphaType::kPremul_SkAlphaType);
 
     int compare = std::memcmp(convertedPixel.get(), transformedPixel.get(),
                               imageInfo.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
+  ResetRuntimeFlags(flagsStatus);
 }
 
 }  // namespace blink