080de939fba64e11b80e9563969a49354c743f9f
[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 "AXObjectCache.h"
32 #include "BitmapImage.h"
33 #include "CachedImage.h"
34 #include "FocusController.h"
35 #include "FontCache.h"
36 #include "FontCascade.h"
37 #include "Frame.h"
38 #include "FrameSelection.h"
39 #include "GeometryUtilities.h"
40 #include "GraphicsContext.h"
41 #include "HTMLAreaElement.h"
42 #include "HTMLImageElement.h"
43 #include "HTMLInputElement.h"
44 #include "HTMLMapElement.h"
45 #include "HTMLNames.h"
46 #include "HitTestResult.h"
47 #include "InlineElementBox.h"
48 #include "Page.h"
49 #include "PaintInfo.h"
50 #include "RenderFragmentedFlow.h"
51 #include "RenderImageResourceStyleImage.h"
52 #include "RenderTheme.h"
53 #include "RenderView.h"
54 #include "RuntimeEnabledFeatures.h"
55 #include "SVGImage.h"
56 #include <wtf/IsoMallocInlines.h>
57 #include <wtf/StackStats.h>
58
59 #if PLATFORM(IOS)
60 #include "LogicalSelectionOffsetCaches.h"
61 #include "SelectionRect.h"
62 #endif
63
64 #if USE(CG)
65 #include "PDFDocumentImage.h"
66 #include "Settings.h"
67 #endif
68
69 namespace WebCore {
70
71 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderImage);
72
73 #if PLATFORM(IOS)
74 // FIXME: This doesn't behave correctly for floating or positioned images, but WebCore doesn't handle those well
75 // during selection creation yet anyway.
76 // FIXME: We can't tell whether or not we contain the start or end of the selected Range using only the offsets
77 // of the start and end, we need to know the whole Position.
78 void RenderImage::collectSelectionRects(Vector<SelectionRect>& rects, unsigned, unsigned)
79 {
80     RenderBlock* containingBlock = this->containingBlock();
81
82     IntRect imageRect;
83     // FIXME: It doesn't make sense to package line bounds into SelectionRects. We should find
84     // the right and left extent of the selection once for the entire selected Range, perhaps
85     // using the Range's common ancestor.
86     IntRect lineExtentRect;
87     bool isFirstOnLine = false;
88     bool isLastOnLine = false;
89
90     InlineBox* inlineBox = inlineBoxWrapper();
91     if (!inlineBox) {
92         // This is a block image.
93         imageRect = IntRect(0, 0, width(), height());
94         isFirstOnLine = true;
95         isLastOnLine = true;
96         lineExtentRect = imageRect;
97         if (containingBlock->isHorizontalWritingMode()) {
98             lineExtentRect.setX(containingBlock->x());
99             lineExtentRect.setWidth(containingBlock->width());
100         } else {
101             lineExtentRect.setY(containingBlock->y());
102             lineExtentRect.setHeight(containingBlock->height());
103         }
104     } else {
105         LayoutUnit selectionTop = !containingBlock->style().isFlippedBlocksWritingMode() ? inlineBox->root().selectionTop() - logicalTop() : logicalBottom() - inlineBox->root().selectionBottom();
106         imageRect = IntRect(0,  selectionTop, logicalWidth(), inlineBox->root().selectionHeight());
107         isFirstOnLine = !inlineBox->previousOnLineExists();
108         isLastOnLine = !inlineBox->nextOnLineExists();
109         LogicalSelectionOffsetCaches cache(*containingBlock);
110         LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
111         LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
112         lineExtentRect = IntRect(leftOffset - logicalLeft(), imageRect.y(), rightOffset - leftOffset, imageRect.height());
113         if (!inlineBox->isHorizontal()) {
114             imageRect = imageRect.transposedRect();
115             lineExtentRect = lineExtentRect.transposedRect();
116         }
117     }
118
119     bool isFixed = false;
120     IntRect absoluteBounds = localToAbsoluteQuad(FloatRect(imageRect), UseTransforms, &isFixed).enclosingBoundingBox();
121     IntRect lineExtentBounds = localToAbsoluteQuad(FloatRect(lineExtentRect)).enclosingBoundingBox();
122     if (!containingBlock->isHorizontalWritingMode())
123         lineExtentBounds = lineExtentBounds.transposedRect();
124
125     // FIXME: We should consider either making SelectionRect a struct or better organize its optional fields into
126     // an auxiliary struct to simplify its initialization.
127     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())));
128 }
129 #endif
130
131 using namespace HTMLNames;
132
133 RenderImage::RenderImage(Element& element, RenderStyle&& style, StyleImage* styleImage, const float imageDevicePixelRatio)
134     : RenderReplaced(element, WTFMove(style), IntSize())
135     , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
136     , m_imageDevicePixelRatio(imageDevicePixelRatio)
137 {
138     updateAltText();
139     if (is<HTMLImageElement>(element))
140         m_hasShadowControls = downcast<HTMLImageElement>(element).hasShadowControls();
141 }
142
143 RenderImage::RenderImage(Document& document, RenderStyle&& style, StyleImage* styleImage)
144     : RenderReplaced(document, WTFMove(style), IntSize())
145     , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
146 {
147 }
148
149 RenderImage::~RenderImage()
150 {
151     // Do not add any code here. Add it to willBeDestroyed() instead.
152 }
153
154 void RenderImage::willBeDestroyed()
155 {
156     imageResource().shutdown();
157     RenderReplaced::willBeDestroyed();
158 }
159
160 // If we'll be displaying either alt text or an image, add some padding.
161 static const unsigned short paddingWidth = 4;
162 static const unsigned short paddingHeight = 4;
163
164 // Alt text is restricted to this maximum size, in pixels.  These are
165 // signed integers because they are compared with other signed values.
166 static const float maxAltTextWidth = 1024;
167 static const int maxAltTextHeight = 256;
168
169 IntSize RenderImage::imageSizeForError(CachedImage* newImage) const
170 {
171     ASSERT_ARG(newImage, newImage);
172     ASSERT_ARG(newImage, newImage->imageForRenderer(this));
173
174     FloatSize imageSize;
175     if (newImage->willPaintBrokenImage()) {
176         std::pair<Image*, float> brokenImageAndImageScaleFactor = newImage->brokenImage(document().deviceScaleFactor());
177         imageSize = brokenImageAndImageScaleFactor.first->size();
178         imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
179     } else
180         imageSize = newImage->imageForRenderer(this)->size();
181
182     // imageSize() returns 0 for the error image. We need the true size of the
183     // error image, so we have to get it by grabbing image() directly.
184     return IntSize(paddingWidth + imageSize.width() * style().effectiveZoom(), paddingHeight + imageSize.height() * style().effectiveZoom());
185 }
186
187 // Sets the image height and width to fit the alt text.  Returns true if the
188 // image size changed.
189 ImageSizeChangeType RenderImage::setImageSizeForAltText(CachedImage* newImage /* = 0 */)
190 {
191     IntSize imageSize;
192     if (newImage && newImage->imageForRenderer(this))
193         imageSize = imageSizeForError(newImage);
194     else if (!m_altText.isEmpty() || newImage) {
195         // If we'll be displaying either text or an image, add a little padding.
196         imageSize = IntSize(paddingWidth, paddingHeight);
197     }
198
199     // we have an alt and the user meant it (its not a text we invented)
200     if (!m_altText.isEmpty()) {
201         const FontCascade& font = style().fontCascade();
202         IntSize paddedTextSize(paddingWidth + std::min(ceilf(font.width(RenderBlock::constructTextRun(m_altText, style()))), maxAltTextWidth), paddingHeight + std::min(font.fontMetrics().height(), maxAltTextHeight));
203         imageSize = imageSize.expandedTo(paddedTextSize);
204     }
205
206     if (imageSize == intrinsicSize())
207         return ImageSizeChangeNone;
208
209     setIntrinsicSize(imageSize);
210     return ImageSizeChangeForAltText;
211 }
212
213 void RenderImage::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
214 {
215     if (!hasInitializedStyle())
216         imageResource().initialize(*this);
217     RenderReplaced::styleWillChange(diff, newStyle);
218 }
219
220 void RenderImage::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
221 {
222     RenderReplaced::styleDidChange(diff, oldStyle);
223     if (m_needsToSetSizeForAltText) {
224         if (!m_altText.isEmpty() && setImageSizeForAltText(cachedImage()))
225             repaintOrMarkForLayout(ImageSizeChangeForAltText);
226         m_needsToSetSizeForAltText = false;
227     }
228 #if ENABLE(CSS_IMAGE_ORIENTATION)
229     if (diff == StyleDifference::Layout && oldStyle->imageOrientation() != style().imageOrientation())
230         return repaintOrMarkForLayout(ImageSizeChangeNone);
231 #endif
232
233 #if ENABLE(CSS_IMAGE_RESOLUTION)
234     if (diff == StyleDifference::Layout
235         && (oldStyle->imageResolution() != style().imageResolution()
236             || oldStyle->imageResolutionSnap() != style().imageResolutionSnap()
237             || oldStyle->imageResolutionSource() != style().imageResolutionSource()))
238         repaintOrMarkForLayout(ImageSizeChangeNone);
239 #endif
240 }
241
242 void RenderImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
243 {
244     if (renderTreeBeingDestroyed())
245         return;
246
247     if (hasVisibleBoxDecorations() || hasMask() || hasShapeOutside())
248         RenderReplaced::imageChanged(newImage, rect);
249
250     if (newImage != imageResource().imagePtr() || !newImage)
251         return;
252     
253     if (!m_didIncrementVisuallyNonEmptyPixelCount) {
254         // At a zoom level of 1 the image is guaranteed to have an integer size.
255         view().frameView().incrementVisuallyNonEmptyPixelCount(flooredIntSize(imageResource().imageSize(1.0f)));
256         m_didIncrementVisuallyNonEmptyPixelCount = true;
257     }
258
259     ImageSizeChangeType imageSizeChange = ImageSizeChangeNone;
260
261     // Set image dimensions, taking into account the size of the alt text.
262     if (imageResource().errorOccurred()) {
263         if (!m_altText.isEmpty() && document().hasPendingStyleRecalc()) {
264             ASSERT(element());
265             if (element()) {
266                 m_needsToSetSizeForAltText = true;
267                 element()->invalidateStyleAndLayerComposition();
268             }
269             return;
270         }
271         imageSizeChange = setImageSizeForAltText(cachedImage());
272     }
273     repaintOrMarkForLayout(imageSizeChange, rect);
274     if (AXObjectCache* cache = document().existingAXObjectCache())
275         cache->deferRecomputeIsIgnoredIfNeeded(element());
276 }
277
278 void RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
279 {
280     if (imageResource().errorOccurred() || !m_imageResource->cachedImage())
281         return;
282     setIntrinsicSize(newSize);
283 }
284
285 void RenderImage::updateInnerContentRect()
286 {
287     // Propagate container size to image resource.
288     IntSize containerSize(replacedContentRect().size());
289     if (!containerSize.isEmpty()) {
290         URL imageSourceURL;
291         if (HTMLImageElement* imageElement = is<HTMLImageElement>(element()) ? downcast<HTMLImageElement>(element()) : nullptr)
292             imageSourceURL = document().completeURL(imageElement->imageSourceURL());
293         imageResource().setContainerContext(containerSize, imageSourceURL);
294     }
295 }
296
297 void RenderImage::repaintOrMarkForLayout(ImageSizeChangeType imageSizeChange, const IntRect* rect)
298 {
299 #if ENABLE(CSS_IMAGE_RESOLUTION)
300     double scale = style().imageResolution();
301     if (style().imageResolutionSnap() == ImageResolutionSnap::Pixels)
302         scale = roundForImpreciseConversion<int>(scale);
303     if (scale <= 0)
304         scale = 1;
305     LayoutSize newIntrinsicSize = imageResource().intrinsicSize(style().effectiveZoom() / scale);
306 #else
307     LayoutSize newIntrinsicSize = imageResource().intrinsicSize(style().effectiveZoom());
308 #endif
309     LayoutSize oldIntrinsicSize = intrinsicSize();
310
311     updateIntrinsicSizeIfNeeded(newIntrinsicSize);
312
313     // In the case of generated image content using :before/:after/content, we might not be
314     // in the render tree yet. In that case, we just need to update our intrinsic size.
315     // layout() will be called after we are inserted in the tree which will take care of
316     // what we are doing here.
317     if (!containingBlock())
318         return;
319
320     bool imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize || imageSizeChange != ImageSizeChangeNone;
321
322     if (imageSourceHasChangedSize && setNeedsLayoutIfNeededAfterIntrinsicSizeChange())
323         return;
324
325     if (everHadLayout() && !selfNeedsLayout()) {
326         // The inner content rectangle is calculated during layout, but may need an update now
327         // (unless the box has already been scheduled for layout). In order to calculate it, we
328         // may need values from the containing block, though, so make sure that we're not too
329         // early. It may be that layout hasn't even taken place once yet.
330
331         // FIXME: we should not have to trigger another call to setContainerContextForRenderer()
332         // from here, since it's already being done during layout.
333         updateInnerContentRect();
334     }
335
336     LayoutRect repaintRect = contentBoxRect();
337     if (rect) {
338         // The image changed rect is in source image coordinates (pre-zooming),
339         // so map from the bounds of the image to the contentsBox.
340         repaintRect.intersect(enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), imageResource().imageSize(1.0f)), repaintRect)));
341     }
342         
343     repaintRectangle(repaintRect);
344
345     // Tell any potential compositing layers that the image needs updating.
346     contentChanged(ImageChanged);
347 }
348
349 void RenderImage::notifyFinished(CachedResource& newImage)
350 {
351     if (renderTreeBeingDestroyed())
352         return;
353
354     invalidateBackgroundObscurationStatus();
355
356     if (&newImage == cachedImage()) {
357         // tell any potential compositing layers
358         // that the image is done and they can reference it directly.
359         contentChanged(ImageChanged);
360     }
361 }
362
363 bool RenderImage::isShowingMissingOrImageError() const
364 {
365     return !imageResource().cachedImage() || imageResource().errorOccurred();
366 }
367
368 bool RenderImage::isShowingAltText() const
369 {
370     return isShowingMissingOrImageError() && !m_altText.isEmpty();
371 }
372
373 bool RenderImage::hasNonBitmapImage() const
374 {
375     if (!imageResource().cachedImage())
376         return false;
377
378     Image* image = cachedImage()->imageForRenderer(this);
379     return image && !is<BitmapImage>(image);
380 }
381
382 void RenderImage::paintIncompleteImageOutline(PaintInfo& paintInfo, LayoutPoint paintOffset, LayoutUnit borderWidth) const
383 {
384     auto contentSize = this->contentSize();
385     if (contentSize.width() <= 2 || contentSize.height() <= 2)
386         return;
387
388     auto leftBorder = borderLeft();
389     auto topBorder = borderTop();
390     auto leftPadding = paddingLeft();
391     auto topPadding = paddingTop();
392
393     // Draw an outline rect where the image should be.
394     GraphicsContext& context = paintInfo.context();
395     context.setStrokeStyle(SolidStroke);
396     context.setStrokeColor(Color::lightGray);
397     context.setFillColor(Color::transparent);
398     context.drawRect(snapRectToDevicePixels(LayoutRect({ paintOffset.x() + leftBorder + leftPadding, paintOffset.y() + topBorder + topPadding }, contentSize), document().deviceScaleFactor()), borderWidth);
399 }
400
401 void RenderImage::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
402 {
403     GraphicsContext& context = paintInfo.context();
404     if (context.invalidatingImagesWithAsyncDecodes()) {
405         if (cachedImage() && cachedImage()->isClientWaitingForAsyncDecoding(*this))
406             cachedImage()->removeAllClientsWaitingForAsyncDecoding();
407         return;
408     }
409
410     auto contentSize = this->contentSize();
411     float deviceScaleFactor = document().deviceScaleFactor();
412     LayoutUnit missingImageBorderWidth(1 / deviceScaleFactor);
413
414     if (!imageResource().cachedImage() || imageResource().errorOccurred()) {
415         if (paintInfo.phase == PaintPhaseSelection)
416             return;
417
418         if (paintInfo.phase == PaintPhaseForeground)
419             page().addRelevantUnpaintedObject(this, visualOverflowRect());
420
421         paintIncompleteImageOutline(paintInfo, paintOffset, missingImageBorderWidth);
422
423         if (contentSize.width() > 2 && contentSize.height() > 2) {
424             LayoutUnit leftBorder = borderLeft();
425             LayoutUnit topBorder = borderTop();
426             LayoutUnit leftPad = paddingLeft();
427             LayoutUnit topPad = paddingTop();
428
429             bool errorPictureDrawn = false;
430             LayoutSize imageOffset;
431             // When calculating the usable dimensions, exclude the pixels of
432             // the ouline rect so the error image/alt text doesn't draw on it.
433             LayoutSize usableSize = contentSize - LayoutSize(2 * missingImageBorderWidth, 2 * missingImageBorderWidth);
434
435             RefPtr<Image> image = imageResource().image();
436
437             if (imageResource().errorOccurred() && !image->isNull() && usableSize.width() >= image->width() && usableSize.height() >= image->height()) {
438                 // Call brokenImage() explicitly to ensure we get the broken image icon at the appropriate resolution.
439                 std::pair<Image*, float> brokenImageAndImageScaleFactor = cachedImage()->brokenImage(deviceScaleFactor);
440                 image = brokenImageAndImageScaleFactor.first;
441                 FloatSize imageSize = image->size();
442                 imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
443                 // Center the error image, accounting for border and padding.
444                 LayoutUnit centerX = (usableSize.width() - imageSize.width()) / 2;
445                 if (centerX < 0)
446                     centerX = 0;
447                 LayoutUnit centerY = (usableSize.height() - imageSize.height()) / 2;
448                 if (centerY < 0)
449                     centerY = 0;
450                 imageOffset = LayoutSize(leftBorder + leftPad + centerX + missingImageBorderWidth, topBorder + topPad + centerY + missingImageBorderWidth);
451
452                 ImageOrientationDescription orientationDescription(shouldRespectImageOrientation());
453 #if ENABLE(CSS_IMAGE_ORIENTATION)
454                 orientationDescription.setImageOrientationEnum(style().imageOrientation());
455 #endif
456                 context.drawImage(*image, snapRectToDevicePixels(LayoutRect(paintOffset + imageOffset, imageSize), deviceScaleFactor), orientationDescription);
457                 errorPictureDrawn = true;
458             }
459
460             if (!m_altText.isEmpty()) {
461                 String text = document().displayStringModifiedByEncoding(m_altText);
462                 context.setFillColor(style().visitedDependentColorWithColorFilter(CSSPropertyColor));
463                 const FontCascade& font = style().fontCascade();
464                 const FontMetrics& fontMetrics = font.fontMetrics();
465                 LayoutUnit ascent = fontMetrics.ascent();
466                 LayoutPoint altTextOffset = paintOffset;
467                 altTextOffset.move(leftBorder + leftPad + (paddingWidth / 2) - missingImageBorderWidth, topBorder + topPad + ascent + (paddingHeight / 2) - missingImageBorderWidth);
468
469                 // Only draw the alt text if it'll fit within the content box,
470                 // and only if it fits above the error image.
471                 TextRun textRun = RenderBlock::constructTextRun(text, style());
472                 LayoutUnit textWidth = font.width(textRun);
473                 if (errorPictureDrawn) {
474                     if (usableSize.width() >= textWidth && fontMetrics.height() <= imageOffset.height())
475                         context.drawText(font, textRun, altTextOffset);
476                 } else if (usableSize.width() >= textWidth && usableSize.height() >= fontMetrics.height())
477                     context.drawText(font, textRun, altTextOffset);
478             }
479         }
480         return;
481     }
482     
483     if (contentSize.isEmpty())
484         return;
485
486     bool showBorderForIncompleteImage = settings().incompleteImageBorderEnabled();
487
488     RefPtr<Image> img = imageResource().image(flooredIntSize(contentSize));
489     if (!img || img->isNull()) {
490         if (showBorderForIncompleteImage)
491             paintIncompleteImageOutline(paintInfo, paintOffset, missingImageBorderWidth);
492
493         if (paintInfo.phase == PaintPhaseForeground)
494             page().addRelevantUnpaintedObject(this, visualOverflowRect());
495         return;
496     }
497
498     LayoutRect contentBoxRect = this->contentBoxRect();
499     contentBoxRect.moveBy(paintOffset);
500     LayoutRect replacedContentRect = this->replacedContentRect();
501     replacedContentRect.moveBy(paintOffset);
502     bool clip = !contentBoxRect.contains(replacedContentRect);
503     GraphicsContextStateSaver stateSaver(context, clip);
504     if (clip)
505         context.clip(contentBoxRect);
506
507     ImageDrawResult result = paintIntoRect(paintInfo, snapRectToDevicePixels(replacedContentRect, deviceScaleFactor));
508
509     if (showBorderForIncompleteImage && (result != ImageDrawResult::DidDraw || (cachedImage() && cachedImage()->isLoading())))
510         paintIncompleteImageOutline(paintInfo, paintOffset, missingImageBorderWidth);
511     
512     if (cachedImage() && paintInfo.phase == PaintPhaseForeground) {
513         // For now, count images as unpainted if they are still progressively loading. We may want 
514         // to refine this in the future to account for the portion of the image that has painted.
515         LayoutRect visibleRect = intersection(replacedContentRect, contentBoxRect);
516         if (cachedImage()->isLoading() || result == ImageDrawResult::DidRequestDecoding)
517             page().addRelevantUnpaintedObject(this, visibleRect);
518         else
519             page().addRelevantRepaintedObject(this, visibleRect);
520     }
521 }
522
523 void RenderImage::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
524 {
525     RenderReplaced::paint(paintInfo, paintOffset);
526     
527     if (paintInfo.phase == PaintPhaseOutline)
528         paintAreaElementFocusRing(paintInfo, paintOffset);
529 }
530     
531 void RenderImage::paintAreaElementFocusRing(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
532 {
533 #if PLATFORM(IOS)
534     UNUSED_PARAM(paintInfo);
535     UNUSED_PARAM(paintOffset);
536 #else
537     if (document().printing() || !frame().selection().isFocusedAndActive())
538         return;
539     
540     if (paintInfo.context().paintingDisabled() && !paintInfo.context().performingPaintInvalidation())
541         return;
542
543     Element* focusedElement = document().focusedElement();
544     if (!is<HTMLAreaElement>(focusedElement))
545         return;
546
547     HTMLAreaElement& areaElement = downcast<HTMLAreaElement>(*focusedElement);
548     if (areaElement.imageElement() != element())
549         return;
550
551     auto* areaElementStyle = areaElement.computedStyle();
552     if (!areaElementStyle)
553         return;
554
555     float outlineWidth = areaElementStyle->outlineWidth();
556     if (!outlineWidth)
557         return;
558
559     // Even if the theme handles focus ring drawing for entire elements, it won't do it for
560     // an area within an image, so we don't call RenderTheme::supportsFocusRing here.
561     auto path = areaElement.computePathForFocusRing(size());
562     if (path.isEmpty())
563         return;
564
565     AffineTransform zoomTransform;
566     zoomTransform.scale(style().effectiveZoom());
567     path.transform(zoomTransform);
568
569     auto adjustedOffset = paintOffset;
570     adjustedOffset.moveBy(location());
571     path.translate(toFloatSize(adjustedOffset));
572
573 #if PLATFORM(MAC)
574     bool needsRepaint;
575     paintInfo.context().drawFocusRing(path, page().focusController().timeSinceFocusWasSet().seconds(), needsRepaint, RenderTheme::focusRingColor(document().styleColorOptions()));
576     if (needsRepaint)
577         page().focusController().setFocusedElementNeedsRepaint();
578 #else
579     paintInfo.context().drawFocusRing(path, outlineWidth, areaElementStyle->outlineOffset(), areaElementStyle->visitedDependentColorWithColorFilter(CSSPropertyOutlineColor));
580 #endif
581 #endif
582 }
583
584 void RenderImage::areaElementFocusChanged(HTMLAreaElement* element)
585 {
586     ASSERT_UNUSED(element, element->imageElement() == this->element());
587
588     // It would be more efficient to only repaint the focus ring rectangle
589     // for the passed-in area element. That would require adding functions
590     // to the area element class.
591     repaint();
592 }
593
594 ImageDrawResult RenderImage::paintIntoRect(PaintInfo& paintInfo, const FloatRect& rect)
595 {
596     if (!imageResource().cachedImage() || imageResource().errorOccurred() || rect.width() <= 0 || rect.height() <= 0)
597         return ImageDrawResult::DidNothing;
598
599     RefPtr<Image> img = imageResource().image(flooredIntSize(rect.size()));
600     if (!img || img->isNull())
601         return ImageDrawResult::DidNothing;
602
603     HTMLImageElement* imageElement = is<HTMLImageElement>(element()) ? downcast<HTMLImageElement>(element()) : nullptr;
604     CompositeOperator compositeOperator = imageElement ? imageElement->compositeOperator() : CompositeSourceOver;
605
606     // FIXME: Document when image != img.get().
607     Image* image = imageResource().image().get();
608     InterpolationQuality interpolation = image ? chooseInterpolationQuality(paintInfo.context(), *image, image, LayoutSize(rect.size())) : InterpolationDefault;
609
610 #if USE(CG)
611     if (is<PDFDocumentImage>(image))
612         downcast<PDFDocumentImage>(*image).setPdfImageCachingPolicy(settings().pdfImageCachingPolicy());
613 #endif
614
615     if (is<BitmapImage>(image))
616         downcast<BitmapImage>(*image).updateFromSettings(settings());
617
618     ImageOrientationDescription orientationDescription(shouldRespectImageOrientation(), style().imageOrientation());
619     auto decodingMode = decodingModeForImageDraw(*image, paintInfo);
620     auto drawResult = paintInfo.context().drawImage(*img, rect, ImagePaintingOptions(compositeOperator, BlendMode::Normal, decodingMode, orientationDescription, interpolation));
621     if (drawResult == ImageDrawResult::DidRequestDecoding)
622         imageResource().cachedImage()->addClientWaitingForAsyncDecoding(*this);
623
624 #if USE(SYSTEM_PREVIEW)
625     if (imageElement && imageElement->isSystemPreviewImage() && drawResult == ImageDrawResult::DidDraw && RuntimeEnabledFeatures::sharedFeatures().systemPreviewEnabled())
626         theme().paintSystemPreviewBadge(*img, paintInfo, rect);
627 #endif
628
629     return drawResult;
630 }
631
632 bool RenderImage::boxShadowShouldBeAppliedToBackground(const LayoutPoint& paintOffset, BackgroundBleedAvoidance bleedAvoidance, InlineFlowBox*) const
633 {
634     if (!RenderBoxModelObject::boxShadowShouldBeAppliedToBackground(paintOffset, bleedAvoidance))
635         return false;
636
637     return !const_cast<RenderImage*>(this)->backgroundIsKnownToBeObscured(paintOffset);
638 }
639
640 bool RenderImage::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
641 {
642     UNUSED_PARAM(maxDepthToTest);
643     if (!imageResource().cachedImage() || imageResource().errorOccurred())
644         return false;
645     if (cachedImage() && !cachedImage()->isLoaded())
646         return false;
647     if (!contentBoxRect().contains(localRect))
648         return false;
649     FillBox backgroundClip = style().backgroundClip();
650     // Background paints under borders.
651     if (backgroundClip == FillBox::Border && style().hasBorder() && !borderObscuresBackground())
652         return false;
653     // Background shows in padding area.
654     if ((backgroundClip == FillBox::Border || backgroundClip == FillBox::Padding) && style().hasPadding())
655         return false;
656     // Object-fit may leave parts of the content box empty.
657     ObjectFit objectFit = style().objectFit();
658     if (objectFit != ObjectFit::Fill && objectFit != ObjectFit::Cover)
659         return false;
660
661     LengthPoint objectPosition = style().objectPosition();
662     if (objectPosition != RenderStyle::initialObjectPosition())
663         return false;
664
665     // Check for image with alpha.
666     return cachedImage() && cachedImage()->currentFrameKnownToBeOpaque(this);
667 }
668
669 bool RenderImage::computeBackgroundIsKnownToBeObscured(const LayoutPoint& paintOffset)
670 {
671     if (!hasBackground())
672         return false;
673     
674     LayoutRect paintedExtent;
675     if (!getBackgroundPaintedExtent(paintOffset, paintedExtent))
676         return false;
677     return foregroundIsKnownToBeOpaqueInRect(paintedExtent, 0);
678 }
679
680 LayoutUnit RenderImage::minimumReplacedHeight() const
681 {
682     return imageResource().errorOccurred() ? intrinsicSize().height() : LayoutUnit();
683 }
684
685 HTMLMapElement* RenderImage::imageMap() const
686 {
687     auto* imageElement = element();
688     if (!imageElement || !is<HTMLImageElement>(imageElement))
689         return nullptr;
690     return downcast<HTMLImageElement>(imageElement)->associatedMapElement();
691 }
692
693 bool RenderImage::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
694 {
695     HitTestResult tempResult(result.hitTestLocation());
696     bool inside = RenderReplaced::nodeAtPoint(request, tempResult, locationInContainer, accumulatedOffset, hitTestAction);
697
698     if (tempResult.innerNode() && element()) {
699         if (HTMLMapElement* map = imageMap()) {
700             LayoutRect contentBox = contentBoxRect();
701             float scaleFactor = 1 / style().effectiveZoom();
702             LayoutPoint mapLocation = locationInContainer.point() - toLayoutSize(accumulatedOffset) - locationOffset() - toLayoutSize(contentBox.location());
703             mapLocation.scale(scaleFactor);
704
705             if (map->mapMouseEvent(mapLocation, contentBox.size(), tempResult))
706                 tempResult.setInnerNonSharedNode(element());
707         }
708     }
709
710     if (!inside && request.resultIsElementList())
711         result.append(tempResult, request);
712     if (inside)
713         result = tempResult;
714     return inside;
715 }
716
717 void RenderImage::updateAltText()
718 {
719     if (!element())
720         return;
721
722     if (is<HTMLInputElement>(*element()))
723         m_altText = downcast<HTMLInputElement>(*element()).altText();
724     else if (is<HTMLImageElement>(*element()))
725         m_altText = downcast<HTMLImageElement>(*element()).altText();
726 }
727
728 bool RenderImage::canHaveChildren() const
729 {
730 #if !ENABLE(SERVICE_CONTROLS)
731     return false;
732 #else
733     return m_hasShadowControls;
734 #endif
735 }
736
737 void RenderImage::layout()
738 {
739     // Recomputing overflow is required only when child content is present. 
740     if (needsSimplifiedNormalFlowLayoutOnly() && !m_hasShadowControls) {
741         clearNeedsLayout();
742         return;
743     }
744
745     StackStats::LayoutCheckPoint layoutCheckPoint;
746
747     LayoutSize oldSize = contentBoxRect().size();
748     RenderReplaced::layout();
749
750     updateInnerContentRect();
751
752     if (m_hasShadowControls)
753         layoutShadowControls(oldSize);
754 }
755
756 void RenderImage::layoutShadowControls(const LayoutSize& oldSize)
757 {
758     // We expect a single containing box under the UA shadow root.
759     ASSERT(firstChild() == lastChild());
760
761     auto* controlsRenderer = downcast<RenderBox>(firstChild());
762     if (!controlsRenderer)
763         return;
764     
765     bool controlsNeedLayout = controlsRenderer->needsLayout();
766     // If the region chain has changed we also need to relayout the controls to update the region box info.
767     // FIXME: We can do better once we compute region box info for RenderReplaced, not only for RenderBlock.
768     const RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
769     if (fragmentedFlow && !controlsNeedLayout) {
770         if (fragmentedFlow->pageLogicalSizeChanged())
771             controlsNeedLayout = true;
772     }
773
774     LayoutSize newSize = contentBoxRect().size();
775     if (newSize == oldSize && !controlsNeedLayout)
776         return;
777
778     // When calling layout() on a child node, a parent must either push a LayoutStateMaintainter, or 
779     // instantiate LayoutStateDisabler. Since using a LayoutStateMaintainer is slightly more efficient,
780     // and this method might be called many times per second during video playback, use a LayoutStateMaintainer:
781     LayoutStateMaintainer statePusher(*this, locationOffset(), hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
782
783     if (shadowControlsNeedCustomLayoutMetrics()) {
784         controlsRenderer->setLocation(LayoutPoint(borderLeft(), borderTop()) + LayoutSize(paddingLeft(), paddingTop()));
785         controlsRenderer->mutableStyle().setHeight(Length(newSize.height(), Fixed));
786         controlsRenderer->mutableStyle().setWidth(Length(newSize.width(), Fixed));
787     }
788
789     controlsRenderer->setNeedsLayout(MarkOnlyThis);
790     controlsRenderer->layout();
791     clearChildNeedsLayout();
792 }
793
794 void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
795 {
796     RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
797
798     // Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.
799     if (intrinsicSize.isEmpty() && (imageResource().imageHasRelativeWidth() || imageResource().imageHasRelativeHeight())) {
800         RenderObject* containingBlock = isOutOfFlowPositioned() ? container() : this->containingBlock();
801         if (is<RenderBox>(*containingBlock)) {
802             auto& box = downcast<RenderBox>(*containingBlock);
803             intrinsicSize.setWidth(box.availableLogicalWidth());
804             intrinsicSize.setHeight(box.availableLogicalHeight(IncludeMarginBorderPadding));
805         }
806     }
807     // Don't compute an intrinsic ratio to preserve historical WebKit behavior if we're painting alt text and/or a broken image.
808     if (imageResource().errorOccurred()) {
809         intrinsicRatio = 1;
810         return;
811     }
812 }
813
814 bool RenderImage::needsPreferredWidthsRecalculation() const
815 {
816     if (RenderReplaced::needsPreferredWidthsRecalculation())
817         return true;
818     return embeddedContentBox();
819 }
820
821 RenderBox* RenderImage::embeddedContentBox() const
822 {
823     CachedImage* cachedImage = this->cachedImage();
824     if (cachedImage && is<SVGImage>(cachedImage->image()))
825         return downcast<SVGImage>(*cachedImage->image()).embeddedContentBox();
826
827     return nullptr;
828 }
829
830 } // namespace WebCore