Move rendering/RenderImage* to layout/LayoutImage*

Source/core/layout/LayoutImage.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
-#include "core/rendering/RenderImage.h"
+#include "core/layout/LayoutImage.h"
 
 #include "core/HTMLNames.h"
 #include "core/editing/FrameSelection.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ResourceLoadPriorityOptimizer.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLAreaElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLMapElement.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/Layer.h"
 #include "core/layout/PaintInfo.h"
 #include "core/layout/TextRunConstructor.h"
 #include "core/page/Page.h"
 #include "core/paint/ImagePainter.h"
 #include "core/rendering/RenderView.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/FontCache.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-RenderImage::RenderImage(Element* element)
+LayoutImage::LayoutImage(Element* element)
     : RenderReplaced(element, LayoutSize())
     , m_didIncrementVisuallyNonEmptyPixelCount(false)
     , m_isGeneratedContent(false)
     , m_imageDevicePixelRatio(1.0f)
 {
     ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addLayoutObject(this);
 }
 
-RenderImage* RenderImage::createAnonymous(Document* document)
+LayoutImage* LayoutImage::createAnonymous(Document* document)
 {
-    RenderImage* image = new RenderImage(0);
+    LayoutImage* image = new LayoutImage(0);
     image->setDocumentForAnonymous(document);
     return image;
 }
 
-RenderImage::~RenderImage()
+LayoutImage::~LayoutImage()
 {
 }
 
-void RenderImage::destroy()
+void LayoutImage::destroy()
 {
     ASSERT(m_imageResource);
     m_imageResource->shutdown();
     RenderReplaced::destroy();
 }
 
-void RenderImage::setImageResource(PassOwnPtr<RenderImageResource> imageResource)
+void LayoutImage::setImageResource(PassOwnPtr<LayoutImageResource> imageResource)
 {
     ASSERT(!m_imageResource);
     m_imageResource = imageResource;
     m_imageResource->initialize(this);
 }
 
-void RenderImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
+void LayoutImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
 {
     if (documentBeingDestroyed())
         return;
 
     if (hasBoxDecorationBackground() || hasMask() || hasShapeOutside())
         RenderReplaced::imageChanged(newImage, rect);
 
     if (!m_imageResource)
         return;
 
     if (newImage != m_imageResource->imagePtr())
         return;
 
     // Per the spec, we let the server-sent header override srcset/other sources of dpr.
     // https://github.com/igrigorik/http-client-hints/blob/master/draft-grigorik-http-client-hints-01.txt#L255
     if (m_imageResource->cachedImage() && m_imageResource->cachedImage()->hasDevicePixelRatioHeaderValue())
         m_imageDevicePixelRatio = 1 / m_imageResource->cachedImage()->devicePixelRatioHeaderValue();
 
     if (!m_didIncrementVisuallyNonEmptyPixelCount) {
         // At a zoom level of 1 the image is guaranteed to have an integer size.
         view()->frameView()->incrementVisuallyNonEmptyPixelCount(flooredIntSize(m_imageResource->imageSize(1.0f)));
         m_didIncrementVisuallyNonEmptyPixelCount = true;
     }
 
     repaintOrMarkForLayout(rect);
 }
 
-void RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
+void LayoutImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
 {
     if (m_imageResource->errorOccurred() || !m_imageResource->hasImage())
         return;
     setIntrinsicSize(newSize);
 }
 
-void RenderImage::updateInnerContentRect()
+void LayoutImage::updateInnerContentRect()
 {
     // Propagate container size to the image resource.
     LayoutRect containerRect = replacedContentRect();
     IntSize containerSize(containerRect.width(), containerRect.height());
     if (!containerSize.isEmpty())
         m_imageResource->setContainerSizeForRenderer(containerSize);
 }
 
-void RenderImage::repaintOrMarkForLayout(const IntRect* rect)
+void LayoutImage::repaintOrMarkForLayout(const IntRect* rect)
 {
     LayoutSize oldIntrinsicSize = intrinsicSize();
     LayoutSize newIntrinsicSize = m_imageResource->intrinsicSize(style()->effectiveZoom());
     updateIntrinsicSizeIfNeeded(newIntrinsicSize);
 
     // In the case of generated image content using :before/:after/content, we might not be
     // in the render tree yet. In that case, we just need to update our intrinsic size.
     // layout() will be called after we are inserted in the tree which will take care of
     // what we are doing here.
     if (!containingBlock())
@@ skipping 41 matching lines @@
         DisableCompositingQueryAsserts disabler;
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
         invalidatePaintRectangle(paintInvalidationRect);
     }
 
     // Tell any potential compositing layers that the image needs updating.
     contentChanged(ImageChanged);
 }
 
-void RenderImage::notifyFinished(Resource* newImage)
+void LayoutImage::notifyFinished(Resource* newImage)
 {
     if (!m_imageResource)
         return;
 
     if (documentBeingDestroyed())
         return;
 
     invalidateBackgroundObscurationStatus();
 
     if (newImage == m_imageResource->cachedImage()) {
         // tell any potential compositing layers
         // that the image is done and they can reference it directly.
         contentChanged(ImageChanged);
     }
 }
 
-void RenderImage::paintReplaced(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+void LayoutImage::paintReplaced(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ImagePainter(*this).paintReplaced(paintInfo, paintOffset);
 }
 
-void RenderImage::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+void LayoutImage::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ImagePainter(*this).paint(paintInfo, paintOffset);
 }
 
-void RenderImage::areaElementFocusChanged(HTMLAreaElement* areaElement)
+void LayoutImage::areaElementFocusChanged(HTMLAreaElement* areaElement)
 {
     ASSERT(areaElement->imageElement() == node());
 
     Path path = areaElement->computePath(this);
     if (path.isEmpty())
         return;
 
     const LayoutStyle* areaElementStyle = areaElement->computedStyle();
     unsigned short outlineWidth = areaElementStyle->outlineWidth();
 
     IntRect paintInvalidationRect = enclosingIntRect(path.boundingRect());
     paintInvalidationRect.moveBy(-IntPoint(absoluteContentBoxOffset()));
     paintInvalidationRect.inflate(outlineWidth);
 
     repaintOrMarkForLayout(&paintInvalidationRect);
 }
 
-bool RenderImage::boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance bleedAvoidance, InlineFlowBox*) const
+bool LayoutImage::boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance bleedAvoidance, InlineFlowBox*) const
 {
     if (!RenderBoxModelObject::boxShadowShouldBeAppliedToBackground(bleedAvoidance))
         return false;
 
-    return !const_cast<RenderImage*>(this)->boxDecorationBackgroundIsKnownToBeObscured();
+    return !const_cast<LayoutImage*>(this)->boxDecorationBackgroundIsKnownToBeObscured();
 }
 
-bool RenderImage::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned) const
+bool LayoutImage::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned) const
 {
     if (!m_imageResource->hasImage() || m_imageResource->errorOccurred())
         return false;
     if (m_imageResource->cachedImage() && !m_imageResource->cachedImage()->isLoaded())
         return false;
     if (!contentBoxRect().contains(localRect))
         return false;
     EFillBox backgroundClip = style()->backgroundClip();
     // Background paints under borders.
     if (backgroundClip == BorderFillBox && style()->hasBorder() && !style()->borderObscuresBackground())
         return false;
     // Background shows in padding area.
     if ((backgroundClip == BorderFillBox || backgroundClip == PaddingFillBox) && style()->hasPadding())
         return false;
     // Object-position may leave parts of the content box empty, regardless of the value of object-fit.
     if (style()->objectPosition() != LayoutStyle::initialObjectPosition())
         return false;
     // Object-fit may leave parts of the content box empty.
     ObjectFit objectFit = style()->objectFit();
     if (objectFit != ObjectFitFill && objectFit != ObjectFitCover)
         return false;
     // Check for image with alpha.
     return m_imageResource->cachedImage() && m_imageResource->cachedImage()->currentFrameKnownToBeOpaque(this);
 }
 
-bool RenderImage::computeBackgroundIsKnownToBeObscured()
+bool LayoutImage::computeBackgroundIsKnownToBeObscured()
 {
     if (!hasBackground())
         return false;
 
     LayoutRect paintedExtent;
     if (!getBackgroundPaintedExtent(paintedExtent))
         return false;
     return foregroundIsKnownToBeOpaqueInRect(paintedExtent, 0);
 }
 
-LayoutUnit RenderImage::minimumReplacedHeight() const
+LayoutUnit LayoutImage::minimumReplacedHeight() const
 {
     return m_imageResource->errorOccurred() ? intrinsicSize().height() : LayoutUnit();
 }
 
-HTMLMapElement* RenderImage::imageMap() const
+HTMLMapElement* LayoutImage::imageMap() const
 {
     HTMLImageElement* i = isHTMLImageElement(node()) ? toHTMLImageElement(node()) : 0;
     return i ? i->treeScope().getImageMap(i->fastGetAttribute(usemapAttr)) : 0;
 }
 
-bool RenderImage::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
+bool LayoutImage::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
     HitTestResult tempResult(result.hitTestLocation());
     bool inside = RenderReplaced::nodeAtPoint(request, tempResult, locationInContainer, accumulatedOffset, hitTestAction);
 
     if (tempResult.innerNode() && node()) {
         if (HTMLMapElement* map = imageMap()) {
             LayoutRect contentBox = contentBoxRect();
             float scaleFactor = 1 / style()->effectiveZoom();
             LayoutPoint mapLocation = locationInContainer.point() - toLayoutSize(accumulatedOffset) - locationOffset() - toLayoutSize(contentBox.location());
             mapLocation.scale(scaleFactor, scaleFactor);
 
             if (map->mapMouseEvent(mapLocation, contentBox.size(), tempResult))
                 tempResult.setInnerNonSharedNode(node());
         }
     }
 
     if (!inside && result.isRectBasedTest())
         result.append(tempResult);
     if (inside)
         result = tempResult;
     return inside;
 }
 
-void RenderImage::layout()
+void LayoutImage::layout()
 {
     RenderReplaced::layout();
     updateInnerContentRect();
 }
 
-bool RenderImage::updateImageLoadingPriorities()
+bool LayoutImage::updateImageLoadingPriorities()
 {
     if (!m_imageResource || !m_imageResource->cachedImage() || m_imageResource->cachedImage()->isLoaded())
         return false;
 
     LayoutRect viewBounds = viewRect();
     LayoutRect objectBounds = absoluteContentBox();
 
     // The object bounds might be empty right now, so intersects will fail since it doesn't deal
     // with empty rects. Use LayoutRect::contains in that case.
     bool isVisible;
     if (!objectBounds.isEmpty())
         isVisible =  viewBounds.intersects(objectBounds);
     else
         isVisible = viewBounds.contains(objectBounds);
 
     ResourceLoadPriorityOptimizer::VisibilityStatus status = isVisible ?
         ResourceLoadPriorityOptimizer::Visible : ResourceLoadPriorityOptimizer::NotVisible;
 
     LayoutRect screenArea;
     if (!objectBounds.isEmpty()) {
         screenArea = viewBounds;
         screenArea.intersect(objectBounds);
     }
 
     ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->notifyImageResourceVisibility(m_imageResource->cachedImage(), status, screenArea);
 
     return true;
 }
 
-void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
+void LayoutImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
 {
     RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
 
     // Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.
     if (intrinsicSize.isEmpty() && (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight())) {
         LayoutObject* containingBlock = isOutOfFlowPositioned() ? container() : this->containingBlock();
         if (containingBlock->isBox()) {
             RenderBox* box = toRenderBox(containingBlock);
             intrinsicSize.setWidth(box->availableLogicalWidth().toFloat());
             intrinsicSize.setHeight(box->availableLogicalHeight(IncludeMarginBorderPadding).toFloat());
         }
     }
     // Don't compute an intrinsic ratio to preserve historical WebKit behavior if we're painting alt text and/or a broken image.
     // Video is excluded from this behavior because video elements have a default aspect ratio that a failed poster image load should not override.
     if (m_imageResource && m_imageResource->errorOccurred() && !isVideo()) {
         intrinsicRatio = 1;
         return;
     }
 }
 
-bool RenderImage::needsPreferredWidthsRecalculation() const
+bool LayoutImage::needsPreferredWidthsRecalculation() const
 {
     if (RenderReplaced::needsPreferredWidthsRecalculation())
         return true;
     return embeddedContentBox();
 }
 
-RenderBox* RenderImage::embeddedContentBox() const
+RenderBox* LayoutImage::embeddedContentBox() const
 {
     if (!m_imageResource)
         return 0;
 
     ImageResource* cachedImage = m_imageResource->cachedImage();
     if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
         return toSVGImage(cachedImage->image())->embeddedContentBox();
 
     return 0;
 }
 
 } // namespace blink