Add support for the object-fit CSS property.

Source/core/rendering/RenderImage.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
  *
@@ skipping 178 matching lines @@
 bool RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize, bool imageSizeChanged)
 {
     if (newSize == intrinsicSize() && !imageSizeChanged)
         return false;
     if (m_imageResource->errorOccurred() || !m_imageResource->hasImage())
         return imageSizeChanged;
     setIntrinsicSize(newSize);
     return true;
 }
 
+void RenderImage::updateInnerContentRect()
+{
+    // Propagate container size to image resource.
+    LayoutRect paintRect = replacedContentRect();
+    IntSize containerSize(paintRect.width(), paintRect.height());
+    if (!containerSize.isEmpty())
+        m_imageResource->setContainerSizeForRenderer(containerSize);
+}
+
 void RenderImage::imageDimensionsChanged(bool imageSizeChanged, const IntRect* rect)
 {
-    bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(m_imageResource->imageSize(style()->effectiveZoom()), imageSizeChanged);
+    bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(m_imageResource->intrinsicSize(style()->effectiveZoom()), imageSizeChanged);
 
     // In the case of generated image content using :before/:after/content, we might not be
     // in the render tree yet. In that case, we just need to update our intrinsic size.
     // layout() will be called after we are inserted in the tree which will take care of
     // what we are doing here.
     if (!containingBlock())
         return;
 
     bool shouldRepaint = true;
     if (intrinsicSizeChanged) {
@@ skipping 17 matching lines @@
         bool containingBlockNeedsToRecomputePreferredSize =
             style()->logicalWidth().isPercent()
             || style()->logicalMaxWidth().isPercent()
             || style()->logicalMinWidth().isPercent();
 
         if (imageSizeChanged || hasOverrideSize || containingBlockNeedsToRecomputePreferredSize) {
             shouldRepaint = false;
             if (!selfNeedsLayout())
                 setNeedsLayout(true);
         }
+
+        if (everHadLayout() && !selfNeedsLayout()) {
+            // The inner content rectangle is calculated during layout, but may need an update now
+            // (unless the box has already been scheduled for layout). In order to calculate it, we
+            // may need values from the containing block, though, so make sure that we're not too
+            // early. It may be that layout hasn't even taken place once yet.
+            updateInnerContentRect();
+        }
     }
 
     if (shouldRepaint) {
         LayoutRect repaintRect;
         if (rect) {
             // The image changed rect is in source image coordinates (pre-zooming),
             // so map from the bounds of the image to the contentsBox.
             repaintRect = enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), m_imageResource->imageSize(1.0f)), contentBoxRect()));
             // Guard against too-large changed rects.
             repaintRect.intersect(contentBoxRect());
@@ skipping 107 matching lines @@
             }
         }
     } else if (m_imageResource->hasImage() && cWidth > 0 && cHeight > 0) {
         RefPtr<Image> img = m_imageResource->image(cWidth, cHeight);
         if (!img || img->isNull()) {
             if (page && paintInfo.phase == PaintPhaseForeground)
                 page->addRelevantUnpaintedObject(this, visualOverflowRect());
             return;
         }
 
-        LayoutSize contentSize(cWidth, cHeight);
-        LayoutPoint contentLocation = paintOffset;
-        contentLocation.move(leftBorder + leftPad, topBorder + topPad);
-        paintIntoRect(context, LayoutRect(contentLocation, contentSize));
+        LayoutRect contentRect = contentBoxRect();
+        contentRect.moveBy(paintOffset);
+        LayoutRect paintRect = replacedContentRect();
+        paintRect.moveBy(paintOffset);
+        bool clip = !contentRect.contains(paintRect);
+        if (clip) {
+            context->save();
+            context->clip(contentRect);
+        }
+
+        paintIntoRect(context, paintRect);

[pdr., 2013/08/09 23:39:22]

In general, we try to avoid clipping because it's quite expensive for software
rasterizers.

In this case, paintIntoRect ends up calling context->drawImage which takes a
source and dest rect. Can you plumb this through instead of clipping?

[mstensho (USE GERRIT), 2013/08/12 13:39:11]

Done.

Please take a look at what I did. I was considering adding a paint offset
LayoutPoint parameter (and untranslated rectangle(s)), but decided against it in
the end, and instead used what paintReplaced() (and the other caller in
RenderVideo) calculates right away. That may be a bit more convoluted.
Especially the "srcRect.moveBy(-paintRect.location())" thing may cause some
eyebrow-raising. Not sure.

If we let paintIntoRect() take a LayoutPoint offset + an untranslated paint
rectangle instead, we could consider letting paintIntoRect() calculate the
content rectangle on its own.

My current solution results in fewer code lines and calculations, since it is
slightly more coupled against what paintReplaced() already calculates.

 
         if (cachedImage() && page && paintInfo.phase == PaintPhaseForeground) {
             // For now, count images as unpainted if they are still progressively loading. We may want
             // to refine this in the future to account for the portion of the image that has painted.
+            LayoutRect visibleRect = intersection(paintRect, contentRect);
             if (cachedImage()->isLoading())
-                page->addRelevantUnpaintedObject(this, LayoutRect(contentLocation, contentSize));
+                page->addRelevantUnpaintedObject(this, visibleRect);
             else
-                page->addRelevantRepaintedObject(this, LayoutRect(contentLocation, contentSize));
+                page->addRelevantRepaintedObject(this, visibleRect);
         }
+
+        if (clip)
+            context->restore();
     }
 }
 
 void RenderImage::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     RenderReplaced::paint(paintInfo, paintOffset);
 
     if (paintInfo.phase == PaintPhaseOutline)
         paintAreaElementFocusRing(paintInfo);
 }
@@ skipping 89 matching lines @@
         return false;
     if (!contentBoxRect().contains(localRect))
         return false;
     EFillBox backgroundClip = style()->backgroundClip();
     // Background paints under borders.
     if (backgroundClip == BorderFillBox && style()->hasBorder() && !borderObscuresBackground())
         return false;
     // Background shows in padding area.
     if ((backgroundClip == BorderFillBox || backgroundClip == PaddingFillBox) && style()->hasPadding())
         return false;
+    // Object-fit may leave parts of the content box empty.
+    EObjectFit objectFit = style()->objectFit();
+    if (objectFit != ObjectFitFill && objectFit != ObjectFitCover)
+        return false;
     // Check for image with alpha.
     return m_imageResource->cachedImage() && m_imageResource->cachedImage()->currentFrameKnownToBeOpaque(this);
 }
 
 bool RenderImage::computeBackgroundIsKnownToBeObscured()
 {
     if (!hasBackground())
         return false;
     return foregroundIsKnownToBeOpaqueInRect(backgroundPaintedExtent(), 0);
 }
@@ skipping 41 matching lines @@
     if (node()->hasTagName(inputTag))
         m_altText = toHTMLInputElement(node())->altText();
     else if (node()->hasTagName(imgTag))
         m_altText = toHTMLImageElement(node())->altText();
 }
 
 void RenderImage::layout()
 {
     StackStats::LayoutCheckPoint layoutCheckPoint;
     RenderReplaced::layout();
-
-    // Propagate container size to image resource.
-    IntSize containerSize(contentWidth(), contentHeight());
-    if (!containerSize.isEmpty())
-        m_imageResource->setContainerSizeForRenderer(containerSize);
+    updateInnerContentRect();
 }
 
 void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const
 {
     RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio, isPercentageIntrinsicSize);
 
     // Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.
     if (intrinsicSize.isEmpty() && (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight())) {
         RenderObject* containingBlock = isOutOfFlowPositioned() ? container() : this->containingBlock();
         if (containingBlock->isBox()) {
@@ skipping 22 matching lines @@
         return 0;
 
     CachedImage* cachedImage = m_imageResource->cachedImage();
     if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
         return static_cast<SVGImage*>(cachedImage->image())->embeddedContentBox();
 
     return 0;
 }
 
 } // namespace WebCore