Fix BaseRenderingContext2D create/put/get-ImageData() for color managed canvas

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp

 // Copyright 2016 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 "modules/canvas2d/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/css/cssom/CSSURLImageValue.h"
@@ skipping 1478 matching lines @@
   static_cast<SkRect>(canvasRect).roundOut(&canvasIRect);
   if (!canvasIRect.intersect(transformedClipBounds))
     return false;
 
   if (dirtyRect)
     *dirtyRect = canvasIRect;
 
   return true;
 }
 
+bool BaseRenderingContext2D::colorSettingsAsImageDataColorSettings(
+    ImageDataColorSettings& colorSettings) const {
+  if (!RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() ||
+      !RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
+    return false;
+  colorSettings.setColorSpace(renderingContext()->colorSpaceAsString());
+  switch (renderingContext()->pixelFormat()) {
+    case kRGBA8CanvasPixelFormat:
+      colorSettings.setStorageFormat(kUint8ClampedArrayStorageFormatName);
+      break;
+    case kF16CanvasPixelFormat:
+      colorSettings.setStorageFormat(kFloat32ArrayStorageFormatName);
+      break;
+    case kRGB10A2CanvasPixelFormat:
+    case kRGBA12CanvasPixelFormat:
+    default:
+      NOTREACHED();
+      return false;
+  }
+  return true;
+}
+
 ImageData* BaseRenderingContext2D::createImageData(
     ImageData* imageData,
     ExceptionState& exceptionState) const {
-  ImageData* result = ImageData::create(imageData->size());
+  ImageData* result = nullptr;
+  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    ImageDataColorSettings colorSettings;
+    if (colorSettingsAsImageDataColorSettings(colorSettings))
+      result = ImageData::create(imageData->size(), &colorSettings);
+  } else {
+    result = ImageData::create(imageData->size());
+  }
   if (!result)
     exceptionState.throwRangeError("Out of memory at ImageData creation");
   return result;
 }
 
 ImageData* BaseRenderingContext2D::createImageData(
     int sw,
     int sh,
     ExceptionState& exceptionState) const {
   if (!sw || !sh) {
     exceptionState.throwDOMException(
         IndexSizeError,
         String::format("The source %s is 0.", sw ? "height" : "width"));
     return nullptr;
   }
 
   IntSize size(abs(sw), abs(sh));
-
-  ImageData* result = ImageData::create(size);
+  ImageData* result = nullptr;
+  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    ImageDataColorSettings colorSettings;
+    if (colorSettingsAsImageDataColorSettings(colorSettings))
+      result = ImageData::create(size, &colorSettings);
+  } else {
+    result = ImageData::create(size);
+  }
   if (!result)
     exceptionState.throwRangeError("Out of memory at ImageData creation");
   return result;
 }
 
 ImageData* BaseRenderingContext2D::getImageData(
     int sx,
     int sy,
     int sw,
     int sh,
@@ skipping 34 matching lines @@
                                  10000000, 50));
     timer.emplace(scopedUsCounterDisplayList);
   } else {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scopedUsCounterCPU,
         new CustomCountHistogram("Blink.Canvas.GetImageData.CPU", 0, 10000000,
                                  50));
     timer.emplace(scopedUsCounterCPU);
   }
 
+  ImageDataColorSettings colorSettings;
+  bool canvasIsColorManaged =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
+  if (canvasIsColorManaged)
+    canvasIsColorManaged = colorSettingsAsImageDataColorSettings(colorSettings);
   IntRect imageDataRect(sx, sy, sw, sh);
   DVLOG(1) << sx << ", " << sy << ", " << sw << ", " << sh;
   ImageBuffer* buffer = imageBuffer();
   if (!buffer || isContextLost()) {
-    ImageData* result = ImageData::create(imageDataRect.size());
+    ImageData* result = nullptr;
+    if (canvasIsColorManaged)
+      result = ImageData::create(imageDataRect.size(), &colorSettings);
+    else
+      result = ImageData::create(imageDataRect.size());
     if (!result)
       exceptionState.throwRangeError("Out of memory at ImageData creation");
     return result;
   }
 
   WTF::ArrayBufferContents contents;
   if (!buffer->getImageData(Unmultiplied, imageDataRect, contents)) {
     exceptionState.throwRangeError("Out of memory at ImageData creation");
     return nullptr;
   }
 
-  DOMArrayBuffer* arrayBuffer = DOMArrayBuffer::create(contents);
+  DOMArrayBuffer* arrayBuffer = nullptr;
+  DOMArrayBufferView* arrayBufferView = nullptr;
+  DOMFloat32Array* dataArray = nullptr;
+
+  if (canvasIsColorManaged) {
+    ImageDataStorageFormat storageFormat =
+        ImageData::imageDataStorageFormat(colorSettings.storageFormat());
+    switch (storageFormat) {
+      case kUint8ClampedArrayStorageFormat:
+        arrayBuffer = DOMArrayBuffer::create(contents);
+        return ImageData::create(
+            imageDataRect.size(),
+            DOMUint8ClampedArray::create(arrayBuffer, 0,
+                                         arrayBuffer->byteLength()));
+        break;
+      case kUint16ArrayStorageFormat:
+        NOTREACHED();
+        break;
+      case kFloat32ArrayStorageFormat:
+        arrayBufferView = ImageData::
+            convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
+                contents, renderingContext()->pixelFormat(), storageFormat);
+        dataArray = const_cast<DOMFloat32Array*>(
+            static_cast<const DOMFloat32Array*>(arrayBufferView));
+        return ImageData::create(imageDataRect.size(), arrayBufferView,
+                                 &colorSettings);
+      default:
+        NOTREACHED();
+    }
+    return nullptr;
+  }
+
+  arrayBuffer = DOMArrayBuffer::create(contents);
   return ImageData::create(
       imageDataRect.size(),
       DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength()));
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
                                           int dx,
                                           int dy,
                                           ExceptionState& exceptionState) {
   putImageData(data, dx, dy, 0, 0, data->width(), data->height(),
                exceptionState);
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
                                           int dx,
                                           int dy,
                                           int dirtyX,
                                           int dirtyY,
                                           int dirtyWidth,
                                           int dirtyHeight,
                                           ExceptionState& exceptionState) {
   m_usageCounters.numPutImageDataCalls++;
   m_usageCounters.areaPutImageDataCalls += dirtyWidth * dirtyHeight;
-  if (data->data()->bufferBase()->isNeutered()) {
+
+  bool canvasIsColorManaged =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();

[Justin Novosad, 2017/04/06 19:01:04]

This check is copied in many placed, perhaps we could just check once in the
constructor and store the result in a bool. m_isColorManaged

[zakerinasab, 2017/04/11 19:52:59]

Done.

+
+  bool dataIsNeutered = false;
+  if (canvasIsColorManaged) {
+    dataIsNeutered =
+        (data->dataUnion().isUint8ClampedArray() &&
+         data->dataUnion()
+             .getAsUint8ClampedArray()
+             ->bufferBase()
+             ->isNeutered()) ||
+        (data->dataUnion().isUint16Array() &&
+         data->dataUnion().getAsUint16Array()->bufferBase()->isNeutered()) ||
+        (data->dataUnion().isFloat32Array() &&
+         data->dataUnion().getAsFloat32Array()->bufferBase()->isNeutered());
+  } else {
+    dataIsNeutered = data->data()->bufferBase()->isNeutered();
+  }
+  if (dataIsNeutered) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "The source data has been neutered.");
     return;
   }
+
   ImageBuffer* buffer = imageBuffer();
   if (!buffer)
     return;
 
   if (dirtyWidth < 0) {
     dirtyX += dirtyWidth;
     dirtyWidth = -dirtyWidth;
   }
 
   if (dirtyHeight < 0) {
@@ skipping 29 matching lines @@
                                  50));
     timer.emplace(scopedUsCounterCPU);
   }
 
   IntRect sourceRect(destRect);
   sourceRect.move(-destOffset);
 
   checkOverdraw(destRect, 0, CanvasRenderingContext2DState::NoImage,
                 UntransformedUnclippedFill);
 
-  buffer->putByteArray(Unmultiplied, data->data()->data(),
-                       IntSize(data->width(), data->height()), sourceRect,
-                       IntPoint(destOffset));
-
+  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    unsigned dataLength = data->width() * data->height();
+    if (renderingContext()->pixelFormat() == kF16CanvasPixelFormat)
+      dataLength *= 2;
+    std::unique_ptr<uint8_t[]> convertedPixels(new uint8_t[4 * dataLength]);
+    data->imageDataInCanvasColorSettings(renderingContext()->colorSpace(),
+                                         renderingContext()->pixelFormat(),
+                                         convertedPixels);
+    buffer->putByteArray(Unmultiplied, convertedPixels.get(),
+                         IntSize(data->width(), data->height()), sourceRect,
+                         IntPoint(destOffset));
+  } else {
+    buffer->putByteArray(Unmultiplied, data->data()->data(),
+                         IntSize(data->width(), data->height()), sourceRect,
+                         IntPoint(destOffset));
+  }
   didDraw(destRect);
 }
 
 void BaseRenderingContext2D::inflateStrokeRect(FloatRect& rect) const {
   // Fast approximation of the stroke's bounding rect.
   // This yields a slightly oversized rect but is very fast
   // compared to Path::strokeBoundingRect().
   static const double root2 = sqrtf(2);
   double delta = state().lineWidth() / 2;
   if (state().getLineJoin() == MiterJoin)
@@ skipping 330 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink