Use Shadow DOM to display fallback content for images

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 41 matching lines @@
 namespace blink {
 
 using namespace HTMLNames;
 
 RenderImage::RenderImage(Element* element)
     : RenderReplaced(element, LayoutSize())
     , m_didIncrementVisuallyNonEmptyPixelCount(false)
     , m_isGeneratedContent(false)
     , m_imageDevicePixelRatio(1.0f)
 {
-    updateAltText();
     ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addRenderObject(this);
 }
 
 RenderImage* RenderImage::createAnonymous(Document* document)
 {
     RenderImage* image = new RenderImage(0);
     image->setDocumentForAnonymous(document);
     return image;
 }
 
 RenderImage::~RenderImage()
 {
 }
 
 void RenderImage::destroy()
 {
     ASSERT(m_imageResource);
     m_imageResource->shutdown();
     RenderReplaced::destroy();
 }
 
 void RenderImage::setImageResource(PassOwnPtr<RenderImageResource> imageResource)
 {
     ASSERT(!m_imageResource);
     m_imageResource = imageResource;
     m_imageResource->initialize(this);
 }
 
-// Alt text is restricted to this maximum size, in pixels.  These are
-// signed integers because they are compared with other signed values.
-static const float maxAltTextWidth = 1024;
-static const int maxAltTextHeight = 256;
-
-IntSize RenderImage::imageSizeForError(ImageResource* newImage) const
-{
-    ASSERT_ARG(newImage, newImage);
-    ASSERT_ARG(newImage, newImage->imageForRenderer(this));
-
-    IntSize imageSize;
-    if (newImage->willPaintBrokenImage()) {
-        float deviceScaleFactor = blink::deviceScaleFactor(frame());
-        pair<Image*, float> brokenImageAndImageScaleFactor = ImageResource::brokenImage(deviceScaleFactor);
-        imageSize = brokenImageAndImageScaleFactor.first->size();
-        imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
-    } else {
-        imageSize = newImage->imageForRenderer(this)->size();
-    }
-
-    // imageSize() returns 0 for the error image. We need the true size of the
-    // error image, so we have to get it by grabbing image() directly.
-    return IntSize(paddingWidth + imageSize.width() * style()->effectiveZoom(), paddingHeight + imageSize.height() * style()->effectiveZoom());
-}
-
-// Sets the image height and width to fit the alt text.  Returns true if the
-// image size changed.
-bool RenderImage::setImageSizeForAltText(ImageResource* newImage /* = 0 */)
-{
-    LayoutSize imageSize;
-    if (newImage && newImage->imageForRenderer(this)) {
-        imageSize = LayoutSize(imageSizeForError(newImage));
-    } else if (!m_altText.isEmpty() || newImage) {
-        // If we'll be displaying either text or an image, add a little padding.
-        imageSize = LayoutSize(paddingWidth, paddingHeight);
-    }
-
-    // we have an alt and the user meant it (its not a text we invented)
-    if (!m_altText.isEmpty()) {
-        FontCachePurgePreventer fontCachePurgePreventer;
-
-        const Font& font = style()->font();
-        LayoutSize paddedTextSize(paddingWidth + std::min(ceilf(font.width(constructTextRun(this, font, m_altText, style()))), maxAltTextWidth), paddingHeight + std::min(font.fontMetrics().height(), maxAltTextHeight));
-        imageSize = imageSize.expandedTo(paddedTextSize);
-    }
-
-    if (imageSize == intrinsicSize())
-        return false;
-
-    setIntrinsicSize(imageSize);
-    return true;
-}
-
 void RenderImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
 {
     if (documentBeingDestroyed())
         return;
 
     if (hasBoxDecorationBackground() || hasMask() || hasShapeOutside())
         RenderReplaced::imageChanged(newImage, rect);
 
     if (!m_imageResource)
         return;
 
     if (newImage != m_imageResource->imagePtr())
         return;
 
     // Per the spec, we let the server-sent header override srcset/other sources of dpr.
     // https://github.com/igrigorik/http-client-hints/blob/master/draft-grigorik-http-client-hints-01.txt#L255
     if (m_imageResource->cachedImage() && m_imageResource->cachedImage()->hasDevicePixelRatioHeaderValue())
         m_imageDevicePixelRatio = 1 / m_imageResource->cachedImage()->devicePixelRatioHeaderValue();
 
     if (!m_didIncrementVisuallyNonEmptyPixelCount) {
         // At a zoom level of 1 the image is guaranteed to have an integer size.
         view()->frameView()->incrementVisuallyNonEmptyPixelCount(flooredIntSize(m_imageResource->imageSize(1.0f)));
         m_didIncrementVisuallyNonEmptyPixelCount = true;
     }
 
-    bool imageSizeChanged = false;
-
-    // Set image dimensions, taking into account the size of the alt text.
-    if (m_imageResource->errorOccurred() || !newImage)
-        imageSizeChanged = setImageSizeForAltText(m_imageResource->cachedImage());
-
-    paintInvalidationOrMarkForLayout(imageSizeChanged, rect);
+    repaintOrMarkForLayout(rect);
 }
 
 void RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
 {
     if (m_imageResource->errorOccurred() || !m_imageResource->hasImage())
         return;
     setIntrinsicSize(newSize);
 }
 
 void RenderImage::updateInnerContentRect()
 {
     // Propagate container size to the image resource.
     LayoutRect containerRect = replacedContentRect();
     IntSize containerSize(containerRect.width(), containerRect.height());
     if (!containerSize.isEmpty())
         m_imageResource->setContainerSizeForRenderer(containerSize);
 }
 
-void RenderImage::paintInvalidationOrMarkForLayout(bool imageSizeChangedToAccomodateAltText, const IntRect* rect)
+void RenderImage::repaintOrMarkForLayout(const IntRect* rect)
 {
     LayoutSize oldIntrinsicSize = intrinsicSize();
     LayoutSize newIntrinsicSize = m_imageResource->intrinsicSize(style()->effectiveZoom());
     updateIntrinsicSizeIfNeeded(newIntrinsicSize);
 
     // 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 imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize || imageSizeChangedToAccomodateAltText;
+    bool imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize;
     if (imageSourceHasChangedSize)
         setPreferredLogicalWidthsDirty();
 
     // If the actual area occupied by the image has changed and it is not constrained by style then a layout is required.
     bool imageSizeIsConstrained = style()->logicalWidth().isSpecified() && style()->logicalHeight().isSpecified();
 
     // FIXME: We only need to recompute the containing block's preferred size if the containing block's size
     // depends on the image's size (i.e., the container uses shrink-to-fit sizing).
     // There's no easy way to detect that shrink-to-fit is needed, always force a layout.
     bool containingBlockNeedsToRecomputePreferredSize = style()->logicalWidth().isPercent() || style()->logicalMaxWidth().isPercent()  || style()->logicalMinWidth().isPercent();
@@ skipping 70 matching lines @@
     if (path.isEmpty())
         return;
 
     RenderStyle* areaElementStyle = areaElement->computedStyle();
     unsigned short outlineWidth = areaElementStyle->outlineWidth();
 
     IntRect paintInvalidationRect = enclosingIntRect(path.boundingRect());
     paintInvalidationRect.moveBy(-IntPoint(absoluteContentBoxOffset()));
     paintInvalidationRect.inflate(outlineWidth);
 
-    paintInvalidationOrMarkForLayout(false, &paintInvalidationRect);
+    repaintOrMarkForLayout(&paintInvalidationRect);
 }
 
 bool RenderImage::boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance bleedAvoidance, InlineFlowBox*) const
 {
     if (!RenderBoxModelObject::boxShadowShouldBeAppliedToBackground(bleedAvoidance))
         return false;
 
     return !const_cast<RenderImage*>(this)->boxDecorationBackgroundIsKnownToBeObscured();
 }
 
@@ skipping 62 matching lines @@
         }
     }
 
     if (!inside && result.isRectBasedTest())
         result.append(tempResult);
     if (inside)
         result = tempResult;
     return inside;
 }
 
-void RenderImage::updateAltText()
-{
-    if (!node())
-        return;
-
-    if (isHTMLInputElement(*node()))
-        m_altText = toHTMLInputElement(node())->altText();
-    else if (isHTMLImageElement(*node()))
-        m_altText = toHTMLImageElement(node())->altText();
-}
-
 void RenderImage::layout()
 {
     RenderReplaced::layout();
     updateInnerContentRect();
 }
 
 bool RenderImage::updateImageLoadingPriorities()
 {
     if (!m_imageResource || !m_imageResource->cachedImage() || m_imageResource->cachedImage()->isLoaded())
         return false;
@@ skipping 57 matching lines @@
         return 0;
 
     ImageResource* cachedImage = m_imageResource->cachedImage();
     if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
         return toSVGImage(cachedImage->image())->embeddedContentBox();
 
     return 0;
 }
 
 } // namespace blink