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

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 1508 matching lines @@
   FloatSize logicalSize(fabs(sw), fabs(sh));
   if (!logicalSize.isExpressibleAsIntSize())
     return nullptr;
 
   IntSize size = expandedIntSize(logicalSize);
   if (size.width() < 1)
     size.setWidth(1);
   if (size.height() < 1)
     size.setHeight(1);
 
-  ImageData* result = ImageData::create(size);
+  ImageData* result = nullptr;
+  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    ImageDataColorSettings colorSettings;
+    colorSettings.setColorSpace(renderingContext()->colorSpaceAsString());

[Justin Novosad, 2017/03/27 19:43:48]

Hmmm... so createImageData inherits the setting from the canvas context.  That
is an interesting Idea. Please add that to the feature proposal document.

[zakerinasab, 2017/03/30 17:56:11]

I'll do.

+    switch (renderingContext()->pixelFormat()) {
+      case kRGBA8CanvasPixelFormat:
+        colorSettings.setStorageFormat(kUint8ClampedArrayStorageFormatName);
+        break;
+      case kF16CanvasPixelFormat:
+        colorSettings.setStorageFormat(kFloat32ArrayStorageFormatName);
+        break;
+      case kRGB10A2CanvasPixelFormat:
+      case kRGBA12CanvasPixelFormat:
+      default:
+        NOTREACHED();
+    }
+    LOG(ERROR) << "In createImageData: " << colorSettings.colorSpace() << ", "
+               << colorSettings.storageFormat();
+    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(
     double sx,
     double sy,
     double sw,
     double sh,
     ExceptionState& exceptionState) const {
+  LOG(ERROR) << renderingContext()->colorSpaceAsString();
+  LOG(ERROR) << renderingContext()->pixelFormatAsString();

[Justin Novosad, 2017/03/27 19:43:48]

I See a lot of error logging in this file that looks like debug traces.  Please
clean it up. 

[zakerinasab, 2017/03/30 17:56:11]

This was a work in progress. Removed now.

   m_usageCounters.numGetImageDataCalls++;
   m_usageCounters.areaGetImageDataCalls += sw * sh;
   if (!originClean())
     exceptionState.throwSecurityError(
         "The canvas has been tainted by cross-origin data.");
   else if (!sw || !sh)
     exceptionState.throwDOMException(
         IndexSizeError,
         String::format("The source %s is 0.", sw ? "height" : "width"));
 
@@ skipping 31 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;
+  LOG(ERROR) << "Default: " << colorSettings.colorSpace() << ", "
+             << colorSettings.storageFormat();
+  bool canvasIsColorManaged =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
+  if (canvasIsColorManaged) {
+    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();
+    }
+    LOG(ERROR) << "Set: " << colorSettings.colorSpace() << ", "
+               << colorSettings.storageFormat();
+  }
+
   IntRect imageDataRect = enclosingIntRect(logicalRect);
   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;
+
+  LOG(ERROR) << "HERE";
+  if (canvasIsColorManaged) {
+    LOG(ERROR) << "Canvas is color managed";
+    ImageDataStorageFormat storageFormat =
+        ImageData::getImageDataStorageFormat(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:
+        LOG(ERROR) << "kFloat32ArrayStorageFormat";
+        arrayBufferView = ImageData::
+            convertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
+                contents, renderingContext()->pixelFormat(), storageFormat);
+        LOG(ERROR) << (void*)(arrayBufferView);
+        LOG(ERROR) << arrayBufferView->byteLength();
+        LOG(ERROR) << arrayBufferView->typeSize();
+        dataArray = const_cast<DOMFloat32Array*>(
+            static_cast<const DOMFloat32Array*>(arrayBufferView));
+        return ImageData::create(imageDataRect.size(), arrayBufferView,
+                                 &colorSettings);
+      default:
+        NOTREACHED();
+    }
+    return nullptr;
+  }
+  LOG(ERROR) << "NOT color managed canvas";
+
+  arrayBuffer = DOMArrayBuffer::create(contents);
   return ImageData::create(
       imageDataRect.size(),
       DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength()));
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
                                           double dx,
                                           double dy,
                                           ExceptionState& exceptionState) {
   putImageData(data, dx, dy, 0, 0, data->width(), data->height(),
@@ skipping 58 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));
-
+  unsigned char* source = data->data()->data();
+  if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    source = data->getImageDataInCanvasColorSettings(
+        renderingContext()->colorSpace(), renderingContext()->pixelFormat());
+  } else {
+    buffer->putByteArray(Unmultiplied, source,
+                         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 325 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink