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