Use srcset's resource pixel density to determine intrinsic size

Source/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 1189 matching lines @@
     } else {
         c->clearShadow();
     }
 }
 
 bool CanvasRenderingContext2D::shouldDrawShadows() const
 {
     return alphaChannel(state().m_shadowColor) && (state().m_shadowBlur || !state().m_shadowOffset.isZero());
 }
 
-static LayoutSize sizeFor(HTMLImageElement* image)
+enum ImageSizeType {
+    ScaledSize,
+    UnscaledSize
+};
+
+static LayoutSize sizeFor(HTMLImageElement* image, ImageSizeType sizeType)

[pdr., 2013/10/11 05:17:33]

Can you help me understand why this is needed?

I thought canvas could only access the image size without the scale factor.
For example:
<img srcset="100x100.png 2x">

ctx.drawImage(img, 0, 0) should render at 50x50
and
ctx.drawImage(img, 0, 0, 100, 100) should render the original image (without
upscaling) at 100x100
and
ctx.drawImage(img, 0, 0, 1000, 1000) should render the original image upscaled
to 1000x1000

[Yoav Weiss, 2013/10/11 07:22:32]

For what I've seen, drawImage calls sizeFor 3 times:
* In CanvasRenderingContext2D:1376 it is called to determine the destination
canvas size. That size should be scaled (so 50x50 as you said for
ctx.drawImage(img, 0, 0))
* In CanvasRenderingContext2D:1387 it is called to determine the source image
size. Giving it scaled dimensions here resorts in only a quarter of the image
drawn.
* In CanvasRenderingContext2D:1418 it is called to determine the image
dimensions for clipping purposes. Giving scaled image dimensions here results in
image distortion.

 {
-    if (ImageResource* cachedImage = image->cachedImage())
-        return cachedImage->imageSizeForRenderer(image->renderer(), 1.0f); // FIXME: Not sure about this.
-    return IntSize();
+    LayoutSize size;
+    ImageResource* cachedImage = image->cachedImage();
+    if (cachedImage) {
+        size = cachedImage->imageSizeForRenderer(image->renderer(), 1.0f); // FIXME: Not sure about this.
+
+        if (sizeType == ScaledSize && image->renderer() && cachedImage->image() && !cachedImage->image()->hasRelativeWidth())
+            size.scale(image->renderer()->intrinsicSizeFactor());
+    }
+    return size;
 }
 
 static IntSize sizeFor(HTMLVideoElement* video)
 {
     if (MediaPlayer* player = video->player())
         return player->naturalSize();
     return IntSize();
 }
 
 static inline FloatRect normalizeRect(const FloatRect& rect)
@@ skipping 130 matching lines @@
 
     drawImageInternal(imageForRendering.get(), actualSrcRect, actualDstRect, state().m_globalComposite, state().m_globalBlend);
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y, ExceptionState& es)
 {
     if (!image) {
         es.throwUninformativeAndGenericDOMException(TypeMismatchError);
         return;
     }
-    LayoutSize size = sizeFor(image);
+    LayoutSize size = sizeFor(image, ScaledSize);
     drawImage(image, x, y, size.width(), size.height(), es);
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image,
     float x, float y, float width, float height, ExceptionState& es)
 {
     if (!image) {
         es.throwUninformativeAndGenericDOMException(TypeMismatchError);
         return;
     }
-    LayoutSize size = sizeFor(image);
+    LayoutSize size = sizeFor(image, UnscaledSize);
     drawImage(image, FloatRect(0, 0, size.width(), size.height()), FloatRect(x, y, width, height), es);
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& es)
 {
     drawImage(image, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), es);
 }
 
@@ skipping 10 matching lines @@
     }
 
     if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height())
         || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height()))
         return;
 
     ImageResource* cachedImage = image->cachedImage();
     if (!cachedImage || !image->complete())
         return;
 
-    LayoutSize size = sizeFor(image);
+    LayoutSize size = sizeFor(image, UnscaledSize);
     if (!size.width() || !size.height()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
     if (!dstRect.width() || !dstRect.height())
         return;
 
     FloatRect normalizedSrcRect = normalizeRect(srcRect);
     FloatRect normalizedDstRect = normalizeRect(dstRect);
@@ skipping 996 matching lines @@
     const int focusRingWidth = 5;
     const int focusRingOutline = 0;
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
 
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore