Fix directly composited image path for CSS image-orientation

third_party/WebKit/Source/platform/DragImage.cpp

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 54 matching lines @@
 // Keep border_y in synch with DragController::LinkDragBorderInset.
 const float kDragLabelBorderY = 2;
 const float kLabelBorderYOffset = 2;
 
 const float kMaxDragLabelWidth = 300;
 const float kMaxDragLabelStringWidth = (kMaxDragLabelWidth - 2 * kDragLabelBorderX);
 
 const float kDragLinkLabelFontSize = 11;
 const float kDragLinkUrlFontSize = 10;
 
+} // anonymous namespace
+
 PassRefPtr<SkImage> adjustedImage(PassRefPtr<SkImage> image, const IntSize& size,
     const AffineTransform& transform, float opacity, InterpolationQuality interpolationQuality)
 {
     if (transform.isIdentity() && opacity == 1) {
         // Nothing to adjust, just use the original.
         ASSERT(image->width() == size.width());
         ASSERT(image->height() == size.height());
         return image;
     }
 
     RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterN32Premul(size.width(), size.height()));
     if (!surface)
         return nullptr;
 
     SkPaint paint;
     ASSERT(opacity >= 0 && opacity <= 1);
     paint.setAlpha(opacity * 255);
     paint.setFilterQuality(interpolationQuality == InterpolationNone
         ? kNone_SkFilterQuality : kHigh_SkFilterQuality);
 
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(SK_ColorTRANSPARENT);
     canvas->concat(affineTransformToSkMatrix(transform));
     canvas->drawImage(image.get(), 0, 0, &paint);
 
     return adoptRef(surface->newImageSnapshot());
 }
 
-} // anonymous namespace
-
-FloatSize DragImage::clampedImageScale(const Image& image, const IntSize& size,
+FloatSize DragImage::clampedImageScale(const IntSize& imageSize, const IntSize& size,
     const IntSize& maxSize)
 {
     // Non-uniform scaling for size mapping.
     FloatSize imageScale(
-        static_cast<float>(size.width()) / image.width(),
-        static_cast<float>(size.height()) / image.height());
+        static_cast<float>(size.width()) / imageSize.width(),
+        static_cast<float>(size.height()) / imageSize.height());
 
     // Uniform scaling for clamping.
     const float clampScaleX = size.width() > maxSize.width()
         ? static_cast<float>(maxSize.width()) / size.width() : 1;
     const float clampScaleY = size.height() > maxSize.height()
         ? static_cast<float>(maxSize.height()) / size.height() : 1;
     imageScale.scale(std::min(clampScaleX, clampScaleY));
 
     return imageScale;
 }
 
 PassOwnPtr<DragImage> DragImage::create(Image* image,
     RespectImageOrientationEnum shouldRespectImageOrientation, float deviceScaleFactor,
-    InterpolationQuality interpolationQuality, float opacity, const FloatSize& imageScale)
+    InterpolationQuality interpolationQuality, float opacity, FloatSize imageScale)
 {
     if (!image)
         return nullptr;
 
     RefPtr<SkImage> skImage = image->imageForCurrentFrame();
     if (!skImage)
         return nullptr;
 
     IntSize size = image->size();
     size.scale(imageScale.width(), imageScale.height());
     if (size.isEmpty())
         return nullptr;
 
     AffineTransform transform;
-    transform.scaleNonUniform(imageScale.width(), imageScale.height());
-
     if (shouldRespectImageOrientation == RespectImageOrientation && image->isBitmapImage()) {
         BitmapImage* bitmapImage = toBitmapImage(image);
         ImageOrientation orientation = bitmapImage->currentFrameOrientation();
 
         if (orientation != DefaultImageOrientation) {
             size = bitmapImage->sizeRespectingOrientation();
-            if (orientation.usesWidthAsHeight())
-                size.scale(imageScale.height(), imageScale.width());
-            else
-                size.scale(imageScale.width(), imageScale.height());
-
+            size.scale(imageScale.width(), imageScale.height());
             transform *= orientation.transformFromDefault(size);
         }
     }
+    transform.scaleNonUniform(imageScale.width(), imageScale.height());
 
     SkBitmap bm;
     RefPtr<SkImage> resizedImage =
         adjustedImage(skImage.release(), size, transform, opacity, interpolationQuality);
     if (!resizedImage || !resizedImage->asLegacyBitmap(&bm, SkImage::kRO_LegacyBitmapMode))
         return nullptr;
 
     return adoptPtr(new DragImage(bm, deviceScaleFactor, interpolationQuality));
 }
 
@@ skipping 108 matching lines @@
 
 void DragImage::scale(float scaleX, float scaleY)
 {
     skia::ImageOperations::ResizeMethod resizeMethod = m_interpolationQuality == InterpolationNone ? skia::ImageOperations::RESIZE_BOX : skia::ImageOperations::RESIZE_LANCZOS3;
     int imageWidth = scaleX * m_bitmap.width();
     int imageHeight = scaleY * m_bitmap.height();
     m_bitmap = skia::ImageOperations::Resize(m_bitmap, resizeMethod, imageWidth, imageHeight);
 }
 
 } // namespace blink