Implementing ImageBitmap option imageOrientation of flipY

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 "third_party/skia/include/core/SkSurface.h"
@@ skipping 71 matching lines @@
 
     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     if (srcRect.isEmpty()) {
         m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration));
         return;
     }
 
     IntPoint dstPoint = IntPoint(std::min(0, -cropRect.x()), std::min(0, -cropRect.y()));

[jbroman, 2016/01/26 17:03:37]

Is it intended that the crop rect apply to the image after the orientation has
been applied? It takes awhile to figure out whether the rectangle is specified
in the flipped or unflipped coordinate space, and a comment here (and one in the
spec) would be very helpful.

[xidachen, 2016/02/03 02:17:19]

Upon discussion with kbr@, it actually should be applying crop first and then
flip.

     if (cropRect.x() < 0)
         dstPoint.setX(-cropRect.x());
     if (cropRect.y() < 0)
         dstPoint.setY(-cropRect.y());
-    buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(), srcRect, dstPoint);
+    if (options.orientation() == "flipY" || options.orientation() == "bottomLeft") {
+        OwnPtr<uint8_t[]> flippedData = copyFlippedSourceData(data->data()->data(), data->width(), data->height());
+        buffer->putByteArray(Unmultiplied, flippedData.get(), data->size(), srcRect, dstPoint);
+    } else {
+        buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(), srcRect, dstPoint);
+    }
     m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration));
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     m_image = cropImage(bitmap->bitmapImage(), cropRect);
     m_image->setOriginClean(bitmap->originClean());
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image, const IntRect& cropRect, const ImageBitmapOptions& options)
 {
     m_image = cropImage(image.get(), cropRect);
     m_image->setOriginClean(image->originClean());
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image)
 {
     m_image = image;
 }
 
+PassOwnPtr<uint8_t[]> ImageBitmap::copyFlippedSourceData(const unsigned char* source, int width, int height)

[jbroman, 2016/01/26 17:03:37]

This assumes 4-byte pixels, and that the row size is exactly width * 4. This
seems to be true for ImageData, but not generally. Please either make this take
the ImageData instead, or rename it so that it's clear that these expectations
apply, to avoid misuse.

Also, this does not need to be a member of ImageBitmap, so I'd rather this were
a free static function, like normalizeRect and cropImage at the top of this
file. (It will then not need to be declared in the header.)

[xidachen, 2016/02/03 02:17:19]

This function won't be needed anymore because we don't need to apply flip to the
source data.

+{
+    const size_t bytesPerRow = 4 * width;
+    OwnPtr<uint8_t[]> dstPixels = adoptArrayPtr(new uint8_t[width * height * 4]);
+    for (int i = 0; i < height; i++) {
+        const unsigned char* srcAddr = source + i * bytesPerRow;
+        unsigned char* dstAddr = dstPixels.get() + (height - 1 - i) * bytesPerRow;
+        memcpy(dstAddr, srcAddr, bytesPerRow);
+    }
+    return dstPixels.release();
+}
+
 PassRefPtr<StaticBitmapImage> ImageBitmap::transfer()
 {
     ASSERT(!isNeutered());
     m_isNeutered = true;
     return m_image.release();
 }
 
 ImageBitmap::~ImageBitmap()
 {
 }
@@ skipping 99 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
     ImageLoaderClient::trace(visitor);
 }
 
 } // namespace blink