Revert of Prepare ImageData for color managed BaseRenderingContext2D::create/put/get-ImageData

third_party/WebKit/Source/core/html/ImageDataTest.cpp

 // Copyright 2017 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/html/ImageData.h"
 
 #include "core/dom/ExceptionCode.h"
 #include "platform/geometry/IntSize.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/skia/include/core/SkColorSpaceXform.h"
 
 namespace blink {
 namespace {
 
 class ImageDataTest : public ::testing::Test {
  protected:
-  virtual void SetUp() {
-    // Save the state of experimental canvas features and color correct
-    // rendering flags to restore them on teardown.
-    experimentalCanvasFeatures =
-        RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
-    colorCorrectRendering =
-        RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-    RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(true);
-    RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(true);
-  }
-
-  virtual void TearDown() {
-    RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
-        experimentalCanvasFeatures);
-    RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
-        colorCorrectRendering);
-  }
-
-  bool experimentalCanvasFeatures;
-  bool colorCorrectRendering;
+  ImageDataTest(){};
+  void TearDown(){};
 };
 
 TEST_F(ImageDataTest, NegativeAndZeroIntSizeTest) {
   ImageData* imageData;
 
   imageData = ImageData::create(IntSize(0, 10));
   EXPECT_EQ(imageData, nullptr);
 
   imageData = ImageData::create(IntSize(10, 0));
   EXPECT_EQ(imageData, nullptr);
@@ skipping 26 matching lines @@
 // allocated to the ImageData, then an exception must raise.
 TEST_F(ImageDataTest, MAYBE_CreateImageDataTooBig) {
   DummyExceptionStateForTesting exceptionState;
   ImageData* tooBigImageData = ImageData::create(32767, 32767, exceptionState);
   if (!tooBigImageData) {
     EXPECT_TRUE(exceptionState.hadException());
     EXPECT_EQ(exceptionState.code(), V8RangeError);
   }
 }
 
-// Skia conversion does not guarantee to be exact, se we need to do approximate
-// comparisons.
-static inline bool IsNearlyTheSame(float f, float g) {
-  static const float epsilonScale = 0.01f;
-  return std::abs(f - g) <
-         epsilonScale *
-             std::max(std::max(std::abs(f), std::abs(g)), epsilonScale);
-}
-
-// This test verifies the correct behavior of ImageData member function used
-// to convert pixels data from canvas pixel format to image data storage
-// format. This function is used in BaseRenderingContext2D::getImageData.
-TEST_F(ImageDataTest,
-       TestConvertPixelsFromCanvasPixelFormatToImageDataStorageFormat) {
-  // Source pixels in RGBA32
-  unsigned char rgba32Pixels[] = {255, 0,   0,   255,  // Red
-                                  0,   0,   0,   0,    // Transparent
-                                  255, 192, 128, 64,   // Decreasing values
-                                  93,  117, 205, 11};  // Random values
-  const unsigned numColorComponents = 16;
-  // Source pixels in F16
-  unsigned char f16Pixels[numColorComponents * 2];
-
-  // Filling F16 source pixels
-  std::unique_ptr<SkColorSpaceXform> xform =
-      SkColorSpaceXform::New(SkColorSpace::MakeSRGBLinear().get(),
-                             SkColorSpace::MakeSRGBLinear().get());
-  xform->apply(SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat, f16Pixels,
-               SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat,
-               rgba32Pixels, 4, SkAlphaType::kUnpremul_SkAlphaType);
-
-  // Creating ArrayBufferContents objects. We need two buffers for RGBA32 data
-  // because kRGBA8CanvasPixelFormat->kUint8ClampedArrayStorageFormat consumes
-  // the input data parameter.
-  WTF::ArrayBufferContents contentsRGBA32(
-      numColorComponents, 1, WTF::ArrayBufferContents::NotShared,
-      WTF::ArrayBufferContents::DontInitialize);
-  std::memcpy(contentsRGBA32.data(), rgba32Pixels, numColorComponents);
-
-  WTF::ArrayBufferContents contents2RGBA32(
-      numColorComponents, 1, WTF::ArrayBufferContents::NotShared,
-      WTF::ArrayBufferContents::DontInitialize);
-  std::memcpy(contents2RGBA32.data(), rgba32Pixels, numColorComponents);
-
-  WTF::ArrayBufferContents contentsF16(
-      numColorComponents * 2, 1, WTF::ArrayBufferContents::NotShared,
-      WTF::ArrayBufferContents::DontInitialize);
-  std::memcpy(contentsF16.data(), f16Pixels, numColorComponents * 2);
-
-  // Uint16 is not supported as the storage format for ImageData created from a
-  // canvas, so this conversion is neither implemented nor tested here.
-  bool testPassed = true;
-  DOMArrayBufferView* data = nullptr;
-  DOMUint8ClampedArray* dataU8 = nullptr;
-  DOMFloat32Array* dataF32 = nullptr;
-
-  // Testing kRGBA8CanvasPixelFormat -> kUint8ClampedArrayStorageFormat
-  data = ImageData::convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
-      contentsRGBA32, kRGBA8CanvasPixelFormat, kUint8ClampedArrayStorageFormat);
-  DCHECK(data->type() == DOMArrayBufferView::ViewType::TypeUint8Clamped);
-  dataU8 = const_cast<DOMUint8ClampedArray*>(
-      static_cast<const DOMUint8ClampedArray*>(data));
-  DCHECK(dataU8);
-  for (unsigned i = 0; i < numColorComponents; i++) {
-    if (dataU8->item(i) != rgba32Pixels[i]) {
-      testPassed = false;
-      break;
-    }
-  }
-  EXPECT_TRUE(testPassed);
-
-  // Testing kRGBA8CanvasPixelFormat -> kFloat32ArrayStorageFormat
-  data = ImageData::convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
-      contents2RGBA32, kRGBA8CanvasPixelFormat, kFloat32ArrayStorageFormat);
-  DCHECK(data->type() == DOMArrayBufferView::ViewType::TypeFloat32);
-  dataF32 =
-      const_cast<DOMFloat32Array*>(static_cast<const DOMFloat32Array*>(data));
-  DCHECK(dataF32);
-  for (unsigned i = 0; i < numColorComponents; i++) {
-    if (!IsNearlyTheSame(dataF32->item(i), rgba32Pixels[i] / 255.0)) {
-      testPassed = false;
-      break;
-    }
-  }
-  EXPECT_TRUE(testPassed);
-
-  // Testing kF16CanvasPixelFormat -> kUint8ClampedArrayStorageFormat
-  data = ImageData::convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
-      contentsF16, kF16CanvasPixelFormat, kUint8ClampedArrayStorageFormat);
-  DCHECK(data->type() == DOMArrayBufferView::ViewType::TypeUint8Clamped);
-  dataU8 = const_cast<DOMUint8ClampedArray*>(
-      static_cast<const DOMUint8ClampedArray*>(data));
-  DCHECK(dataU8);
-  for (unsigned i = 0; i < numColorComponents; i++) {
-    if (!IsNearlyTheSame(dataU8->item(i), rgba32Pixels[i])) {
-      testPassed = false;
-      break;
-    }
-  }
-  EXPECT_TRUE(testPassed);
-
-  // Testing kF16CanvasPixelFormat -> kFloat32ArrayStorageFormat
-  data = ImageData::convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
-      contentsF16, kF16CanvasPixelFormat, kFloat32ArrayStorageFormat);
-  DCHECK(data->type() == DOMArrayBufferView::ViewType::TypeFloat32);
-  dataF32 =
-      const_cast<DOMFloat32Array*>(static_cast<const DOMFloat32Array*>(data));
-  DCHECK(dataF32);
-  for (unsigned i = 0; i < numColorComponents; i++) {
-    if (!IsNearlyTheSame(dataF32->item(i), rgba32Pixels[i] / 255.0)) {
-      testPassed = false;
-      break;
-    }
-  }
-  EXPECT_TRUE(testPassed);
-}
-
-bool convertPixelsToColorSpaceAndPixelFormatForTest(
-    DOMArrayBufferView* dataArray,
-    CanvasColorSpace srcColorSpace,
-    CanvasColorSpace dstColorSpace,
-    CanvasPixelFormat dstPixelFormat,
-    std::unique_ptr<uint8_t[]>& convertedPixels) {
-  // Setting SkColorSpaceXform::apply parameters
-  SkColorSpaceXform::ColorFormat srcColorFormat =
-      SkColorSpaceXform::kRGBA_8888_ColorFormat;
-
-  unsigned dataLength = dataArray->byteLength() / dataArray->typeSize();
-  unsigned numPixels = dataLength / 4;
-  DOMUint8ClampedArray* u8Array = nullptr;
-  DOMUint16Array* u16Array = nullptr;
-  DOMFloat32Array* f32Array = nullptr;
-  void* srcData = nullptr;
-
-  switch (dataArray->type()) {
-    case ArrayBufferView::ViewType::TypeUint8Clamped:
-      u8Array = const_cast<DOMUint8ClampedArray*>(
-          static_cast<const DOMUint8ClampedArray*>(dataArray));
-      srcData = static_cast<void*>(u8Array->data());
-      break;
-
-    case ArrayBufferView::ViewType::TypeUint16:
-      u16Array = const_cast<DOMUint16Array*>(
-          static_cast<const DOMUint16Array*>(dataArray));
-      srcColorFormat = SkColorSpaceXform::ColorFormat::kRGBA_U16_BE_ColorFormat;
-      srcData = static_cast<void*>(u16Array->data());
-      break;
-
-    case ArrayBufferView::ViewType::TypeFloat32:
-      f32Array = const_cast<DOMFloat32Array*>(
-          static_cast<const DOMFloat32Array*>(dataArray));
-      srcColorFormat = SkColorSpaceXform::kRGBA_F32_ColorFormat;
-      srcData = static_cast<void*>(f32Array->data());
-      break;
-    default:
-      NOTREACHED();
-      return false;
-  }
-
-  SkColorSpaceXform::ColorFormat dstColorFormat =
-      SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
-  if (dstPixelFormat == kF16CanvasPixelFormat)
-    dstColorFormat = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
-
-  sk_sp<SkColorSpace> srcSkColorSpace = nullptr;
-  if (u8Array) {
-    srcSkColorSpace = ImageData::getSkColorSpaceForTest(
-        srcColorSpace, kRGBA8CanvasPixelFormat);
-  } else {
-    srcSkColorSpace =
-        ImageData::getSkColorSpaceForTest(srcColorSpace, kF16CanvasPixelFormat);
-  }
-
-  sk_sp<SkColorSpace> dstSkColorSpace =
-      ImageData::getSkColorSpaceForTest(dstColorSpace, dstPixelFormat);
-
-  // When the input dataArray is in Uint16, we normally should convert the
-  // values from Little Endian to Big Endian before passing the buffer to
-  // SkColorSpaceXform::apply. However, in this test scenario we are creating
-  // the Uin16 dataArray by multiplying a Uint8Clamped array members by 257,
-  // hence the Big Endian and Little Endian representations are the same.
-
-  std::unique_ptr<SkColorSpaceXform> xform =
-      SkColorSpaceXform::New(srcSkColorSpace.get(), dstSkColorSpace.get());
-
-  if (!xform->apply(dstColorFormat, convertedPixels.get(), srcColorFormat,
-                    srcData, numPixels, kUnpremul_SkAlphaType))
-    return false;
-  return true;
-}
-
-// This test verifies the correct behavior of ImageData member function used
-// to convert image data from image data storage format to canvas pixel format.
-// This function is used in BaseRenderingContext2D::putImageData.
-TEST_F(ImageDataTest, TestGetImageDataInCanvasColorSettings) {
-  unsigned numImageDataColorSpaces = 3;
-  CanvasColorSpace imageDataColorSpaces[] = {
-      kSRGBCanvasColorSpace, kRec2020CanvasColorSpace, kP3CanvasColorSpace,
-  };
-
-  unsigned numImageDataStorageFormats = 3;
-  ImageDataStorageFormat imageDataStorageFormats[] = {
-      kUint8ClampedArrayStorageFormat, kUint16ArrayStorageFormat,
-      kFloat32ArrayStorageFormat,
-  };
-
-  unsigned numCanvasColorSettings = 4;
-  CanvasColorSpace canvasColorSpaces[] = {
-      kSRGBCanvasColorSpace, kSRGBCanvasColorSpace, kRec2020CanvasColorSpace,
-      kP3CanvasColorSpace,
-  };
-  CanvasPixelFormat canvasPixelFormats[] = {
-      kRGBA8CanvasPixelFormat, kF16CanvasPixelFormat, kF16CanvasPixelFormat,
-      kF16CanvasPixelFormat,
-  };
-
-  // As cross checking the output of Skia color space covnersion API is not in
-  // the scope of this unit test, we do turn-around tests here. To do so, we
-  // create an ImageData with the selected color space and storage format,
-  // convert it to the target canvas color space and pixel format by calling
-  // ImageData::imageDataInCanvasColorSettings(), and then convert it back
-  // to the source image data color space and Float32 storage format by calling
-  // ImageData::convertPixelsFromCanvasPixelFormatToImageDataStorageFormat().
-  // We expect to get the same image data as we started with.
-
-  // Source pixels in RGBA32
-  uint8_t u8Pixels[] = {255, 0,   0,   255,  // Red
-                        0,   0,   0,   0,    // Transparent
-                        255, 192, 128, 64,   // Decreasing values
-                        93,  117, 205, 11};  // Random values
-  unsigned dataLength = 16;
-
-  uint16_t* u16Pixels = new uint16_t[dataLength];
-  for (unsigned i = 0; i < dataLength; i++)
-    u16Pixels[i] = u8Pixels[i] * 257;
-
-  float* f32Pixels = new float[dataLength];
-  for (unsigned i = 0; i < dataLength; i++)
-    f32Pixels[i] = u8Pixels[i] / 255.0;
-
-  DOMArrayBufferView* dataArray = nullptr;
-
-  DOMUint8ClampedArray* dataU8 =
-      DOMUint8ClampedArray::create(u8Pixels, dataLength);
-  DCHECK(dataU8);
-  EXPECT_EQ(dataLength, dataU8->length());
-  DOMUint16Array* dataU16 = DOMUint16Array::create(u16Pixels, dataLength);
-  DCHECK(dataU16);
-  EXPECT_EQ(dataLength, dataU16->length());
-  DOMFloat32Array* dataF32 = DOMFloat32Array::create(f32Pixels, dataLength);
-  DCHECK(dataF32);
-  EXPECT_EQ(dataLength, dataF32->length());
-
-  ImageData* imageData = nullptr;
-  ImageDataColorSettings colorSettings;
-
-  // At most two bytes are needed for output per color component.
-  std::unique_ptr<uint8_t[]> pixelsConvertedManually(
-      new uint8_t[dataLength * 2]());
-  std::unique_ptr<uint8_t[]> pixelsConvertedInImageData(
-      new uint8_t[dataLength * 2]());
-
-  // Loop through different possible combinations of image data color space and
-  // storage formats and create the respective test image data objects.
-  for (unsigned i = 0; i < numImageDataColorSpaces; i++) {
-    colorSettings.setColorSpace(
-        ImageData::canvasColorSpaceName(imageDataColorSpaces[i]));
-
-    for (unsigned j = 0; j < numImageDataStorageFormats; j++) {
-      switch (imageDataStorageFormats[j]) {
-        case kUint8ClampedArrayStorageFormat:
-          dataArray = static_cast<DOMArrayBufferView*>(dataU8);
-          colorSettings.setStorageFormat(kUint8ClampedArrayStorageFormatName);
-          break;
-        case kUint16ArrayStorageFormat:
-          dataArray = static_cast<DOMArrayBufferView*>(dataU16);
-          colorSettings.setStorageFormat(kUint16ArrayStorageFormatName);
-          break;
-        case kFloat32ArrayStorageFormat:
-          dataArray = static_cast<DOMArrayBufferView*>(dataF32);
-          colorSettings.setStorageFormat(kFloat32ArrayStorageFormatName);
-          break;
-        default:
-          NOTREACHED();
-      }
-
-      imageData =
-          ImageData::createForTest(IntSize(2, 2), dataArray, &colorSettings);
-
-      for (unsigned k = 0; k < numCanvasColorSettings; k++) {
-        unsigned outputLength =
-            (canvasPixelFormats[k] == kRGBA8CanvasPixelFormat) ? dataLength
-                                                               : dataLength * 2;
-        // Convert the original data used to create ImageData to the
-        // canvas color space and canvas pixel format.
-        EXPECT_TRUE(convertPixelsToColorSpaceAndPixelFormatForTest(
-            dataArray, imageDataColorSpaces[i], canvasColorSpaces[k],
-            canvasPixelFormats[k], pixelsConvertedManually));
-
-        // Convert the image data to the color settings of the canvas.
-        EXPECT_TRUE(imageData->imageDataInCanvasColorSettings(
-            canvasColorSpaces[k], canvasPixelFormats[k],
-            pixelsConvertedInImageData));
-
-        // Compare the converted pixels
-        EXPECT_EQ(0, memcmp(pixelsConvertedManually.get(),
-                            pixelsConvertedInImageData.get(), outputLength));
-      }
-    }
-  }
-  delete[] u16Pixels;
-  delete[] f32Pixels;
-}
-
 }  // namspace
 }  // namespace blink