Change code path for structured cloning ImageBitmap

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 "platform/graphics/skia/SkiaUtils.h"
@@ skipping 240 matching lines @@
     // canvas is always premultiplied, so set the last parameter to true and convert to un-premul later
     m_image = cropImage(canvas->copiedImage(BackBuffer, PreferAcceleration).get(), cropRect, flipY, true);
     if (!m_image)
         return;
     if (!premultiplyAlpha)
         m_image = StaticBitmapImage::create(premulSkImageToUnPremul(m_image->imageForCurrentFrame().get()));
     m_image->setOriginClean(canvas->originClean());
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
-// The last two parameters are used for structure-cloning.
-ImageBitmap::ImageBitmap(ImageData* data, const IntRect& cropRect, const ImageBitmapOptions& options, const bool& isImageDataPremultiplied, const bool& isImageDataOriginClean)
+// This constructor is called by structured-cloning an ImageBitmap.
+// isImageBitmapPremultiplied indicates whether the original ImageBitmap is premultiplied or not.

[jbroman, 2016/06/28 18:50:22]

Comments like this normally go in the header, since they describe how to call
the function correctly. I'd also specify in the comment that it specifies
whether the provided data contains premultiplied or unpremultiplied pixel data.

[xidachen, 2016/06/29 12:58:35]

Done.

+// isImageBitmapOriginClean indicates whether the original ImageBitmap is origin clean or not.
+ImageBitmap::ImageBitmap(std::unique_ptr<uint8_t[]> data, uint32_t width, uint32_t height, bool isImageBitmapPremultiplied, bool isImageBitmapOriginClean)
+{
+    SkImageInfo info = SkImageInfo::Make(width, height, kBGRA_8888_SkColorType, isImageBitmapPremultiplied ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
+    swizzleImageData(data.get(), height, info.bytesPerPixel() * width, false);

[jbroman, 2016/06/28 18:50:22]

What's the purpose of this swizzling? Why aren't we serializing data in the most
convenient format to read it?

[xidachen, 2016/06/29 12:58:35]

Done.

+    m_image = StaticBitmapImage::create(fromSkSp(SkImage::MakeRasterCopy(SkPixmap(info, data.get(), info.bytesPerPixel() * width))));
+    swizzleImageData(data.get(), height, info.bytesPerPixel() * width, false);

[jbroman, 2016/06/28 18:50:22]

Why unswizzle the data when we're about to delete it anyhow?

[xidachen, 2016/06/29 12:58:35]

Done.

+    m_image->setPremultiplied(isImageBitmapPremultiplied);
+    m_image->setOriginClean(isImageBitmapOriginClean);
+}
+
+ImageBitmap::ImageBitmap(ImageData* data, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     bool flipY;
     bool premultiplyAlpha;
     parseOptions(options, flipY, premultiplyAlpha);
     IntRect srcRect = intersection(cropRect, IntRect(IntPoint(), data->size()));
 
     // treat non-premultiplyAlpha as a special case
     if (!premultiplyAlpha) {
         unsigned char* srcAddr = data->data()->data();
         int srcHeight = data->size().height();
         int dstHeight = cropRect.height();
         // TODO (xidachen): skia doesn't support SkImage::NewRasterCopy from a kRGBA color type.
         // For now, we swap R and B channel and uses kBGRA color type.
-        SkImageInfo info;
-        if (!isImageDataPremultiplied)
-            info = SkImageInfo::Make(cropRect.width(), dstHeight, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType);
-        else
-            info = SkImageInfo::Make(cropRect.width(), dstHeight, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
+        SkImageInfo info = SkImageInfo::Make(cropRect.width(), dstHeight, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType);
         int srcPixelBytesPerRow = info.bytesPerPixel() * data->size().width();
         int dstPixelBytesPerRow = info.bytesPerPixel() * cropRect.width();
         if (cropRect == IntRect(IntPoint(), data->size())) {
             swizzleImageData(srcAddr, srcHeight, srcPixelBytesPerRow, flipY);
             m_image = StaticBitmapImage::create(fromSkSp(SkImage::MakeRasterCopy(SkPixmap(info, srcAddr, dstPixelBytesPerRow))));
             // restore the original ImageData
             swizzleImageData(srcAddr, srcHeight, srcPixelBytesPerRow, flipY);
         } else {
             std::unique_ptr<uint8_t[]> copiedDataBuffer = wrapArrayUnique(new uint8_t[dstHeight * dstPixelBytesPerRow]());
             if (!srcRect.isEmpty()) {
@@ skipping 19 matching lines @@
                         else if (j % 4 == 2)
                             copiedDataBuffer[dstStartCopyPosition + j] = srcAddr[srcStartCopyPosition + j - 2];
                         else
                             copiedDataBuffer[dstStartCopyPosition + j] = srcAddr[srcStartCopyPosition + j];
                     }
                 }
             }
             m_image = StaticBitmapImage::create(newSkImageFromRaster(info, std::move(copiedDataBuffer), dstPixelBytesPerRow));
         }
         m_image->setPremultiplied(premultiplyAlpha);
-        m_image->setOriginClean(isImageDataOriginClean);
         return;
     }
 
     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     if (srcRect.isEmpty()) {
         m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown));
         return;
@@ skipping 67 matching lines @@
     IntRect normalizedCropRect = normalizeRect(cropRect);
     return new ImageBitmap(video, normalizedCropRect, document, options);
 }
 
 ImageBitmap* ImageBitmap::create(HTMLCanvasElement* canvas, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
     return new ImageBitmap(canvas, normalizedCropRect, options);
 }
 
-ImageBitmap* ImageBitmap::create(ImageData* data, const IntRect& cropRect, const ImageBitmapOptions& options, const bool& isImageDataPremultiplied, const bool& isImageDataOriginClean)
+ImageBitmap* ImageBitmap::create(ImageData* data, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
-    return new ImageBitmap(data, normalizedCropRect, options, isImageDataPremultiplied, isImageDataOriginClean);
+    return new ImageBitmap(data, normalizedCropRect, options);
 }
 
 ImageBitmap* ImageBitmap::create(ImageBitmap* bitmap, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
     return new ImageBitmap(bitmap, normalizedCropRect, options);
 }
 
 ImageBitmap* ImageBitmap::create(PassRefPtr<StaticBitmapImage> image, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     IntRect normalizedCropRect = normalizeRect(cropRect);
     return new ImageBitmap(image, normalizedCropRect, options);
 }
 
 ImageBitmap* ImageBitmap::create(PassRefPtr<StaticBitmapImage> image)
 {
     return new ImageBitmap(image);
 }
 
 ImageBitmap* ImageBitmap::create(WebExternalTextureMailbox& mailbox)
 {
     return new ImageBitmap(mailbox);
 }
 
+ImageBitmap* ImageBitmap::create(std::unique_ptr<uint8_t[]> data, uint32_t width, uint32_t height, bool isImageBitmapPremultiplied, bool isImageBitmapOriginClean)
+{
+    return new ImageBitmap(std::move(data), width, height, isImageBitmapPremultiplied, isImageBitmapOriginClean);
+}
+
 void ImageBitmap::close()
 {
     if (!m_image || m_isNeutered)
         return;
     m_image.clear();
     m_isNeutered = true;
 }
 
 // static
 ImageBitmap* ImageBitmap::take(ScriptPromiseResolver*, sk_sp<SkImage> image)
@@ skipping 75 matching lines @@
 FloatSize ImageBitmap::elementSize(const FloatSize&) const
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
 }
 
 } // namespace blink