Change implementation of resize ImageBitmap to meet specs

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 47 matching lines @@
     }
     if (options.premultiplyAlpha() == imageBitmapOptionNone) {
         parsedOptions.premultiplyAlpha = false;
     } else {
         parsedOptions.premultiplyAlpha = true;
         DCHECK(options.premultiplyAlpha() == "default" || options.premultiplyAlpha() == "premultiply");
     }
 
     int sourceWidth = sourceSize.width();
     int sourceHeight = sourceSize.height();
+    if (!cropRect) {
+        parsedOptions.cropRect = IntRect(0, 0, sourceWidth, sourceHeight);
+    } else  {
+        parsedOptions.cropRect = normalizeRect(*cropRect);
+    }
     if (!options.hasResizeWidth() && !options.hasResizeHeight()) {
-        parsedOptions.resizeWidth = sourceWidth;
-        parsedOptions.resizeHeight = sourceHeight;
+        parsedOptions.resizeWidth = parsedOptions.cropRect.width();
+        parsedOptions.resizeHeight = parsedOptions.cropRect.height();
     } else if (options.hasResizeWidth() && options.hasResizeHeight()) {
         parsedOptions.resizeWidth = options.resizeWidth();
         parsedOptions.resizeHeight = options.resizeHeight();
     } else if (options.hasResizeWidth() && !options.hasResizeHeight()) {
         parsedOptions.resizeWidth = options.resizeWidth();
-        parsedOptions.resizeHeight = ceil(static_cast<float>(options.resizeWidth()) / sourceWidth * sourceHeight);
+        parsedOptions.resizeHeight = ceil(static_cast<float>(options.resizeWidth()) / parsedOptions.cropRect.width() * parsedOptions.cropRect.height());
     } else {
         parsedOptions.resizeHeight = options.resizeHeight();
-        parsedOptions.resizeWidth = ceil(static_cast<float>(options.resizeHeight()) / sourceHeight * sourceWidth);
+        parsedOptions.resizeWidth = ceil(static_cast<float>(options.resizeHeight()) / parsedOptions.cropRect.height() * parsedOptions.cropRect.width());
     }
-    if (!cropRect) {
-        parsedOptions.cropRect = IntRect(0, 0, parsedOptions.resizeWidth, parsedOptions.resizeHeight);
-    } else  {
-        parsedOptions.cropRect = normalizeRect(*cropRect);
-    }
-    if (static_cast<int>(parsedOptions.resizeWidth) == sourceWidth && static_cast<int>(parsedOptions.resizeHeight) == sourceHeight) {
+    if (static_cast<int>(parsedOptions.resizeWidth) == parsedOptions.cropRect.width() && static_cast<int>(parsedOptions.resizeHeight) == parsedOptions.cropRect.height()) {
         parsedOptions.shouldScaleInput = false;
         return parsedOptions;
     }
     parsedOptions.shouldScaleInput = true;
 
     if (options.resizeQuality() == "high")
         parsedOptions.resizeQuality = kHigh_SkFilterQuality;
     else if (options.resizeQuality() == "medium")
         parsedOptions.resizeQuality = kMedium_SkFilterQuality;
     else if (options.resizeQuality() == "pixelated")
@@ skipping 108 matching lines @@
 static PassRefPtr<StaticBitmapImage> cropImage(Image* image, const ParsedOptions& parsedOptions, AlphaDisposition imageFormat = PremultiplyAlpha, ImageDecoder::GammaAndColorProfileOption colorSpaceOp = ImageDecoder::GammaAndColorProfileApplied)
 {
     ASSERT(image);
 
     IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
     const IntRect srcRect = intersection(imgRect, parsedOptions.cropRect);
 
     // In the case when cropRect doesn't intersect the source image and it requires a umpremul image
     // We immediately return a transparent black image with cropRect.size()
     if (srcRect.isEmpty() && !parsedOptions.premultiplyAlpha) {
-        SkImageInfo info = SkImageInfo::Make(parsedOptions.cropRect.width(), parsedOptions.cropRect.height(), kN32_SkColorType, kUnpremul_SkAlphaType);
-        std::unique_ptr<uint8_t[]> dstPixels = wrapArrayUnique(new uint8_t[parsedOptions.cropRect.width() * parsedOptions.cropRect.height() * info.bytesPerPixel()]());
-        return StaticBitmapImage::create(newSkImageFromRaster(info, std::move(dstPixels), parsedOptions.cropRect.width() * info.bytesPerPixel()));
+        SkImageInfo info = SkImageInfo::Make(parsedOptions.resizeWidth, parsedOptions.resizeHeight, kN32_SkColorType, kUnpremul_SkAlphaType);
+        std::unique_ptr<uint8_t[]> dstPixels = wrapArrayUnique(new uint8_t[info.width() * info.height() * info.bytesPerPixel()]());
+        return StaticBitmapImage::create(newSkImageFromRaster(info, std::move(dstPixels), info.width() * info.bytesPerPixel()));
     }
 
     RefPtr<SkImage> skiaImage = image->imageForCurrentFrame();
     // Attempt to get raw unpremultiplied image data, executed only when skiaImage is premultiplied.
     if ((((!parsedOptions.premultiplyAlpha && !skiaImage->isOpaque()) || !skiaImage) && image->data() && imageFormat == PremultiplyAlpha) || colorSpaceOp == ImageDecoder::GammaAndColorProfileIgnored) {
         std::unique_ptr<ImageDecoder> decoder(ImageDecoder::create(*(image->data()),
             parsedOptions.premultiplyAlpha ? ImageDecoder::AlphaPremultiplied : ImageDecoder::AlphaNotPremultiplied,
             colorSpaceOp));
         if (!decoder)
             return nullptr;
         decoder->setData(image->data(), true);
         skiaImage = ImageBitmap::getSkImageFromDecoder(std::move(decoder));
         if (!skiaImage)
             return nullptr;
     }
 
-    if (parsedOptions.cropRect == srcRect) {
+    if (parsedOptions.cropRect == srcRect && !parsedOptions.shouldScaleInput) {
         RefPtr<SkImage> croppedSkImage = fromSkSp(skiaImage->makeSubset(srcRect));
         if (parsedOptions.flipY)
             return StaticBitmapImage::create(flipSkImageVertically(croppedSkImage.get(), parsedOptions.premultiplyAlpha ? PremultiplyAlpha : DontPremultiplyAlpha));
         // Special case: The first parameter image is unpremul but we need to turn it into premul.
         if (parsedOptions.premultiplyAlpha && imageFormat == DontPremultiplyAlpha)
             return StaticBitmapImage::create(unPremulSkImageToPremul(croppedSkImage.get()));
         // Call preroll to trigger image decoding.
         croppedSkImage->preroll();
         return StaticBitmapImage::create(croppedSkImage.release());
     }
 
-    sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(parsedOptions.cropRect.width(), parsedOptions.cropRect.height());
+    sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(parsedOptions.resizeWidth, parsedOptions.resizeHeight);
     if (!surface)
         return nullptr;
     if (srcRect.isEmpty())
         return StaticBitmapImage::create(fromSkSp(surface->makeImageSnapshot()));
 
     SkScalar dstLeft = std::min(0, -parsedOptions.cropRect.x());
     SkScalar dstTop = std::min(0, -parsedOptions.cropRect.y());
     if (parsedOptions.cropRect.x() < 0)
         dstLeft = -parsedOptions.cropRect.x();
     if (parsedOptions.cropRect.y() < 0)
         dstTop = -parsedOptions.cropRect.y();
     if (parsedOptions.flipY) {
         surface->getCanvas()->translate(0, surface->height());
         surface->getCanvas()->scale(1, -1);
     }
     if (parsedOptions.shouldScaleInput) {
-        SkRect drawDstRect = SkRect::MakeXYWH(dstLeft, dstTop, parsedOptions.resizeWidth, parsedOptions.resizeHeight);
+        SkRect drawSrcRect = SkRect::MakeXYWH(parsedOptions.cropRect.x(), parsedOptions.cropRect.y(), parsedOptions.cropRect.width(), parsedOptions.cropRect.height());
+        SkRect drawDstRect = SkRect::MakeXYWH(0, 0, parsedOptions.resizeWidth, parsedOptions.resizeHeight);
         SkPaint paint;
         paint.setFilterQuality(parsedOptions.resizeQuality);
-        surface->getCanvas()->drawImageRect(skiaImage.get(), drawDstRect, &paint);
+        surface->getCanvas()->drawImageRect(skiaImage.get(), drawSrcRect, drawDstRect, &paint);
     } else {
         surface->getCanvas()->drawImage(skiaImage.get(), dstLeft, dstTop);
     }
     skiaImage = fromSkSp(surface->makeImageSnapshot());
 
     if (parsedOptions.premultiplyAlpha) {
         if (imageFormat == PremultiplyAlpha)
             return StaticBitmapImage::create(unPremulSkImageToPremul(skiaImage.get()));
         return StaticBitmapImage::create(skiaImage.release());
     }
@@ skipping 328 matching lines @@
 FloatSize ImageBitmap::elementSize(const FloatSize&) const
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
 }
 
 } // namespace blink