281ff865c4ef0f4c00d774f6b303e2e6f7df5126
[WebKit-https.git] / Source / WebCore / rendering / RenderImage.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  *           (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com)
6  *           (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
7  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
8  * Copyright (C) 2010 Google Inc. All rights reserved.
9  * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  *
26  */
27
28 #include "config.h"
29 #include "RenderImage.h"
30
31 #include "BitmapImage.h"
32 #include "CachedImage.h"
33 #include "FocusController.h"
34 #include "FontCache.h"
35 #include "FontCascade.h"
36 #include "Frame.h"
37 #include "FrameSelection.h"
38 #include "GeometryUtilities.h"
39 #include "GraphicsContext.h"
40 #include "HTMLAreaElement.h"
41 #include "HTMLImageElement.h"
42 #include "HTMLInputElement.h"
43 #include "HTMLMapElement.h"
44 #include "HTMLNames.h"
45 #include "HitTestResult.h"
46 #include "InlineElementBox.h"
47 #include "Page.h"
48 #include "PaintInfo.h"
49 #include "RenderFlowThread.h"
50 #include "RenderImageResourceStyleImage.h"
51 #include "RenderView.h"
52 #include "SVGImage.h"
53 #include <wtf/StackStats.h>
54
55 #if PLATFORM(IOS)
56 #include "LogicalSelectionOffsetCaches.h"
57 #include "SelectionRect.h"
58 #endif
59
60 namespace WebCore {
61
62 #if PLATFORM(IOS)
63 // FIXME: This doesn't behave correctly for floating or positioned images, but WebCore doesn't handle those well
64 // during selection creation yet anyway.
65 // FIXME: We can't tell whether or not we contain the start or end of the selected Range using only the offsets
66 // of the start and end, we need to know the whole Position.
67 void RenderImage::collectSelectionRects(Vector<SelectionRect>& rects, unsigned, unsigned)
68 {
69     RenderBlock* containingBlock = this->containingBlock();
70
71     IntRect imageRect;
72     // FIXME: It doesn't make sense to package line bounds into SelectionRects. We should find
73     // the right and left extent of the selection once for the entire selected Range, perhaps
74     // using the Range's common ancestor.
75     IntRect lineExtentRect;
76     bool isFirstOnLine = false;
77     bool isLastOnLine = false;
78
79     InlineBox* inlineBox = inlineBoxWrapper();
80     if (!inlineBox) {
81         // This is a block image.
82         imageRect = IntRect(0, 0, width(), height());
83         isFirstOnLine = true;
84         isLastOnLine = true;
85         lineExtentRect = imageRect;
86         if (containingBlock->isHorizontalWritingMode()) {
87             lineExtentRect.setX(containingBlock->x());
88             lineExtentRect.setWidth(containingBlock->width());
89         } else {
90             lineExtentRect.setY(containingBlock->y());
91             lineExtentRect.setHeight(containingBlock->height());
92         }
93     } else {
94         LayoutUnit selectionTop = !containingBlock->style().isFlippedBlocksWritingMode() ? inlineBox->root().selectionTop() - logicalTop() : logicalBottom() - inlineBox->root().selectionBottom();
95         imageRect = IntRect(0,  selectionTop, logicalWidth(), inlineBox->root().selectionHeight());
96         isFirstOnLine = !inlineBox->previousOnLineExists();
97         isLastOnLine = !inlineBox->nextOnLineExists();
98         LogicalSelectionOffsetCaches cache(*containingBlock);
99         LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
100         LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
101         lineExtentRect = IntRect(leftOffset - logicalLeft(), imageRect.y(), rightOffset - leftOffset, imageRect.height());
102         if (!inlineBox->isHorizontal()) {
103             imageRect = imageRect.transposedRect();
104             lineExtentRect = lineExtentRect.transposedRect();
105         }
106     }
107
108     bool isFixed = false;
109     IntRect absoluteBounds = localToAbsoluteQuad(FloatRect(imageRect), UseTransforms, &isFixed).enclosingBoundingBox();
110     IntRect lineExtentBounds = localToAbsoluteQuad(FloatRect(lineExtentRect)).enclosingBoundingBox();
111     if (!containingBlock->isHorizontalWritingMode())
112         lineExtentBounds = lineExtentBounds.transposedRect();
113
114     // FIXME: We should consider either making SelectionRect a struct or better organize its optional fields into
115     // an auxiliary struct to simplify its initialization.
116     rects.append(SelectionRect(absoluteBounds, containingBlock->style().direction(), lineExtentBounds.x(), lineExtentBounds.maxX(), lineExtentBounds.maxY(), 0, false /* line break */, isFirstOnLine, isLastOnLine, false /* contains start */, false /* contains end */, containingBlock->style().isHorizontalWritingMode(), isFixed, false /* ruby text */, view().pageNumberForBlockProgressionOffset(absoluteBounds.x())));
117 }
118 #endif
119
120 using namespace HTMLNames;
121
122 RenderImage::RenderImage(Element& element, RenderStyle&& style, StyleImage* styleImage, const float imageDevicePixelRatio)
123     : RenderReplaced(element, WTFMove(style), IntSize())
124     , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
125     , m_imageDevicePixelRatio(imageDevicePixelRatio)
126 {
127     updateAltText();
128     imageResource().initialize(this);
129     if (is<HTMLImageElement>(element))
130         m_hasShadowControls = downcast<HTMLImageElement>(element).hasShadowControls();
131 }
132
133 RenderImage::RenderImage(Document& document, RenderStyle&& style, StyleImage* styleImage)
134     : RenderReplaced(document, WTFMove(style), IntSize())
135     , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
136 {
137     imageResource().initialize(this);
138 }
139
140 RenderImage::~RenderImage()
141 {
142     imageResource().shutdown();
143 }
144
145 // If we'll be displaying either alt text or an image, add some padding.
146 static const unsigned short paddingWidth = 4;
147 static const unsigned short paddingHeight = 4;
148
149 // Alt text is restricted to this maximum size, in pixels.  These are
150 // signed integers because they are compared with other signed values.
151 static const float maxAltTextWidth = 1024;
152 static const int maxAltTextHeight = 256;
153
154 IntSize RenderImage::imageSizeForError(CachedImage* newImage) const
155 {
156     ASSERT_ARG(newImage, newImage);
157     ASSERT_ARG(newImage, newImage->imageForRenderer(this));
158
159     FloatSize imageSize;
160     if (newImage->willPaintBrokenImage()) {
161         std::pair<Image*, float> brokenImageAndImageScaleFactor = newImage->brokenImage(document().deviceScaleFactor());
162         imageSize = brokenImageAndImageScaleFactor.first->size();
163         imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
164     } else
165         imageSize = newImage->imageForRenderer(this)->size();
166
167     // imageSize() returns 0 for the error image. We need the true size of the
168     // error image, so we have to get it by grabbing image() directly.
169     return IntSize(paddingWidth + imageSize.width() * style().effectiveZoom(), paddingHeight + imageSize.height() * style().effectiveZoom());
170 }
171
172 // Sets the image height and width to fit the alt text.  Returns true if the
173 // image size changed.
174 ImageSizeChangeType RenderImage::setImageSizeForAltText(CachedImage* newImage /* = 0 */)
175 {
176     IntSize imageSize;
177     if (newImage && newImage->imageForRenderer(this))
178         imageSize = imageSizeForError(newImage);
179     else if (!m_altText.isEmpty() || newImage) {
180         // If we'll be displaying either text or an image, add a little padding.
181         imageSize = IntSize(paddingWidth, paddingHeight);
182     }
183
184     // we have an alt and the user meant it (its not a text we invented)
185     if (!m_altText.isEmpty()) {
186         const FontCascade& font = style().fontCascade();
187         IntSize paddedTextSize(paddingWidth + std::min(ceilf(font.width(RenderBlock::constructTextRun(m_altText, style()))), maxAltTextWidth), paddingHeight + std::min(font.fontMetrics().height(), maxAltTextHeight));
188         imageSize = imageSize.expandedTo(paddedTextSize);
189     }
190
191     if (imageSize == intrinsicSize())
192         return ImageSizeChangeNone;
193
194     setIntrinsicSize(imageSize);
195     return ImageSizeChangeForAltText;
196 }
197
198 void RenderImage::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
199 {
200     RenderReplaced::styleDidChange(diff, oldStyle);
201     if (m_needsToSetSizeForAltText) {
202         if (!m_altText.isEmpty() && setImageSizeForAltText(imageResource().cachedImage()))
203             repaintOrMarkForLayout(ImageSizeChangeForAltText);
204         m_needsToSetSizeForAltText = false;
205     }
206 #if ENABLE(CSS_IMAGE_ORIENTATION)
207     if (diff == StyleDifferenceLayout && oldStyle->imageOrientation() != style().imageOrientation())
208         return repaintOrMarkForLayout(ImageSizeChangeNone);
209 #endif
210
211 #if ENABLE(CSS_IMAGE_RESOLUTION)
212     if (diff == StyleDifferenceLayout
213         && (oldStyle->imageResolution() != style().imageResolution()
214             || oldStyle->imageResolutionSnap() != style().imageResolutionSnap()
215             || oldStyle->imageResolutionSource() != style().imageResolutionSource()))
216         repaintOrMarkForLayout(ImageSizeChangeNone);
217 #endif
218 }
219
220 void RenderImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
221 {
222     // FIXME (86669): Instead of the RenderImage determining whether its document is in the page
223     // cache, the RenderImage should remove itself as a client when its document is put into the
224     // page cache.
225     if (documentBeingDestroyed() || document().inPageCache())
226         return;
227
228     if (hasVisibleBoxDecorations() || hasMask() || hasShapeOutside())
229         RenderReplaced::imageChanged(newImage, rect);
230
231     if (newImage != imageResource().imagePtr() || !newImage)
232         return;
233     
234     if (!m_didIncrementVisuallyNonEmptyPixelCount) {
235         // At a zoom level of 1 the image is guaranteed to have an integer size.
236         view().frameView().incrementVisuallyNonEmptyPixelCount(flooredIntSize(imageResource().imageSize(1.0f)));
237         m_didIncrementVisuallyNonEmptyPixelCount = true;
238     }
239
240     ImageSizeChangeType imageSizeChange = ImageSizeChangeNone;
241
242     // Set image dimensions, taking into account the size of the alt text.
243     if (imageResource().errorOccurred()) {
244         if (!m_altText.isEmpty() && document().hasPendingStyleRecalc()) {
245             ASSERT(element());
246             if (element()) {
247                 m_needsToSetSizeForAltText = true;
248                 element()->setNeedsStyleRecalc(SyntheticStyleChange);
249             }
250             return;
251         }
252         imageSizeChange = setImageSizeForAltText(imageResource().cachedImage());
253     }
254
255     repaintOrMarkForLayout(imageSizeChange, rect);
256 }
257
258 void RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
259 {
260     if (imageResource().errorOccurred() || !m_imageResource->hasImage())
261         return;
262     setIntrinsicSize(newSize);
263 }
264
265 void RenderImage::updateInnerContentRect()
266 {
267     // Propagate container size to image resource.
268     IntSize containerSize(replacedContentRect(intrinsicSize()).size());
269     if (!containerSize.isEmpty())
270         imageResource().setContainerSizeForRenderer(containerSize);
271 }
272
273 void RenderImage::repaintOrMarkForLayout(ImageSizeChangeType imageSizeChange, const IntRect* rect)
274 {
275 #if ENABLE(CSS_IMAGE_RESOLUTION)
276     double scale = style().imageResolution();
277     if (style().imageResolutionSnap() == ImageResolutionSnapPixels)
278         scale = roundForImpreciseConversion<int>(scale);
279     if (scale <= 0)
280         scale = 1;
281     LayoutSize newIntrinsicSize = imageResource().intrinsicSize(style().effectiveZoom() / scale);
282 #else
283     LayoutSize newIntrinsicSize = imageResource().intrinsicSize(style().effectiveZoom());
284 #endif
285     LayoutSize oldIntrinsicSize = intrinsicSize();
286
287     updateIntrinsicSizeIfNeeded(newIntrinsicSize);
288
289     // In the case of generated image content using :before/:after/content, we might not be
290     // in the render tree yet. In that case, we just need to update our intrinsic size.
291     // layout() will be called after we are inserted in the tree which will take care of
292     // what we are doing here.
293     if (!containingBlock())
294         return;
295
296     bool imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize || imageSizeChange != ImageSizeChangeNone;
297
298     if (imageSourceHasChangedSize && setNeedsLayoutIfNeededAfterIntrinsicSizeChange())
299         return;
300
301     if (everHadLayout() && !selfNeedsLayout()) {
302         // The inner content rectangle is calculated during layout, but may need an update now
303         // (unless the box has already been scheduled for layout). In order to calculate it, we
304         // may need values from the containing block, though, so make sure that we're not too
305         // early. It may be that layout hasn't even taken place once yet.
306
307         // FIXME: we should not have to trigger another call to setContainerSizeForRenderer()
308         // from here, since it's already being done during layout.
309         updateInnerContentRect();
310     }
311
312     LayoutRect repaintRect = contentBoxRect();
313     if (rect) {
314         // The image changed rect is in source image coordinates (pre-zooming),
315         // so map from the bounds of the image to the contentsBox.
316         repaintRect.intersect(enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), imageResource().imageSize(1.0f)), repaintRect)));
317     }
318         
319     repaintRectangle(repaintRect);
320
321     // Tell any potential compositing layers that the image needs updating.
322     contentChanged(ImageChanged);
323 }
324
325 void RenderImage::notifyFinished(CachedResource* newImage)
326 {
327     if (documentBeingDestroyed())
328         return;
329
330     invalidateBackgroundObscurationStatus();
331
332     if (newImage == imageResource().cachedImage()) {
333         // tell any potential compositing layers
334         // that the image is done and they can reference it directly.
335         contentChanged(ImageChanged);
336     }
337 }
338
339 void RenderImage::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
340 {
341     LayoutUnit cWidth = contentWidth();
342     LayoutUnit cHeight = contentHeight();
343     LayoutUnit leftBorder = borderLeft();
344     LayoutUnit topBorder = borderTop();
345     LayoutUnit leftPad = paddingLeft();
346     LayoutUnit topPad = paddingTop();
347
348     GraphicsContext& context = paintInfo.context();
349     float deviceScaleFactor = document().deviceScaleFactor();
350
351     Page* page = frame().page();
352
353     if (!imageResource().hasImage() || imageResource().errorOccurred()) {
354         if (paintInfo.phase == PaintPhaseSelection)
355             return;
356
357         if (page && paintInfo.phase == PaintPhaseForeground)
358             page->addRelevantUnpaintedObject(this, visualOverflowRect());
359
360         if (cWidth > 2 && cHeight > 2) {
361             LayoutUnit borderWidth = LayoutUnit(1 / deviceScaleFactor);
362
363             // Draw an outline rect where the image should be.
364             context.setStrokeStyle(SolidStroke);
365             context.setStrokeColor(Color::lightGray);
366             context.setFillColor(Color::transparent);
367             context.drawRect(snapRectToDevicePixels(LayoutRect(paintOffset.x() + leftBorder + leftPad, paintOffset.y() + topBorder + topPad, cWidth, cHeight), deviceScaleFactor), borderWidth);
368
369             bool errorPictureDrawn = false;
370             LayoutSize imageOffset;
371             // When calculating the usable dimensions, exclude the pixels of
372             // the ouline rect so the error image/alt text doesn't draw on it.
373             LayoutUnit usableWidth = cWidth - 2 * borderWidth;
374             LayoutUnit usableHeight = cHeight - 2 * borderWidth;
375
376             RefPtr<Image> image = imageResource().image();
377
378             if (imageResource().errorOccurred() && !image->isNull() && usableWidth >= image->width() && usableHeight >= image->height()) {
379                 // Call brokenImage() explicitly to ensure we get the broken image icon at the appropriate resolution.
380                 std::pair<Image*, float> brokenImageAndImageScaleFactor = imageResource().cachedImage()->brokenImage(document().deviceScaleFactor());
381                 image = brokenImageAndImageScaleFactor.first;
382                 FloatSize imageSize = image->size();
383                 imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
384                 // Center the error image, accounting for border and padding.
385                 LayoutUnit centerX = (usableWidth - imageSize.width()) / 2;
386                 if (centerX < 0)
387                     centerX = 0;
388                 LayoutUnit centerY = (usableHeight - imageSize.height()) / 2;
389                 if (centerY < 0)
390                     centerY = 0;
391                 imageOffset = LayoutSize(leftBorder + leftPad + centerX + borderWidth, topBorder + topPad + centerY + borderWidth);
392
393                 ImageOrientationDescription orientationDescription(shouldRespectImageOrientation());
394 #if ENABLE(CSS_IMAGE_ORIENTATION)
395                 orientationDescription.setImageOrientationEnum(style().imageOrientation());
396 #endif
397                 context.drawImage(*image, snapRectToDevicePixels(LayoutRect(paintOffset + imageOffset, imageSize), deviceScaleFactor), orientationDescription);
398                 errorPictureDrawn = true;
399             }
400
401             if (!m_altText.isEmpty()) {
402                 String text = document().displayStringModifiedByEncoding(m_altText);
403                 context.setFillColor(style().visitedDependentColor(CSSPropertyColor));
404                 const FontCascade& font = style().fontCascade();
405                 const FontMetrics& fontMetrics = font.fontMetrics();
406                 LayoutUnit ascent = fontMetrics.ascent();
407                 LayoutPoint altTextOffset = paintOffset;
408                 altTextOffset.move(leftBorder + leftPad + (paddingWidth / 2) - borderWidth, topBorder + topPad + ascent + (paddingHeight / 2) - borderWidth);
409
410                 // Only draw the alt text if it'll fit within the content box,
411                 // and only if it fits above the error image.
412                 TextRun textRun = RenderBlock::constructTextRun(text, style());
413                 LayoutUnit textWidth = font.width(textRun);
414                 if (errorPictureDrawn) {
415                     if (usableWidth >= textWidth && fontMetrics.height() <= imageOffset.height())
416                         context.drawText(font, textRun, altTextOffset);
417                 } else if (usableWidth >= textWidth && usableHeight >= fontMetrics.height())
418                     context.drawText(font, textRun, altTextOffset);
419             }
420         }
421     } else if (imageResource().hasImage() && cWidth > 0 && cHeight > 0) {
422         RefPtr<Image> img = imageResource().image(cWidth, cHeight);
423         if (!img || img->isNull()) {
424             if (page && paintInfo.phase == PaintPhaseForeground)
425                 page->addRelevantUnpaintedObject(this, visualOverflowRect());
426             return;
427         }
428
429         LayoutRect contentBoxRect = this->contentBoxRect();
430         contentBoxRect.moveBy(paintOffset);
431         LayoutRect replacedContentRect = this->replacedContentRect(intrinsicSize());
432         replacedContentRect.moveBy(paintOffset);
433         bool clip = !contentBoxRect.contains(replacedContentRect);
434         GraphicsContextStateSaver stateSaver(context, clip);
435         if (clip)
436             context.clip(contentBoxRect);
437
438         paintIntoRect(context, snapRectToDevicePixels(replacedContentRect, deviceScaleFactor));
439         
440         if (cachedImage() && page && paintInfo.phase == PaintPhaseForeground) {
441             // For now, count images as unpainted if they are still progressively loading. We may want 
442             // to refine this in the future to account for the portion of the image that has painted.
443             LayoutRect visibleRect = intersection(replacedContentRect, contentBoxRect);
444             if (cachedImage()->isLoading())
445                 page->addRelevantUnpaintedObject(this, visibleRect);
446             else
447                 page->addRelevantRepaintedObject(this, visibleRect);
448         }
449     }
450 }
451
452 void RenderImage::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
453 {
454     RenderReplaced::paint(paintInfo, paintOffset);
455     
456     if (paintInfo.phase == PaintPhaseOutline)
457         paintAreaElementFocusRing(paintInfo, paintOffset);
458 }
459     
460 void RenderImage::paintAreaElementFocusRing(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
461 {
462 #if PLATFORM(IOS)
463     UNUSED_PARAM(paintInfo);
464     UNUSED_PARAM(paintOffset);
465 #else
466     if (document().printing() || !frame().selection().isFocusedAndActive())
467         return;
468     
469     if (paintInfo.context().paintingDisabled() && !paintInfo.context().updatingControlTints())
470         return;
471
472     if (!document().page())
473         return;
474
475     Element* focusedElement = document().focusedElement();
476     if (!is<HTMLAreaElement>(focusedElement))
477         return;
478
479     HTMLAreaElement& areaElement = downcast<HTMLAreaElement>(*focusedElement);
480     if (areaElement.imageElement() != element())
481         return;
482
483     auto* areaElementStyle = areaElement.computedStyle();
484     if (!areaElementStyle)
485         return;
486
487     float outlineWidth = areaElementStyle->outlineWidth();
488     if (!outlineWidth)
489         return;
490
491     // Even if the theme handles focus ring drawing for entire elements, it won't do it for
492     // an area within an image, so we don't call RenderTheme::supportsFocusRing here.
493     auto path = areaElement.computePathForFocusRing(size());
494     if (path.isEmpty())
495         return;
496
497     AffineTransform zoomTransform;
498     zoomTransform.scale(style().effectiveZoom());
499     path.transform(zoomTransform);
500
501     auto adjustedOffset = paintOffset;
502     adjustedOffset.moveBy(location());
503     path.translate(toFloatSize(adjustedOffset));
504
505 #if PLATFORM(MAC)
506     bool needsRepaint;
507     paintInfo.context().drawFocusRing(path, document().page()->focusController().timeSinceFocusWasSet(), needsRepaint);
508     if (needsRepaint)
509         document().page()->focusController().setFocusedElementNeedsRepaint();
510 #else
511     paintInfo.context().drawFocusRing(path, outlineWidth, areaElementStyle->outlineOffset(), areaElementStyle->visitedDependentColor(CSSPropertyOutlineColor));
512 #endif
513 #endif
514 }
515
516 void RenderImage::areaElementFocusChanged(HTMLAreaElement* element)
517 {
518     ASSERT_UNUSED(element, element->imageElement() == this->element());
519
520     // It would be more efficient to only repaint the focus ring rectangle
521     // for the passed-in area element. That would require adding functions
522     // to the area element class.
523     repaint();
524 }
525
526 void RenderImage::paintIntoRect(GraphicsContext& context, const FloatRect& rect)
527 {
528     if (!imageResource().hasImage() || imageResource().errorOccurred() || rect.width() <= 0 || rect.height() <= 0)
529         return;
530
531     RefPtr<Image> img = imageResource().image(rect.width(), rect.height());
532     if (!img || img->isNull())
533         return;
534
535     HTMLImageElement* imageElement = is<HTMLImageElement>(element()) ? downcast<HTMLImageElement>(element()) : nullptr;
536     CompositeOperator compositeOperator = imageElement ? imageElement->compositeOperator() : CompositeSourceOver;
537
538     // FIXME: Document when image != img.get().
539     Image* image = imageResource().image().get();
540     InterpolationQuality interpolation = image ? chooseInterpolationQuality(context, *image, image, LayoutSize(rect.size())) : InterpolationDefault;
541
542     ImageOrientationDescription orientationDescription(shouldRespectImageOrientation(), style().imageOrientation());
543     context.drawImage(*img, rect, ImagePaintingOptions(compositeOperator, BlendModeNormal, orientationDescription, interpolation));
544 }
545
546 bool RenderImage::boxShadowShouldBeAppliedToBackground(const LayoutPoint& paintOffset, BackgroundBleedAvoidance bleedAvoidance, InlineFlowBox*) const
547 {
548     if (!RenderBoxModelObject::boxShadowShouldBeAppliedToBackground(paintOffset, bleedAvoidance))
549         return false;
550
551     return !const_cast<RenderImage*>(this)->backgroundIsKnownToBeObscured(paintOffset);
552 }
553
554 bool RenderImage::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
555 {
556     UNUSED_PARAM(maxDepthToTest);
557     if (!imageResource().hasImage() || imageResource().errorOccurred())
558         return false;
559     if (imageResource().cachedImage() && !imageResource().cachedImage()->isLoaded())
560         return false;
561     if (!contentBoxRect().contains(localRect))
562         return false;
563     EFillBox backgroundClip = style().backgroundClip();
564     // Background paints under borders.
565     if (backgroundClip == BorderFillBox && style().hasBorder() && !borderObscuresBackground())
566         return false;
567     // Background shows in padding area.
568     if ((backgroundClip == BorderFillBox || backgroundClip == PaddingFillBox) && style().hasPadding())
569         return false;
570     // Object-fit may leave parts of the content box empty.
571     ObjectFit objectFit = style().objectFit();
572     if (objectFit != ObjectFitFill && objectFit != ObjectFitCover)
573         return false;
574
575     LengthPoint objectPosition = style().objectPosition();
576     if (objectPosition != RenderStyle::initialObjectPosition())
577         return false;
578
579     // Check for image with alpha.
580     return imageResource().cachedImage() && imageResource().cachedImage()->currentFrameKnownToBeOpaque(this);
581 }
582
583 bool RenderImage::computeBackgroundIsKnownToBeObscured(const LayoutPoint& paintOffset)
584 {
585     if (!hasBackground())
586         return false;
587     
588     LayoutRect paintedExtent;
589     if (!getBackgroundPaintedExtent(paintOffset, paintedExtent))
590         return false;
591     return foregroundIsKnownToBeOpaqueInRect(paintedExtent, 0);
592 }
593
594 LayoutUnit RenderImage::minimumReplacedHeight() const
595 {
596     return imageResource().errorOccurred() ? intrinsicSize().height() : LayoutUnit();
597 }
598
599 HTMLMapElement* RenderImage::imageMap() const
600 {
601     HTMLImageElement* image = is<HTMLImageElement>(element()) ? downcast<HTMLImageElement>(element()) : nullptr;
602     return image ? image->treeScope().getImageMap(image->fastGetAttribute(usemapAttr)) : nullptr;
603 }
604
605 bool RenderImage::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
606 {
607     HitTestResult tempResult(result.hitTestLocation());
608     bool inside = RenderReplaced::nodeAtPoint(request, tempResult, locationInContainer, accumulatedOffset, hitTestAction);
609
610     if (tempResult.innerNode() && element()) {
611         if (HTMLMapElement* map = imageMap()) {
612             LayoutRect contentBox = contentBoxRect();
613             float scaleFactor = 1 / style().effectiveZoom();
614             LayoutPoint mapLocation = locationInContainer.point() - toLayoutSize(accumulatedOffset) - locationOffset() - toLayoutSize(contentBox.location());
615             mapLocation.scale(scaleFactor, scaleFactor);
616
617             if (map->mapMouseEvent(mapLocation, contentBox.size(), tempResult))
618                 tempResult.setInnerNonSharedNode(element());
619         }
620     }
621
622     if (!inside && result.isRectBasedTest())
623         result.append(tempResult);
624     if (inside)
625         result = tempResult;
626     return inside;
627 }
628
629 void RenderImage::updateAltText()
630 {
631     if (!element())
632         return;
633
634     if (is<HTMLInputElement>(*element()))
635         m_altText = downcast<HTMLInputElement>(*element()).altText();
636     else if (is<HTMLImageElement>(*element()))
637         m_altText = downcast<HTMLImageElement>(*element()).altText();
638 }
639
640 bool RenderImage::canHaveChildren() const
641 {
642 #if !ENABLE(SERVICE_CONTROLS)
643     return false;
644 #else
645     return m_hasShadowControls;
646 #endif
647 }
648
649 void RenderImage::layout()
650 {
651     StackStats::LayoutCheckPoint layoutCheckPoint;
652
653     LayoutSize oldSize = contentBoxRect().size();
654     RenderReplaced::layout();
655
656     updateInnerContentRect();
657
658     if (m_hasShadowControls)
659         layoutShadowControls(oldSize);
660 }
661
662 void RenderImage::layoutShadowControls(const LayoutSize& oldSize)
663 {
664     auto* controlsRenderer = downcast<RenderBox>(firstChild());
665     if (!controlsRenderer)
666         return;
667     
668     bool controlsNeedLayout = controlsRenderer->needsLayout();
669     // If the region chain has changed we also need to relayout the controls to update the region box info.
670     // FIXME: We can do better once we compute region box info for RenderReplaced, not only for RenderBlock.
671     const RenderFlowThread* flowThread = flowThreadContainingBlock();
672     if (flowThread && !controlsNeedLayout) {
673         if (flowThread->pageLogicalSizeChanged())
674             controlsNeedLayout = true;
675     }
676
677     LayoutSize newSize = contentBoxRect().size();
678     if (newSize == oldSize && !controlsNeedLayout)
679         return;
680
681     // When calling layout() on a child node, a parent must either push a LayoutStateMaintainter, or 
682     // instantiate LayoutStateDisabler. Since using a LayoutStateMaintainer is slightly more efficient,
683     // and this method might be called many times per second during video playback, use a LayoutStateMaintainer:
684     LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
685
686     if (shadowControlsNeedCustomLayoutMetrics()) {
687         controlsRenderer->setLocation(LayoutPoint(borderLeft(), borderTop()) + LayoutSize(paddingLeft(), paddingTop()));
688         controlsRenderer->mutableStyle().setHeight(Length(newSize.height(), Fixed));
689         controlsRenderer->mutableStyle().setWidth(Length(newSize.width(), Fixed));
690     }
691
692     controlsRenderer->setNeedsLayout(MarkOnlyThis);
693     controlsRenderer->layout();
694     clearChildNeedsLayout();
695
696     statePusher.pop();
697 }
698
699 void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
700 {
701     RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
702
703     // Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.
704     if (intrinsicSize.isEmpty() && (imageResource().imageHasRelativeWidth() || imageResource().imageHasRelativeHeight())) {
705         RenderObject* containingBlock = isOutOfFlowPositioned() ? container() : this->containingBlock();
706         if (is<RenderBox>(*containingBlock)) {
707             auto& box = downcast<RenderBox>(*containingBlock);
708             intrinsicSize.setWidth(box.availableLogicalWidth());
709             intrinsicSize.setHeight(box.availableLogicalHeight(IncludeMarginBorderPadding));
710         }
711     }
712     // Don't compute an intrinsic ratio to preserve historical WebKit behavior if we're painting alt text and/or a broken image.
713     if (imageResource().errorOccurred()) {
714         intrinsicRatio = 1;
715         return;
716     }
717 }
718
719 bool RenderImage::needsPreferredWidthsRecalculation() const
720 {
721     if (RenderReplaced::needsPreferredWidthsRecalculation())
722         return true;
723     return embeddedContentBox();
724 }
725
726 RenderBox* RenderImage::embeddedContentBox() const
727 {
728     CachedImage* cachedImage = imageResource().cachedImage();
729     if (cachedImage && is<SVGImage>(cachedImage->image()))
730         return downcast<SVGImage>(*cachedImage->image()).embeddedContentBox();
731
732     return nullptr;
733 }
734
735 } // namespace WebCore