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 18 matching lines @@
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/graphics/paint/PaintFlags.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/wtf/CheckedNumeric.h"
 
 namespace blink {
 
 BaseRenderingContext2D::BaseRenderingContext2D()
-    : clip_antialiasing_(kNotAntiAliased) {
+    : clip_antialiasing_(kNotAntiAliased), color_management_enabled_(false) {
   state_stack_.push_back(CanvasRenderingContext2DState::Create());
+  color_management_enabled_ =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
 }
 
 BaseRenderingContext2D::~BaseRenderingContext2D() {}
 
 CanvasRenderingContext2DState& BaseRenderingContext2D::ModifiableState() {
   RealizeSaves();
   return *state_stack_.back();
 }
 
 void BaseRenderingContext2D::RealizeSaves() {
@@ skipping 1448 matching lines @@
   static_cast<SkRect>(canvas_rect).roundOut(&canvas_i_rect);
   if (!canvas_i_rect.intersect(transformed_clip_bounds))
     return false;
 
   if (dirty_rect)
     *dirty_rect = canvas_i_rect;
 
   return true;
 }
 
+ImageDataColorSettings
+BaseRenderingContext2D::GetColorSettingsAsImageDataColorSettings() const {
+  ImageDataColorSettings color_settings;
+  color_settings.setColorSpace(ColorSpaceAsString());
+  if (PixelFormat() == kF16CanvasPixelFormat)
+    color_settings.setStorageFormat(kFloat32ArrayStorageFormatName);
+  return color_settings;
+}
+
 ImageData* BaseRenderingContext2D::createImageData(
     ImageData* image_data,
     ExceptionState& exception_state) const {
-  ImageData* result = ImageData::Create(image_data->size());
+  ImageData* result = nullptr;
+  if (color_management_enabled_) {
+    ImageDataColorSettings color_settings =
+        GetColorSettingsAsImageDataColorSettings();
+    result = ImageData::Create(image_data->size(), &color_settings);
+  } else {
+    result = ImageData::Create(image_data->size());
+  }
   if (!result)
     exception_state.ThrowRangeError("Out of memory at ImageData creation");
   return result;
 }
 
 ImageData* BaseRenderingContext2D::createImageData(
     int sw,
     int sh,
     ExceptionState& exception_state) const {
   if (!sw || !sh) {
     exception_state.ThrowDOMException(
         kIndexSizeError,
         String::Format("The source %s is 0.", sw ? "height" : "width"));
     return nullptr;
   }
 
   IntSize size(abs(sw), abs(sh));
+  ImageData* result = nullptr;
+  if (color_management_enabled_) {
+    ImageDataColorSettings color_settings =
+        GetColorSettingsAsImageDataColorSettings();
+    result = ImageData::Create(size, &color_settings);
+  } else {
+    result = ImageData::Create(size);
+  }
 
-  ImageData* result = ImageData::Create(size);
   if (!result)
     exception_state.ThrowRangeError("Out of memory at ImageData creation");
   return result;
 }
 
+ImageData* BaseRenderingContext2D::createImageData(
+    unsigned width,
+    unsigned height,
+    ImageDataColorSettings& color_settings,
+    ExceptionState& exception_state) const {
+  return ImageData::createImageData(width, height, color_settings,
+                                    exception_state);
+}
+
+ImageData* BaseRenderingContext2D::createImageData(
+    ImageDataArray& data_array,
+    unsigned width,
+    unsigned height,
+    ImageDataColorSettings& color_settings,
+    ExceptionState& exception_state) const {
+  return ImageData::createImageData(data_array, width, height, color_settings,
+                                    exception_state);
+}
+
 ImageData* BaseRenderingContext2D::getImageData(
     int sx,
     int sy,
     int sw,
     int sh,
     ExceptionState& exception_state) {
   if (!WTF::CheckMul(sw, sh).IsValid<int>()) {
     exception_state.ThrowRangeError("Out of memory at ImageData creation");
     return nullptr;
   }
@@ skipping 42 matching lines @@
   } else {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scoped_us_counter_cpu,
         new CustomCountHistogram("Blink.Canvas.GetImageData.CPU", 0, 10000000,
                                  50));
     timer.emplace(scoped_us_counter_cpu);
   }
 
   IntRect image_data_rect(sx, sy, sw, sh);
   ImageBuffer* buffer = GetImageBuffer();
+  ImageDataColorSettings color_settings =
+      GetColorSettingsAsImageDataColorSettings();
   if (!buffer || isContextLost()) {
-    ImageData* result = ImageData::Create(image_data_rect.size());
+    ImageData* result = nullptr;
+    if (color_management_enabled_)
+      result = ImageData::Create(image_data_rect.size(), &color_settings);
+    else
+      result = ImageData::Create(image_data_rect.size());
     if (!result)
       exception_state.ThrowRangeError("Out of memory at ImageData creation");
     return result;
   }
 
   WTF::ArrayBufferContents contents;
   if (!buffer->GetImageData(kUnmultiplied, image_data_rect, contents)) {
     exception_state.ThrowRangeError("Out of memory at ImageData creation");
     return nullptr;
   }
 
   NeedsFinalizeFrame();
 
-  DOMArrayBuffer* array_buffer = DOMArrayBuffer::Create(contents);
-  return ImageData::Create(image_data_rect.size(),
-                           DOMUint8ClampedArray::Create(
-                               array_buffer, 0, array_buffer->ByteLength()));
+  if (!color_management_enabled_ ||
+      ImageData::GetImageDataStorageFormat(color_settings.storageFormat()) ==
+          kUint8ClampedArrayStorageFormat) {
+    DOMArrayBuffer* array_buffer = DOMArrayBuffer::Create(contents);
+    return ImageData::Create(image_data_rect.size(),
+                             DOMUint8ClampedArray::Create(
+                                 array_buffer, 0, array_buffer->ByteLength()));
+  }
+
+  DOMArrayBufferView* array_buffer_view =
+      ImageData::ConvertPixelsFromCanvasPixelFormatToImageDataStorageFormat(
+          contents, PixelFormat(), kFloat32ArrayStorageFormat);
+  return ImageData::Create(image_data_rect.size(), array_buffer_view,
+                           &color_settings);
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
                                           int dx,
                                           int dy,
                                           ExceptionState& exception_state) {
   putImageData(data, dx, dy, 0, 0, data->width(), data->height(),
                exception_state);
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
                                           int dx,
                                           int dy,
                                           int dirty_x,
                                           int dirty_y,
                                           int dirty_width,
                                           int dirty_height,
                                           ExceptionState& exception_state) {
   if (!WTF::CheckMul(dirty_width, dirty_height).IsValid<int>()) {
     return;
   }
-
   usage_counters_.num_put_image_data_calls++;
   usage_counters_.area_put_image_data_calls += dirty_width * dirty_height;
-  if (data->data()->BufferBase()->IsNeutered()) {
+
+  bool data_is_neutered = false;
+  if (color_management_enabled_) {
+    data_is_neutered =
+        (data->dataUnion().isUint8ClampedArray() &&

[Justin Novosad, 2017/04/11 21:28:05]

This block of code is not fun to read. Let's hide the dataUnion logic in a
helper method: ImageData::BufferBase().  That way, the code seen here can just
be:
if (data->BufferBase()->isNeutered()) { ...

[zakerinasab, 2017/04/15 07:04:42]

Done.

+         data->dataUnion()
+             .getAsUint8ClampedArray()
+             ->BufferBase()
+             ->IsNeutered()) ||
+        (data->dataUnion().isUint16Array() &&
+         data->dataUnion().getAsUint16Array()->BufferBase()->IsNeutered()) ||
+        (data->dataUnion().isFloat32Array() &&
+         data->dataUnion().getAsFloat32Array()->BufferBase()->IsNeutered());
+  } else {
+    data_is_neutered = data->data()->BufferBase()->IsNeutered();
+  }
+  if (data_is_neutered) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       "The source data has been neutered.");
     return;
   }
+
   ImageBuffer* buffer = GetImageBuffer();
   if (!buffer)
     return;
 
   if (dirty_width < 0) {
     dirty_x += dirty_width;
     dirty_width = -dirty_width;
   }
 
   if (dirty_height < 0) {
@@ skipping 29 matching lines @@
                                  50));
     timer.emplace(scoped_us_counter_cpu);
   }
 
   IntRect source_rect(dest_rect);
   source_rect.Move(-dest_offset);
 
   CheckOverdraw(dest_rect, 0, CanvasRenderingContext2DState::kNoImage,
                 kUntransformedUnclippedFill);
 
-  buffer->PutByteArray(kUnmultiplied, data->data()->Data(),
-                       IntSize(data->width(), data->height()), source_rect,
-                       IntPoint(dest_offset));
-
+  if (color_management_enabled_) {
+    unsigned data_length = data->width() * data->height();
+    if (PixelFormat() == kF16CanvasPixelFormat)
+      data_length *= 2;
+    std::unique_ptr<uint8_t[]> converted_pixels(new uint8_t[4 * data_length]);
+    data->ImageDataInCanvasColorSettings(ColorSpace(), PixelFormat(),
+                                         converted_pixels);
+    buffer->PutByteArray(kUnmultiplied, converted_pixels.get(),
+                         IntSize(data->width(), data->height()), source_rect,
+                         IntPoint(dest_offset));
+  } else {
+    buffer->PutByteArray(kUnmultiplied, data->data()->Data(),
+                         IntSize(data->width(), data->height()), source_rect,
+                         IntPoint(dest_offset));
+  }
   DidDraw(dest_rect);
 }
 
 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 kRoot2 = sqrtf(2);
   double delta = GetState().LineWidth() / 2;
   if (GetState().GetLineJoin() == kMiterJoin)
@@ skipping 340 matching lines @@
       ExpensiveCanvasHeuristicParameters::kShadowFixedCost[index] *
           usage_counters_.num_blurred_shadows +
       ExpensiveCanvasHeuristicParameters::
               kShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           usage_counters_.bounding_box_area_times_shadow_blur_squared;
 
   return basic_cost_of_draw_calls + fill_type_adjustment + shadow_adjustment;
 }
 
 }  // namespace blink