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

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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 "core/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
@@ skipping 771 matching lines @@
   IntRect srcRect = cropRect ? intersection(parsedOptions.cropRect, dataSrcRect)
                              : dataSrcRect;
 
   // treat non-premultiplyAlpha as a special case
   if (!parsedOptions.premultiplyAlpha) {
     unsigned char* srcAddr = data->data()->data();
 
     // Using kN32 type, swizzle input if necessary.
     SkImageInfo info = SkImageInfo::Make(
         parsedOptions.cropRect.width(), parsedOptions.cropRect.height(),
-        kN32_SkColorType, kUnpremul_SkAlphaType, data->getSkColorSpace());
+        kN32_SkColorType, kUnpremul_SkAlphaType, data->skColorSpace());
     unsigned bytesPerPixel = static_cast<unsigned>(info.bytesPerPixel());
     unsigned srcPixelBytesPerRow = bytesPerPixel * data->size().width();
     unsigned dstPixelBytesPerRow =
         bytesPerPixel * parsedOptions.cropRect.width();
     sk_sp<SkImage> skImage;
     if (parsedOptions.cropRect == IntRect(IntPoint(), data->size())) {
       swizzleImageData(srcAddr, data->size().height(), srcPixelBytesPerRow,
                        parsedOptions.flipY);
       skImage =
           SkImage::MakeRasterCopy(SkPixmap(info, srcAddr, dstPixelBytesPerRow));
@@ skipping 56 matching lines @@
                   srcAddr[srcStartCopyPosition + j];
             }
           }
         }
       }
       skImage = newSkImageFromRaster(info, std::move(copiedDataBuffer),
                                      dstPixelBytesPerRow);
     }
     if (!skImage)
       return;
-    if (data->getSkColorSpace()) {
-      parsedOptions.latestColorSpace = data->getSkColorSpace();
+    if (data->skColorSpace()) {
+      parsedOptions.latestColorSpace = data->skColorSpace();
       applyColorSpaceConversion(skImage, parsedOptions);
     }
     if (parsedOptions.shouldScaleInput) {
       m_image = StaticBitmapImage::create(
           scaleSkImage(skImage, parsedOptions.resizeWidth,
                        parsedOptions.resizeHeight, parsedOptions.resizeQuality,
-                       parsedOptions.latestColorType, data->getSkColorSpace()));
+                       parsedOptions.latestColorType, data->skColorSpace()));
     } else {
       m_image = StaticBitmapImage::create(skImage);
     }
     if (!m_image)
       return;
     m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
     return;
   }
 
   std::unique_ptr<ImageBuffer> buffer =
       ImageBuffer::create(parsedOptions.cropRect.size(), NonOpaque,
-                          DoNotInitializeImagePixels, data->getSkColorSpace());
+                          DoNotInitializeImagePixels, data->skColorSpace());
   if (!buffer)
     return;
 
   if (srcRect.isEmpty()) {
     m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(
         PreferNoAcceleration, SnapshotReasonUnknown));
     return;
   }
 
   IntPoint dstPoint = IntPoint(std::min(0, -parsedOptions.cropRect.x()),
                                std::min(0, -parsedOptions.cropRect.y()));
   if (parsedOptions.cropRect.x() < 0)
     dstPoint.setX(-parsedOptions.cropRect.x());
   if (parsedOptions.cropRect.y() < 0)
     dstPoint.setY(-parsedOptions.cropRect.y());
 
   buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(),
                        srcRect, dstPoint);
   sk_sp<SkImage> skImage =
       buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown);
   if (parsedOptions.flipY)
     skImage = flipSkImageVertically(skImage.get(), EnforceAlphaPremultiply);
   if (!skImage)
     return;
   if (parsedOptions.shouldScaleInput) {
     sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(
         parsedOptions.resizeWidth, parsedOptions.resizeHeight,
-        data->getSkColorSpace()));
+        data->skColorSpace()));
     if (!surface)
       return;
     SkPaint paint;
     paint.setFilterQuality(parsedOptions.resizeQuality);
     SkRect dstDrawRect =
         SkRect::MakeWH(parsedOptions.resizeWidth, parsedOptions.resizeHeight);
     surface->getCanvas()->drawImageRect(skImage, dstDrawRect, &paint);
     skImage = surface->makeImageSnapshot();
   }
-  if (data->getSkColorSpace()) {
-    parsedOptions.latestColorSpace = data->getSkColorSpace();
+  if (data->skColorSpace()) {
+    parsedOptions.latestColorSpace = data->skColorSpace();
     applyColorSpaceConversion(skImage, parsedOptions);
   }
   m_image = StaticBitmapImage::create(std::move(skImage));
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap,
                          Optional<IntRect> cropRect,
                          const ImageBitmapOptions& options) {
   RefPtr<Image> input = bitmap->bitmapImage();
   if (!input)
@@ skipping 186 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink