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