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