Replace ImageData::GetSkImageInfo with ImageData::GetSkPixmap

Several callsites only use ImageData::GetSkImageInfo in the process
of retrieving all of the relevant information to construct a SkPixmap.

TBR=yiyx,fserb

Bug: 1150969
Change-Id: I3a44bcb8ab357559f4f16d749b5abf8b69136f4b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2552999Reviewed-by: ccameron <ccameron@chromium.org>
Commit-Queue: ccameron <ccameron@chromium.org>
Cr-Commit-Position: refs/heads/master@{#829914}

third_party/blink/renderer/core/html/canvas/image_data.cc

@@ -271,13 +271,6 @@ ImageDataColorSettings* CanvasColorParamsToImageDataColorSettings(
   return color_settings;
 }
 
-ImageData* ImageData::Create(const IntSize& size,
-                             const CanvasColorParams& color_params) {
-  ImageDataColorSettings* color_settings =
-      CanvasColorParamsToImageDataColorSettings(color_params);
-  return ImageData::Create(size, color_settings);
-}
-
 ImageData* ImageData::Create(const IntSize& size,
                              CanvasColorSpace color_space,
                              ImageDataStorageFormat storage_format) {
@@ -332,7 +325,8 @@ ImageData* ImageData::Create(scoped_refptr<StaticBitmapImage> image,
     }
   }
 
-  ImageData* image_data = Create(image->Size(), color_params);
+  ImageData* image_data = Create(
+      image->Size(), CanvasColorParamsToImageDataColorSettings(color_params));
   if (!image_data)
     return nullptr;
 
@@ -667,7 +661,13 @@ ImageDataStorageFormat ImageData::GetImageDataStorageFormat(
   return kUint8ClampedArrayStorageFormat;
 }
 
-ImageDataStorageFormat ImageData::GetImageDataStorageFormat() {
+CanvasColorSpace ImageData::GetCanvasColorSpace() const {
+  if (!RuntimeEnabledFeatures::CanvasColorManagementEnabled())
+    return CanvasColorSpace::kSRGB;
+  return CanvasColorSpaceFromName(color_settings_->colorSpace());
+}
+
+ImageDataStorageFormat ImageData::GetImageDataStorageFormat() const {
   if (data_u16_)
     return kUint16ArrayStorageFormat;
   if (data_f32_)
@@ -782,15 +782,17 @@ CanvasColorParams ImageData::GetCanvasColorParams() {
       kNonOpaque);
 }
 
-SkImageInfo ImageData::GetSkImageInfo() {
-  SkColorType color_type = kN32_SkColorType;
+SkPixmap ImageData::GetSkPixmap() const {
+  SkColorType color_type = kRGBA_8888_SkColorType;
   if (data_u16_) {
     color_type = kR16G16B16A16_unorm_SkColorType;
   } else if (data_f32_) {
     color_type = kRGBA_F32_SkColorType;
   }
-  return SkImageInfo::Make(width(), height(), color_type,
-                           kUnpremul_SkAlphaType);
+  SkImageInfo info =
+      SkImageInfo::Make(width(), height(), color_type, kUnpremul_SkAlphaType,
+                        CanvasColorSpaceToSkColorSpace(GetCanvasColorSpace()));
+  return SkPixmap(info, BufferBase()->Data(), info.minRowBytes());
 }
 
 bool ImageData::ImageDataInCanvasColorSettings(
@@ -836,7 +838,8 @@ bool ImageData::ImageDataInCanvasColorSettings(
   skcms_ICCProfile* src_profile_ptr = nullptr;
   skcms_ICCProfile* dst_profile_ptr = nullptr;
   skcms_ICCProfile src_profile, dst_profile;
-  GetCanvasColorParams().GetSkColorSpace()->toProfile(&src_profile);
+  CanvasColorSpaceToSkColorSpace(GetCanvasColorSpace())
+      ->toProfile(&src_profile);
   canvas_color_params.GetSkColorSpace()->toProfile(&dst_profile);
   // If the profiles are similar, we better leave them as nullptr, since
   // skcms_Transform() only checks for profile pointer equality for the fast

third_party/blink/renderer/core/html/canvas/image_data.h

@@ -71,7 +71,6 @@ class CORE_EXPORT ImageData final : public ScriptWrappable,
  public:
   static ImageData* Create(const IntSize&,
                            const ImageDataColorSettings* = nullptr);
-  static ImageData* Create(const IntSize&, const CanvasColorParams&);
   static ImageData* Create(const IntSize&,
                            CanvasColorSpace,
                            ImageDataStorageFormat);
@@ -127,7 +126,6 @@ class CORE_EXPORT ImageData final : public ScriptWrappable,
 
   ImageData* CropRect(const IntRect&, bool flip_y = false);
 
-  ImageDataStorageFormat GetImageDataStorageFormat();
   static String CanvasColorSpaceName(CanvasColorSpace);
   static ImageDataStorageFormat GetImageDataStorageFormat(const String&);
   static unsigned StorageFormatBytesPerPixel(const String&);
@@ -148,7 +146,11 @@ class CORE_EXPORT ImageData final : public ScriptWrappable,
 
   DOMArrayBufferBase* BufferBase() const;
   CanvasColorParams GetCanvasColorParams();
-  SkImageInfo GetSkImageInfo();
+  CanvasColorSpace GetCanvasColorSpace() const;
+  ImageDataStorageFormat GetImageDataStorageFormat() const;
+
+  // Return an SkPixmap that references this data directly.
+  SkPixmap GetSkPixmap() const;
 
   // DataU8ColorType param specifies if the converted pixels in uint8 pixel
   // format should respect the "native" 32bit ARGB format of Skia's blitters.

third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.cc

@@ -1905,7 +1905,7 @@ void BaseRenderingContext2D::putImageData(ImageData* data,
   // in sRGB color space and use uint8 pixel storage format. We use RGBA pixel
   // order for both ImageData and CanvasResourceProvider, therefore no
   // additional swizzling is needed.
-  SkImageInfo data_info = data->GetSkImageInfo();
+  SkPixmap data_pixmap = data->GetSkPixmap();
   CanvasColorParams data_color_params = data->GetCanvasColorParams();
   CanvasColorParams context_color_params = CanvasColorParams(
       GetCanvas2DColorParams().ColorSpace(), PixelFormat(), kNonOpaque);
@@ -1913,30 +1913,28 @@ void BaseRenderingContext2D::putImageData(ImageData* data,
   if (data_color_params.ColorSpace() != context_color_params.ColorSpace() ||
       data_color_params.PixelFormat() != context_color_params.PixelFormat() ||
       PixelFormat() == CanvasPixelFormat::kF16) {
-    size_t data_length;
-    if (!base::CheckMul(data->Size().Area(),
-                        context_color_params.BytesPerPixel())
-             .AssignIfValid(&data_length)) {
+    SkImageInfo converted_info = data_pixmap.info();
+    converted_info =
+        converted_info.makeColorType(GetCanvas2DColorParams().GetSkColorType());
+    converted_info = converted_info.makeColorSpace(
+        GetCanvas2DColorParams().GetSkColorSpace());
+    if (converted_info.colorType() == kN32_SkColorType)
+      converted_info = converted_info.makeColorType(kRGBA_8888_SkColorType);
+
+    const size_t converted_data_bytes = converted_info.computeMinByteSize();
+    const size_t converted_row_bytes = converted_info.minRowBytes();
+    if (SkImageInfo::ByteSizeOverflowed(converted_data_bytes))
       return;
-    }
-    std::unique_ptr<uint8_t[]> converted_pixels(new uint8_t[data_length]);
-
-    if (data->ImageDataInCanvasColorSettings(
-            GetCanvas2DColorParams().ColorSpace(), PixelFormat(),
-            converted_pixels.get(), kRGBAColorType)) {
-      SkImageInfo converted_info = data_info;
-      converted_info = converted_info.makeColorType(
-          GetCanvas2DColorParams().GetSkColorType());
-      converted_info = converted_info.makeColorSpace(
-          GetCanvas2DColorParams().GetSkColorSpace());
-      PutByteArray(SkPixmap(converted_info, converted_pixels.get(),
-                            converted_info.minRowBytes()),
-                   source_rect, IntPoint(dest_offset));
+    std::unique_ptr<uint8_t[]> converted_pixels(
+        new uint8_t[converted_data_bytes]);
+    if (data_pixmap.readPixels(converted_info, converted_pixels.get(),
+                               converted_row_bytes)) {
+      PutByteArray(
+          SkPixmap(converted_info, converted_pixels.get(), converted_row_bytes),
+          source_rect, IntPoint(dest_offset));
     }
   } else {
-    PutByteArray(SkPixmap(data_info, data->BufferBase()->Data(),
-                          data_info.minRowBytes()),
-                 source_rect, IntPoint(dest_offset));
+    PutByteArray(data_pixmap, source_rect, IntPoint(dest_offset));
   }
 
   if (!IsPaint2D()) {

third_party/blink/renderer/modules/shapedetection/shape_detector.cc

@@ -119,18 +119,21 @@ ScriptPromise ShapeDetector::DetectShapesOnImageData(
     return promise;
   }
 
+  SkPixmap image_data_pixmap = image_data->GetSkPixmap();
   SkBitmap sk_bitmap;
-  SkImageInfo sk_image_info = image_data->GetSkImageInfo();
-  if (!sk_bitmap.tryAllocPixels(sk_image_info, sk_image_info.minRowBytes())) {
+  if (!sk_bitmap.tryAllocPixels(image_data_pixmap.info(),
+                                image_data_pixmap.rowBytes())) {
     resolver->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kInvalidStateError,
         "Failed to allocate pixels for current frame."));
     return promise;
   }
-
-  size_t byte_size = sk_bitmap.computeByteSize();
-  CHECK_EQ(byte_size, image_data->BufferBase()->ByteLength());
-  memcpy(sk_bitmap.getPixels(), image_data->BufferBase()->Data(), byte_size);
+  if (!sk_bitmap.writePixels(image_data_pixmap, 0, 0)) {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kInvalidStateError,
+        "Failed to copy pixels for current frame."));
+    return promise;
+  }
 
   return DoDetect(resolver, std::move(sk_bitmap));
 }