Fix ImageBitmap constructor from ImageData to consider the color space tags

third_party/WebKit/Source/platform/graphics/ImageBuffer.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 62 matching lines @@
   if (!surface->isValid())
     return nullptr;
   return WTF::wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 std::unique_ptr<ImageBuffer> ImageBuffer::create(
     const IntSize& size,
     OpacityMode opacityMode,
     ImageInitializationMode initializationMode,
     sk_sp<SkColorSpace> colorSpace) {
-  std::unique_ptr<ImageBufferSurface> surface(
-      WTF::wrapUnique(new UnacceleratedImageBufferSurface(
-          size, opacityMode, initializationMode, std::move(colorSpace))));
+  SkColorType colorType = kN32_SkColorType;
+  if (colorSpace &&
+      SkColorSpace::Equals(
+          colorSpace.get(),
+          SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named).get()))
+    colorType = kRGBA_F16_SkColorType;
+
+  std::unique_ptr<ImageBufferSurface> surface(WTF::wrapUnique(
+      new UnacceleratedImageBufferSurface(size, opacityMode, initializationMode,
+                                          std::move(colorSpace), colorType)));
+
   if (!surface->isValid())
     return nullptr;
   return WTF::wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 ImageBuffer::ImageBuffer(std::unique_ptr<ImageBufferSurface> surface)
     : m_weakPtrFactory(this),
       m_snapshotState(InitialSnapshotState),
       m_surface(std::move(surface)),
       m_client(0),
@@ skipping 232 matching lines @@
 
 void ImageBuffer::flushGpu(FlushReason reason) {
   if (m_surface->canvas()) {
     m_surface->flushGpu(reason);
   }
 }
 
 bool ImageBuffer::getImageData(Multiply multiplied,
                                const IntRect& rect,
                                WTF::ArrayBufferContents& contents) const {
-  CheckedNumeric<int> dataSize = 4;
+  uint8_t bytesPerPixel = 4;
+  if (m_surface->colorSpace())
+    bytesPerPixel = SkColorTypeBytesPerPixel(m_surface->colorType());
+  CheckedNumeric<int> dataSize = bytesPerPixel;
   dataSize *= rect.width();
   dataSize *= rect.height();
   if (!dataSize.IsValid())
     return false;
 
   if (!isSurfaceValid()) {
-    size_t allocSizeInBytes = rect.width() * rect.height() * 4;
+    size_t allocSizeInBytes = rect.width() * rect.height() * bytesPerPixel;
     void* data;
     WTF::ArrayBufferContents::allocateMemoryOrNull(
         allocSizeInBytes, WTF::ArrayBufferContents::ZeroInitialize, data);
     if (!data)
       return false;
     WTF::ArrayBufferContents result(data, allocSizeInBytes,
                                     WTF::ArrayBufferContents::NotShared);
     result.transfer(contents);
     return true;
   }
 
   DCHECK(canvas());
 
   if (ExpensiveCanvasHeuristicParameters::GetImageDataForcesNoAcceleration &&
       !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
     const_cast<ImageBuffer*>(this)->disableAcceleration();
   }
 
   sk_sp<SkImage> snapshot = m_surface->newImageSnapshot(
       PreferNoAcceleration, SnapshotReasonGetImageData);
   if (!snapshot)
     return false;
 
   const bool mayHaveStrayArea =
       m_surface->isAccelerated()  // GPU readback may fail silently
       || rect.x() < 0 || rect.y() < 0 ||
       rect.maxX() > m_surface->size().width() ||
       rect.maxY() > m_surface->size().height();
-  size_t allocSizeInBytes = rect.width() * rect.height() * 4;
+  size_t allocSizeInBytes = rect.width() * rect.height() * bytesPerPixel;
   void* data;
   WTF::ArrayBufferContents::InitializationPolicy initializationPolicy =
       mayHaveStrayArea ? WTF::ArrayBufferContents::ZeroInitialize
                        : WTF::ArrayBufferContents::DontInitialize;
   WTF::ArrayBufferContents::allocateMemoryOrNull(allocSizeInBytes,
                                                  initializationPolicy, data);
   if (!data)
     return false;
   WTF::ArrayBufferContents result(data, allocSizeInBytes,
                                   WTF::ArrayBufferContents::NotShared);
 
   // Skia does not support unpremultiplied read with an F16 to 8888 conversion
   bool useF16Workaround = m_surface->colorType() == kRGBA_F16_SkColorType;
 
   SkAlphaType alphaType = (multiplied == Premultiplied || useF16Workaround)
                               ? kPremul_SkAlphaType
                               : kUnpremul_SkAlphaType;
   // The workaround path use a canvas draw under the hood, which can only
   // use N32 at this time.
   SkColorType colorType =
       useF16Workaround ? kN32_SkColorType : kRGBA_8888_SkColorType;
   SkImageInfo info =
       SkImageInfo::Make(rect.width(), rect.height(), colorType, alphaType,
                         SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named));
 
-  snapshot->readPixels(info, result.data(), 4 * rect.width(), rect.x(),
-                       rect.y());
+  snapshot->readPixels(info, result.data(), bytesPerPixel * rect.width(),
+                       rect.x(), rect.y());
 
   if (useF16Workaround) {
     uint32_t* pixel = (uint32_t*)result.data();
     size_t pixelCount = allocSizeInBytes / sizeof(uint32_t);
     // TODO(skbug.com/5853): make readPixels support RGBA output so that we no
     // longer
     // have to do this.
     if (kN32_SkColorType == kBGRA_8888_SkColorType) {
       // Convert BGRA to RGBA if necessary on this platform.
       SkSwapRB(pixel, pixel, pixelCount);
@@ skipping 13 matching lines @@
   return true;
 }
 
 void ImageBuffer::putByteArray(Multiply multiplied,
                                const unsigned char* source,
                                const IntSize& sourceSize,
                                const IntRect& sourceRect,
                                const IntPoint& destPoint) {
   if (!isSurfaceValid())
     return;
+  uint8_t bytesPerPixel = 4;
+  if (m_surface->colorSpace())
+    bytesPerPixel = SkColorTypeBytesPerPixel(m_surface->colorType());
 
   DCHECK_GT(sourceRect.width(), 0);
   DCHECK_GT(sourceRect.height(), 0);
 
   int originX = sourceRect.x();
   int destX = destPoint.x() + sourceRect.x();
   DCHECK_GE(destX, 0);
   DCHECK_LT(destX, m_surface->size().width());
   DCHECK_GE(originX, 0);
   DCHECK_LT(originX, sourceRect.maxX());
 
   int originY = sourceRect.y();
   int destY = destPoint.y() + sourceRect.y();
   DCHECK_GE(destY, 0);
   DCHECK_LT(destY, m_surface->size().height());
   DCHECK_GE(originY, 0);
   DCHECK_LT(originY, sourceRect.maxY());
 
-  const size_t srcBytesPerRow = 4 * sourceSize.width();
-  const void* srcAddr = source + originY * srcBytesPerRow + originX * 4;
+  const size_t srcBytesPerRow = bytesPerPixel * sourceSize.width();
+  const void* srcAddr =
+      source + originY * srcBytesPerRow + originX * bytesPerPixel;
   SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType
                                                         : kUnpremul_SkAlphaType;
-  SkImageInfo info = SkImageInfo::Make(
-      sourceRect.width(), sourceRect.height(), kRGBA_8888_SkColorType,
-      alphaType, SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named));
-
+  SkImageInfo info;
+  if (m_surface->colorSpace()) {
+    info = SkImageInfo::Make(sourceRect.width(), sourceRect.height(),
+                             m_surface->colorType(), alphaType,
+                             m_surface->colorSpace());
+  } else {
+    info = SkImageInfo::Make(
+        sourceRect.width(), sourceRect.height(), kRGBA_8888_SkColorType,
+        alphaType, SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named));
+  }
   m_surface->writePixels(info, srcAddr, srcBytesPerRow, destX, destY);
 }
 
 void ImageBuffer::updateGPUMemoryUsage() const {
   if (this->isAccelerated()) {
     // If image buffer is accelerated, we should keep track of GPU memory usage.
     int gpuBufferCount = 2;
-    CheckedNumeric<intptr_t> checkedGPUUsage = 4 * gpuBufferCount;
+    CheckedNumeric<intptr_t> checkedGPUUsage =
+        SkColorTypeBytesPerPixel(m_surface->colorType()) * gpuBufferCount;
     checkedGPUUsage *= this->size().width();
     checkedGPUUsage *= this->size().height();
     intptr_t gpuMemoryUsage =
         checkedGPUUsage.ValueOrDefault(std::numeric_limits<intptr_t>::max());
 
     if (!m_gpuMemoryUsage)  // was not accelerated before
       s_globalAcceleratedImageBufferCount++;
 
     s_globalGPUMemoryUsage += (gpuMemoryUsage - m_gpuMemoryUsage);
     m_gpuMemoryUsage = gpuMemoryUsage;
@@ skipping 33 matching lines @@
 void ImageBuffer::disableAcceleration() {
   if (!isAccelerated())
     return;
 
   // Create and configure a recording (unaccelerated) surface.
   std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> surfaceFactory =
       WTF::makeUnique<UnacceleratedSurfaceFactory>();
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::wrapUnique(new RecordingImageBufferSurface(
           m_surface->size(), std::move(surfaceFactory),
-          m_surface->getOpacityMode(), m_surface->colorSpace()));
+          m_surface->getOpacityMode(), m_surface->colorSpace(),
+          m_surface->colorType()));
   setSurface(std::move(surface));
 }
 
 void ImageBuffer::setSurface(std::unique_ptr<ImageBufferSurface> surface) {
   sk_sp<SkImage> image =
       m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonPaint);
 
   if (surface->isRecording()) {
     // Using a GPU-backed image with RecordingImageBufferSurface
     // will fail at playback time.
@@ skipping 35 matching lines @@
   DCHECK(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
   Vector<unsigned char> result;
   if (!encodeImage(mimeType, quality, &result))
     return "data:,";
 
   return "data:" + mimeType + ";base64," + base64Encode(result);
 }
 
 }  // namespace blink