Source/WebCore/rendering/svg/LegacyRenderSVGRoot.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.
  * Copyright (C) Research In Motion Limited 2011. 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 "LegacyRenderSVGRoot.h"

 #include "Frame.h"
 #include "GraphicsContext.h"
 #include "HitTestResult.h"
 #include "LayoutRepainter.h"
 #include "Page.h"
 #include "RenderChildIterator.h"
 #include "RenderIterator.h"
 #include "RenderLayer.h"
 #include "RenderLayoutState.h"
 #include "RenderSVGResource.h"
 #include "RenderSVGResourceContainer.h"
 #include "RenderSVGResourceFilter.h"
 #include "RenderTreeBuilder.h"
 #include "RenderView.h"
 #include "SVGElementTypeHelpers.h"
 #include "SVGImage.h"
 #include "SVGRenderingContext.h"
 #include "SVGResources.h"
 #include "SVGResourcesCache.h"
 #include "SVGSVGElement.h"
 #include "SVGViewSpec.h"
 #include "TransformState.h"
 #include <wtf/IsoMallocInlines.h>
 #include <wtf/SetForScope.h>
 #include <wtf/StackStats.h>

 namespace WebCore {

 WTF_MAKE_ISO_ALLOCATED_IMPL(LegacyRenderSVGRoot);

 LegacyRenderSVGRoot::LegacyRenderSVGRoot(SVGSVGElement& element, RenderStyle&& style)
     : RenderReplaced(element, WTFMove(style))
     , m_isLayoutSizeChanged(false)
     , m_needsBoundariesOrTransformUpdate(true)
     , m_hasBoxDecorations(false)
 {
 }

 LegacyRenderSVGRoot::~LegacyRenderSVGRoot() = default;

 SVGSVGElement& LegacyRenderSVGRoot::svgSVGElement() const
 {
     return downcast<SVGSVGElement>(nodeForNonAnonymous());
 }

 void LegacyRenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
 {
     ASSERT(!shouldApplySizeContainment());

     // Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
     // SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.

     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an ‘object’
     // element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
     // not to have an intrinsic width or height. The intrinsic aspect ratio must be calculated based upon the following rules:
     // - The aspect ratio is calculated by dividing a width by a height.
     // - If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers (in, mm, cm, pt, pc,
     //   px, em, ex) or in user units, then the aspect ratio is calculated from the ‘width’ and ‘height’ attributes after
     //   resolving both values to user units.
     intrinsicSize.setWidth(floatValueForLength(svgSVGElement().intrinsicWidth(), 0));
     intrinsicSize.setHeight(floatValueForLength(svgSVGElement().intrinsicHeight(), 0));

     if (style().aspectRatioType() == AspectRatioType::Ratio) {
         intrinsicRatio = style().logicalAspectRatio();
         return;
     }

     std::optional<double> intrinsicRatioValue;
     if (!intrinsicSize.isEmpty())
         intrinsicRatioValue = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
     else {
         // - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
         //   aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
         //   fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
         //   calculated and is considered unspecified.
         FloatSize viewBoxSize = svgSVGElement().viewBox().size();
         if (!viewBoxSize.isEmpty()) {
             // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
             intrinsicRatioValue = viewBoxSize.width() / static_cast<double>(viewBoxSize.height());
         }
     }

     if (intrinsicRatioValue)
         intrinsicRatio = *intrinsicRatioValue;
     else if (style().aspectRatioType() == AspectRatioType::AutoAndRatio)
         intrinsicRatio = style().logicalAspectRatio();
 }

 bool LegacyRenderSVGRoot::isEmbeddedThroughSVGImage() const
 {
     return isInSVGImage(&svgSVGElement());
 }

 bool LegacyRenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
 {
     // If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
     // but we only negotiate if we're in an SVG document.
     if (!frame().ownerRenderer())
         return false;
     return frame().document()->isSVGDocument();
 }

 LayoutUnit LegacyRenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
 {
     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
     if (!m_containerSize.isEmpty())
         return m_containerSize.width();

     if (isEmbeddedThroughFrameContainingSVGDocument())
         return containingBlock()->availableLogicalWidth();

     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
     return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
 }

 LayoutUnit LegacyRenderSVGRoot::computeReplacedLogicalHeight(std::optional<LayoutUnit> estimatedUsedWidth) const
 {
     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
     if (!m_containerSize.isEmpty())
         return m_containerSize.height();

     if (isEmbeddedThroughFrameContainingSVGDocument())
         return containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding);

     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
     return RenderReplaced::computeReplacedLogicalHeight(estimatedUsedWidth);
 }

 void LegacyRenderSVGRoot::layout()
 {
     SetForScope change(m_inLayout, true);
     StackStats::LayoutCheckPoint layoutCheckPoint;
     ASSERT(needsLayout());

     m_resourcesNeedingToInvalidateClients.clear();

     // Arbitrary affine transforms are incompatible with RenderLayoutState.
     LayoutStateDisabler layoutStateDisabler(view().frameView().layoutContext());

     bool needsLayout = selfNeedsLayout();
     LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);

     LayoutSize oldSize = size();
     updateLogicalWidth();
     updateLogicalHeight();
     buildLocalToBorderBoxTransform();

     m_isLayoutSizeChanged = needsLayout || (svgSVGElement().hasRelativeLengths() && oldSize != size());
     SVGRenderSupport::layoutChildren(*this, needsLayout || SVGRenderSupport::filtersForceContainerLayout(*this));

     if (!m_resourcesNeedingToInvalidateClients.isEmpty()) {
         // Invalidate resource clients, which may mark some nodes for layout.
         for (auto& resource :  m_resourcesNeedingToInvalidateClients) {
             resource->removeAllClientsFromCache();
             SVGResourcesCache::clientStyleChanged(*resource, StyleDifference::Layout, resource->style());
         }

         m_isLayoutSizeChanged = false;
         SVGRenderSupport::layoutChildren(*this, false);
     }

     // At this point LayoutRepainter already grabbed the old bounds,
     // recalculate them now so repaintAfterLayout() uses the new bounds.
     if (m_needsBoundariesOrTransformUpdate) {
         updateCachedBoundaries();
         m_needsBoundariesOrTransformUpdate = false;
     }

     clearOverflow();
     if (!shouldApplyViewportClip()) {
         FloatRect contentRepaintRect = repaintRectInLocalCoordinates();
         contentRepaintRect = m_localToBorderBoxTransform.mapRect(contentRepaintRect);
         addVisualOverflow(enclosingLayoutRect(contentRepaintRect));
     }

     updateLayerTransform();
     m_hasBoxDecorations = isDocumentElementRenderer() ? hasVisibleBoxDecorationStyle() : hasVisibleBoxDecorations();
     invalidateBackgroundObscurationStatus();

     repainter.repaintAfterLayout();

     clearNeedsLayout();
 }

 bool LegacyRenderSVGRoot::shouldApplyViewportClip() const
 {
     // the outermost svg is clipped if auto, and svg document roots are always clipped
     // When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
     // be applied, noting that the window scrollbars should be hidden if overflow=hidden.
     return effectiveOverflowX() == Overflow::Hidden
         || style().overflowX() == Overflow::Auto
         || style().overflowX() == Overflow::Scroll
         || this->isDocumentElementRenderer();
 }

 void LegacyRenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     // An empty viewport disables rendering.
     bool clipViewport = shouldApplyViewportClip();
     if (clipViewport && contentSize().isEmpty())
         return;

     // Don't paint, if the context explicitly disabled it.
     if (paintInfo.context().paintingDisabled() && !paintInfo.context().detectingContentfulPaint())
         return;

     // SVG outlines are painted during PaintPhase::Foreground.
     if (paintInfo.phase == PaintPhase::Outline || paintInfo.phase == PaintPhase::SelfOutline)
         return;

     // An empty viewBox also disables rendering.
     // (http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute)
     if (svgSVGElement().hasEmptyViewBox())
         return;

     GraphicsContext& context = paintInfo.context();
     if (context.detectingContentfulPaint()) {
         for (auto& current : childrenOfType<RenderObject>(*this)) {
             if (!current.isSVGHiddenContainer()) {
                 context.setContentfulPaintDetected();
                 return;
             }
         }
         return;
     }

     // Don't paint if we don't have kids, except if we have filters we should paint those.
     if (!firstChild()) {
         auto* resources = SVGResourcesCache::cachedResourcesForRenderer(*this);
         if (!resources || !resources->filter()) {
             if (paintInfo.phase == PaintPhase::Foreground)
                 page().addRelevantUnpaintedObject(this, visualOverflowRect());
             return;
         }
     }

     if (paintInfo.phase == PaintPhase::Foreground)
         page().addRelevantRepaintedObject(this, visualOverflowRect());

     // Make a copy of the PaintInfo because applyTransform will modify the damage rect.
     PaintInfo childPaintInfo(paintInfo);
     childPaintInfo.context().save();

     // Apply initial viewport clip
     if (clipViewport)
         childPaintInfo.context().clip(snappedIntRect(overflowClipRect(paintOffset)));

     // Convert from container offsets (html renderers) to a relative transform (svg renderers).
     // Transform from our paint container's coordinate system to our local coords.
     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
     childPaintInfo.applyTransform(AffineTransform::makeTranslation(toFloatSize(adjustedPaintOffset)) * localToBorderBoxTransform());

     // SVGRenderingContext must be destroyed before we restore the childPaintInfo.context(), because a filter may have
     // changed the context and it is only reverted when the SVGRenderingContext destructor finishes applying the filter.
     {
         SVGRenderingContext renderingContext;
         bool continueRendering = true;
         if (childPaintInfo.phase == PaintPhase::Foreground) {
             renderingContext.prepareToRenderSVGContent(*this, childPaintInfo);
             continueRendering = renderingContext.isRenderingPrepared();
         }

         if (continueRendering) {
             childPaintInfo.updateSubtreePaintRootForChildren(this);
             for (auto& child : childrenOfType<RenderElement>(*this))
                 child.paint(childPaintInfo, location());
         }
     }

     childPaintInfo.context().restore();
 }

 void LegacyRenderSVGRoot::willBeDestroyed()
 {
     RenderBlock::removePercentHeightDescendant(const_cast<LegacyRenderSVGRoot&>(*this));

     SVGResourcesCache::clientDestroyed(*this);
     RenderReplaced::willBeDestroyed();
 }

 void LegacyRenderSVGRoot::insertedIntoTree(IsInternalMove isInternalMove)
 {
     RenderReplaced::insertedIntoTree(isInternalMove);
     SVGResourcesCache::clientWasAddedToTree(*this);
 }

 void LegacyRenderSVGRoot::willBeRemovedFromTree(IsInternalMove isInternalMove)
 {
     SVGResourcesCache::clientWillBeRemovedFromTree(*this);
     RenderReplaced::willBeRemovedFromTree(isInternalMove);
 }

 void LegacyRenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     if (diff == StyleDifference::Layout)
         setNeedsBoundariesUpdate();

     // Box decorations may have appeared/disappeared - recompute status.
     if (diff == StyleDifference::Repaint)
         m_hasBoxDecorations = hasVisibleBoxDecorationStyle();

     RenderReplaced::styleDidChange(diff, oldStyle);
     SVGResourcesCache::clientStyleChanged(*this, diff, style());
 }

 // RenderBox methods will expect coordinates w/o any transforms in coordinates
 // relative to our borderBox origin. This method gives us exactly that.
 void LegacyRenderSVGRoot::buildLocalToBorderBoxTransform()
 {
     float scale = style().effectiveZoom();
     FloatPoint translate = svgSVGElement().currentTranslateValue();
     LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
     m_localToBorderBoxTransform = svgSVGElement().viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
     if (borderAndPadding.isZero() && scale == 1 && translate == FloatPoint::zero())
         return;
     m_localToBorderBoxTransform = AffineTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y()) * m_localToBorderBoxTransform;
 }

 const AffineTransform& LegacyRenderSVGRoot::localToParentTransform() const
 {
     // Slightly optimized version of m_localToParentTransform = AffineTransform::makeTranslation(x(), y()) * m_localToBorderBoxTransform;
     m_localToParentTransform = m_localToBorderBoxTransform;
     if (x())
         m_localToParentTransform.setE(m_localToParentTransform.e() + roundToInt(x()));
     if (y())
         m_localToParentTransform.setF(m_localToParentTransform.f() + roundToInt(y()));
     return m_localToParentTransform;
 }

 LayoutRect LegacyRenderSVGRoot::clippedOverflowRect(const RenderLayerModelObject* repaintContainer, VisibleRectContext context) const
 {
     if (isInsideEntirelyHiddenLayer())
         return { };

     FloatRect contentRepaintRect = m_localToBorderBoxTransform.mapRect(repaintRectInLocalCoordinates());
     contentRepaintRect.intersect(snappedIntRect(borderBoxRect()));

     LayoutRect repaintRect = enclosingLayoutRect(contentRepaintRect);
     if (m_hasBoxDecorations || hasRenderOverflow())
         repaintRect.unite(unionRect(localSelectionRect(false), visualOverflowRect()));

     return RenderReplaced::computeRect(enclosingIntRect(repaintRect), repaintContainer, context);
 }

 std::optional<FloatRect> LegacyRenderSVGRoot::computeFloatVisibleRectInContainer(const FloatRect& rect, const RenderLayerModelObject* container, VisibleRectContext context) const
 {
     // Apply our local transforms (except for x/y translation) and then call
     // RenderBox's method to handle all the normal CSS Box model bits
     FloatRect adjustedRect = m_localToBorderBoxTransform.mapRect(rect);

     // Apply initial viewport clip
     if (shouldApplyViewportClip()) {
         if (context.options.contains(VisibleRectContextOption::UseEdgeInclusiveIntersection)) {
             if (!adjustedRect.edgeInclusiveIntersect(snappedIntRect(borderBoxRect())))
                 return std::nullopt;
         } else
             adjustedRect.intersect(snappedIntRect(borderBoxRect()));
     }

     if (m_hasBoxDecorations || hasRenderOverflow()) {
         // The selectionRect can project outside of the overflowRect, so take their union
         // for repainting to avoid selection painting glitches.
         LayoutRect decoratedRepaintRect = unionRect(localSelectionRect(false), visualOverflowRect());
         adjustedRect.unite(decoratedRepaintRect);
     }

     if (std::optional<LayoutRect> rectInContainer = RenderReplaced::computeVisibleRectInContainer(enclosingIntRect(adjustedRect), container, context))
         return FloatRect(*rectInContainer);
     return std::nullopt;
 }

 // This method expects local CSS box coordinates.
 // Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
 // to convert from SVG viewport coordinates to local CSS box coordinates.
 void LegacyRenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* ancestorContainer, TransformState& transformState, OptionSet<MapCoordinatesMode> mode, bool* wasFixed) const
 {
     ASSERT(!mode.contains(IsFixed)); // We should have no fixed content in the SVG rendering tree.
     ASSERT(mode.contains(UseTransforms)); // mapping a point through SVG w/o respecting transforms is useless.

     RenderReplaced::mapLocalToContainer(ancestorContainer, transformState, mode | ApplyContainerFlip, wasFixed);
 }

 const RenderObject* LegacyRenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
 {
     return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
 }

 void LegacyRenderSVGRoot::updateCachedBoundaries()
 {
     SVGRenderSupport::computeContainerBoundingBoxes(*this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_repaintBoundingBox);
     SVGRenderSupport::intersectRepaintRectWithResources(*this, m_repaintBoundingBox);
     m_repaintBoundingBox.inflate(horizontalBorderAndPaddingExtent());
 }

 bool LegacyRenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
     LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);
     LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());

     ASSERT(SVGHitTestCycleDetectionScope::isEmpty());

     // Test SVG content if the point is in our content box or it is inside the visualOverflowRect and the overflow is visible.
     // FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
     if (contentBoxRect().contains(pointInBorderBox) || (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInParent))) {
         FloatPoint localPoint = valueOrDefault(localToParentTransform().inverse()).mapPoint(FloatPoint(pointInParent));

         for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
             // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
             if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
                 updateHitTestResult(result, pointInBorderBox);
                 if (result.addNodeToListBasedTestResult(child->node(), request, locationInContainer) == HitTestProgress::Stop) {
                     ASSERT(SVGHitTestCycleDetectionScope::isEmpty());
                     return true;
                 }
             }
         }
     }

     // If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit.
     if ((hitTestAction == HitTestBlockBackground || hitTestAction == HitTestChildBlockBackground) && visibleToHitTesting(request)) {
         // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
         // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
         // to be able to detect hits on the background of a <div> element. If we'd return true here in the 'Foreground' phase, we are not able
         // to detect these hits anymore.
         LayoutRect boundsRect(accumulatedOffset + location(), size());
         if (locationInContainer.intersects(boundsRect)) {
             updateHitTestResult(result, pointInBorderBox);
             if (result.addNodeToListBasedTestResult(nodeForHitTest(), request, locationInContainer, boundsRect) == HitTestProgress::Stop)
                 return true;
         }
     }

     ASSERT(SVGHitTestCycleDetectionScope::isEmpty());

     return false;
 }

 bool LegacyRenderSVGRoot::hasRelativeDimensions() const
 {
     return svgSVGElement().intrinsicHeight().isPercentOrCalculated() || svgSVGElement().intrinsicWidth().isPercentOrCalculated();
 }

 void LegacyRenderSVGRoot::addResourceForClientInvalidation(RenderSVGResourceContainer* resource)
 {
     LegacyRenderSVGRoot* svgRoot = SVGRenderSupport::findTreeRootObject(*resource);
     if (!svgRoot)
         return;
     svgRoot->m_resourcesNeedingToInvalidateClients.add(resource);
 }

 }
	/*
	* Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
	* Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis@kde.org>
	* Copyright (C) 2007 Eric Seidel <eric@webkit.org>
	* Copyright (C) 2009 Google, Inc.
	* Copyright (C) Research In Motion Limited 2011. 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 "LegacyRenderSVGRoot.h"

	#include "Frame.h"
	#include "GraphicsContext.h"
	#include "HitTestResult.h"
	#include "LayoutRepainter.h"
	#include "Page.h"
	#include "RenderChildIterator.h"
	#include "RenderIterator.h"
	#include "RenderLayer.h"
	#include "RenderLayoutState.h"
	#include "RenderSVGResource.h"
	#include "RenderSVGResourceContainer.h"
	#include "RenderSVGResourceFilter.h"
	#include "RenderTreeBuilder.h"
	#include "RenderView.h"
	#include "SVGElementTypeHelpers.h"
	#include "SVGImage.h"
	#include "SVGRenderingContext.h"
	#include "SVGResources.h"
	#include "SVGResourcesCache.h"
	#include "SVGSVGElement.h"
	#include "SVGViewSpec.h"
	#include "TransformState.h"
	#include <wtf/IsoMallocInlines.h>
	#include <wtf/SetForScope.h>
	#include <wtf/StackStats.h>

	namespace WebCore {

	WTF_MAKE_ISO_ALLOCATED_IMPL(LegacyRenderSVGRoot);

	LegacyRenderSVGRoot::LegacyRenderSVGRoot(SVGSVGElement& element, RenderStyle&& style)
	: RenderReplaced(element, WTFMove(style))
	, m_isLayoutSizeChanged(false)
	, m_needsBoundariesOrTransformUpdate(true)
	, m_hasBoxDecorations(false)
	{
	}

	LegacyRenderSVGRoot::~LegacyRenderSVGRoot() = default;

	SVGSVGElement& LegacyRenderSVGRoot::svgSVGElement() const
	{
	return downcast<SVGSVGElement>(nodeForNonAnonymous());
	}

	void LegacyRenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
	{
	ASSERT(!shouldApplySizeContainment());

	// Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
	// SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.

	// The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an ‘object’
	// element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
	// not to have an intrinsic width or height. The intrinsic aspect ratio must be calculated based upon the following rules:
	// - The aspect ratio is calculated by dividing a width by a height.
	// - If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers (in, mm, cm, pt, pc,
	// px, em, ex) or in user units, then the aspect ratio is calculated from the ‘width’ and ‘height’ attributes after
	// resolving both values to user units.
	intrinsicSize.setWidth(floatValueForLength(svgSVGElement().intrinsicWidth(), 0));
	intrinsicSize.setHeight(floatValueForLength(svgSVGElement().intrinsicHeight(), 0));

	if (style().aspectRatioType() == AspectRatioType::Ratio) {
	intrinsicRatio = style().logicalAspectRatio();
	return;
	}

	std::optional<double> intrinsicRatioValue;
	if (!intrinsicSize.isEmpty())
	intrinsicRatioValue = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
	else {
	// - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
	// aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
	// fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
	// calculated and is considered unspecified.
	FloatSize viewBoxSize = svgSVGElement().viewBox().size();
	if (!viewBoxSize.isEmpty()) {
	// The viewBox can only yield an intrinsic ratio, not an intrinsic size.
	intrinsicRatioValue = viewBoxSize.width() / static_cast<double>(viewBoxSize.height());
	}
	}

	if (intrinsicRatioValue)
	intrinsicRatio = *intrinsicRatioValue;
	else if (style().aspectRatioType() == AspectRatioType::AutoAndRatio)
	intrinsicRatio = style().logicalAspectRatio();
	}

	bool LegacyRenderSVGRoot::isEmbeddedThroughSVGImage() const
	{
	return isInSVGImage(&svgSVGElement());
	}

	bool LegacyRenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
	{
	// If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
	// but we only negotiate if we're in an SVG document.
	if (!frame().ownerRenderer())
	return false;
	return frame().document()->isSVGDocument();
	}

	LayoutUnit LegacyRenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
	{
	// When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
	if (!m_containerSize.isEmpty())
	return m_containerSize.width();

	if (isEmbeddedThroughFrameContainingSVGDocument())
	return containingBlock()->availableLogicalWidth();

	// SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
	return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
	}

	LayoutUnit LegacyRenderSVGRoot::computeReplacedLogicalHeight(std::optional<LayoutUnit> estimatedUsedWidth) const
	{
	// When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
	if (!m_containerSize.isEmpty())
	return m_containerSize.height();

	if (isEmbeddedThroughFrameContainingSVGDocument())
	return containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding);

	// SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
	return RenderReplaced::computeReplacedLogicalHeight(estimatedUsedWidth);
	}

	void LegacyRenderSVGRoot::layout()
	{
	SetForScope change(m_inLayout, true);
	StackStats::LayoutCheckPoint layoutCheckPoint;
	ASSERT(needsLayout());

	m_resourcesNeedingToInvalidateClients.clear();

	// Arbitrary affine transforms are incompatible with RenderLayoutState.
	LayoutStateDisabler layoutStateDisabler(view().frameView().layoutContext());

	bool needsLayout = selfNeedsLayout();
	LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);

	LayoutSize oldSize = size();
	updateLogicalWidth();
	updateLogicalHeight();
	buildLocalToBorderBoxTransform();

	m_isLayoutSizeChanged = needsLayout \|\| (svgSVGElement().hasRelativeLengths() && oldSize != size());
	SVGRenderSupport::layoutChildren(this, needsLayout \|\| SVGRenderSupport::filtersForceContainerLayout(this));

	if (!m_resourcesNeedingToInvalidateClients.isEmpty()) {
	// Invalidate resource clients, which may mark some nodes for layout.
	for (auto& resource : m_resourcesNeedingToInvalidateClients) {
	resource->removeAllClientsFromCache();
	SVGResourcesCache::clientStyleChanged(*resource, StyleDifference::Layout, resource->style());
	}

	m_isLayoutSizeChanged = false;
	SVGRenderSupport::layoutChildren(*this, false);
	}

	// At this point LayoutRepainter already grabbed the old bounds,
	// recalculate them now so repaintAfterLayout() uses the new bounds.
	if (m_needsBoundariesOrTransformUpdate) {
	updateCachedBoundaries();
	m_needsBoundariesOrTransformUpdate = false;
	}

	clearOverflow();
	if (!shouldApplyViewportClip()) {
	FloatRect contentRepaintRect = repaintRectInLocalCoordinates();
	contentRepaintRect = m_localToBorderBoxTransform.mapRect(contentRepaintRect);
	addVisualOverflow(enclosingLayoutRect(contentRepaintRect));
	}

	updateLayerTransform();
	m_hasBoxDecorations = isDocumentElementRenderer() ? hasVisibleBoxDecorationStyle() : hasVisibleBoxDecorations();
	invalidateBackgroundObscurationStatus();

	repainter.repaintAfterLayout();

	clearNeedsLayout();
	}

	bool LegacyRenderSVGRoot::shouldApplyViewportClip() const
	{
	// the outermost svg is clipped if auto, and svg document roots are always clipped
	// When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
	// be applied, noting that the window scrollbars should be hidden if overflow=hidden.
	return effectiveOverflowX() == Overflow::Hidden
	\|\| style().overflowX() == Overflow::Auto
	\|\| style().overflowX() == Overflow::Scroll
	\|\| this->isDocumentElementRenderer();
	}

	void LegacyRenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
	{
	// An empty viewport disables rendering.
	bool clipViewport = shouldApplyViewportClip();
	if (clipViewport && contentSize().isEmpty())
	return;

	// Don't paint, if the context explicitly disabled it.
	if (paintInfo.context().paintingDisabled() && !paintInfo.context().detectingContentfulPaint())
	return;

	// SVG outlines are painted during PaintPhase::Foreground.
	if (paintInfo.phase == PaintPhase::Outline \|\| paintInfo.phase == PaintPhase::SelfOutline)
	return;

	// An empty viewBox also disables rendering.
	// (http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute)
	if (svgSVGElement().hasEmptyViewBox())
	return;

	GraphicsContext& context = paintInfo.context();
	if (context.detectingContentfulPaint()) {
	for (auto& current : childrenOfType<RenderObject>(*this)) {
	if (!current.isSVGHiddenContainer()) {
	context.setContentfulPaintDetected();
	return;
	}
	}
	return;
	}

	// Don't paint if we don't have kids, except if we have filters we should paint those.
	if (!firstChild()) {
	auto* resources = SVGResourcesCache::cachedResourcesForRenderer(*this);
	if (!resources \|\| !resources->filter()) {
	if (paintInfo.phase == PaintPhase::Foreground)
	page().addRelevantUnpaintedObject(this, visualOverflowRect());
	return;
	}
	}

	if (paintInfo.phase == PaintPhase::Foreground)
	page().addRelevantRepaintedObject(this, visualOverflowRect());

	// Make a copy of the PaintInfo because applyTransform will modify the damage rect.
	PaintInfo childPaintInfo(paintInfo);
	childPaintInfo.context().save();

	// Apply initial viewport clip
	if (clipViewport)
	childPaintInfo.context().clip(snappedIntRect(overflowClipRect(paintOffset)));

	// Convert from container offsets (html renderers) to a relative transform (svg renderers).
	// Transform from our paint container's coordinate system to our local coords.
	IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
	childPaintInfo.applyTransform(AffineTransform::makeTranslation(toFloatSize(adjustedPaintOffset)) * localToBorderBoxTransform());

	// SVGRenderingContext must be destroyed before we restore the childPaintInfo.context(), because a filter may have
	// changed the context and it is only reverted when the SVGRenderingContext destructor finishes applying the filter.
	{
	SVGRenderingContext renderingContext;
	bool continueRendering = true;
	if (childPaintInfo.phase == PaintPhase::Foreground) {
	renderingContext.prepareToRenderSVGContent(*this, childPaintInfo);
	continueRendering = renderingContext.isRenderingPrepared();
	}

	if (continueRendering) {
	childPaintInfo.updateSubtreePaintRootForChildren(this);
	for (auto& child : childrenOfType<RenderElement>(*this))
	child.paint(childPaintInfo, location());
	}
	}

	childPaintInfo.context().restore();
	}

	void LegacyRenderSVGRoot::willBeDestroyed()
	{
	RenderBlock::removePercentHeightDescendant(const_cast<LegacyRenderSVGRoot&>(*this));

	SVGResourcesCache::clientDestroyed(*this);
	RenderReplaced::willBeDestroyed();
	}

	void LegacyRenderSVGRoot::insertedIntoTree(IsInternalMove isInternalMove)
	{
	RenderReplaced::insertedIntoTree(isInternalMove);
	SVGResourcesCache::clientWasAddedToTree(*this);
	}

	void LegacyRenderSVGRoot::willBeRemovedFromTree(IsInternalMove isInternalMove)
	{
	SVGResourcesCache::clientWillBeRemovedFromTree(*this);
	RenderReplaced::willBeRemovedFromTree(isInternalMove);
	}

	void LegacyRenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
	{
	if (diff == StyleDifference::Layout)
	setNeedsBoundariesUpdate();

	// Box decorations may have appeared/disappeared - recompute status.
	if (diff == StyleDifference::Repaint)
	m_hasBoxDecorations = hasVisibleBoxDecorationStyle();

	RenderReplaced::styleDidChange(diff, oldStyle);
	SVGResourcesCache::clientStyleChanged(*this, diff, style());
	}

	// RenderBox methods will expect coordinates w/o any transforms in coordinates
	// relative to our borderBox origin. This method gives us exactly that.
	void LegacyRenderSVGRoot::buildLocalToBorderBoxTransform()
	{
	float scale = style().effectiveZoom();
	FloatPoint translate = svgSVGElement().currentTranslateValue();
	LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
	m_localToBorderBoxTransform = svgSVGElement().viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
	if (borderAndPadding.isZero() && scale == 1 && translate == FloatPoint::zero())
	return;
	m_localToBorderBoxTransform = AffineTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y()) * m_localToBorderBoxTransform;
	}

	const AffineTransform& LegacyRenderSVGRoot::localToParentTransform() const
	{
	// Slightly optimized version of m_localToParentTransform = AffineTransform::makeTranslation(x(), y()) * m_localToBorderBoxTransform;
	m_localToParentTransform = m_localToBorderBoxTransform;
	if (x())
	m_localToParentTransform.setE(m_localToParentTransform.e() + roundToInt(x()));
	if (y())
	m_localToParentTransform.setF(m_localToParentTransform.f() + roundToInt(y()));
	return m_localToParentTransform;
	}

	LayoutRect LegacyRenderSVGRoot::clippedOverflowRect(const RenderLayerModelObject* repaintContainer, VisibleRectContext context) const
	{
	if (isInsideEntirelyHiddenLayer())
	return { };

	FloatRect contentRepaintRect = m_localToBorderBoxTransform.mapRect(repaintRectInLocalCoordinates());
	contentRepaintRect.intersect(snappedIntRect(borderBoxRect()));

	LayoutRect repaintRect = enclosingLayoutRect(contentRepaintRect);
	if (m_hasBoxDecorations \|\| hasRenderOverflow())
	repaintRect.unite(unionRect(localSelectionRect(false), visualOverflowRect()));

	return RenderReplaced::computeRect(enclosingIntRect(repaintRect), repaintContainer, context);
	}

	std::optional<FloatRect> LegacyRenderSVGRoot::computeFloatVisibleRectInContainer(const FloatRect& rect, const RenderLayerModelObject* container, VisibleRectContext context) const
	{
	// Apply our local transforms (except for x/y translation) and then call
	// RenderBox's method to handle all the normal CSS Box model bits
	FloatRect adjustedRect = m_localToBorderBoxTransform.mapRect(rect);

	// Apply initial viewport clip
	if (shouldApplyViewportClip()) {
	if (context.options.contains(VisibleRectContextOption::UseEdgeInclusiveIntersection)) {
	if (!adjustedRect.edgeInclusiveIntersect(snappedIntRect(borderBoxRect())))
	return std::nullopt;
	} else
	adjustedRect.intersect(snappedIntRect(borderBoxRect()));
	}

	if (m_hasBoxDecorations \|\| hasRenderOverflow()) {
	// The selectionRect can project outside of the overflowRect, so take their union
	// for repainting to avoid selection painting glitches.
	LayoutRect decoratedRepaintRect = unionRect(localSelectionRect(false), visualOverflowRect());
	adjustedRect.unite(decoratedRepaintRect);
	}

	if (std::optional<LayoutRect> rectInContainer = RenderReplaced::computeVisibleRectInContainer(enclosingIntRect(adjustedRect), container, context))
	return FloatRect(*rectInContainer);
	return std::nullopt;
	}

	// This method expects local CSS box coordinates.
	// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
	// to convert from SVG viewport coordinates to local CSS box coordinates.
	void LegacyRenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* ancestorContainer, TransformState& transformState, OptionSet<MapCoordinatesMode> mode, bool* wasFixed) const
	{
	ASSERT(!mode.contains(IsFixed)); // We should have no fixed content in the SVG rendering tree.
	ASSERT(mode.contains(UseTransforms)); // mapping a point through SVG w/o respecting transforms is useless.

	RenderReplaced::mapLocalToContainer(ancestorContainer, transformState, mode \| ApplyContainerFlip, wasFixed);
	}

	const RenderObject* LegacyRenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
	{
	return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
	}

	void LegacyRenderSVGRoot::updateCachedBoundaries()
	{
	SVGRenderSupport::computeContainerBoundingBoxes(*this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_repaintBoundingBox);
	SVGRenderSupport::intersectRepaintRectWithResources(*this, m_repaintBoundingBox);
	m_repaintBoundingBox.inflate(horizontalBorderAndPaddingExtent());
	}

	bool LegacyRenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
	{
	LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);
	LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());

	ASSERT(SVGHitTestCycleDetectionScope::isEmpty());

	// Test SVG content if the point is in our content box or it is inside the visualOverflowRect and the overflow is visible.
	// FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
	if (contentBoxRect().contains(pointInBorderBox) \|\| (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInParent))) {
	FloatPoint localPoint = valueOrDefault(localToParentTransform().inverse()).mapPoint(FloatPoint(pointInParent));

	for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
	// FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
	if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
	updateHitTestResult(result, pointInBorderBox);
	if (result.addNodeToListBasedTestResult(child->node(), request, locationInContainer) == HitTestProgress::Stop) {
	ASSERT(SVGHitTestCycleDetectionScope::isEmpty());
	return true;
	}
	}
	}
	}

	// If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit.
	if ((hitTestAction == HitTestBlockBackground \|\| hitTestAction == HitTestChildBlockBackground) && visibleToHitTesting(request)) {
	// Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
	// hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
	// to be able to detect hits on the background of a <div> element. If we'd return true here in the 'Foreground' phase, we are not able
	// to detect these hits anymore.
	LayoutRect boundsRect(accumulatedOffset + location(), size());
	if (locationInContainer.intersects(boundsRect)) {
	updateHitTestResult(result, pointInBorderBox);
	if (result.addNodeToListBasedTestResult(nodeForHitTest(), request, locationInContainer, boundsRect) == HitTestProgress::Stop)
	return true;
	}
	}

	ASSERT(SVGHitTestCycleDetectionScope::isEmpty());

	return false;
	}

	bool LegacyRenderSVGRoot::hasRelativeDimensions() const
	{
	return svgSVGElement().intrinsicHeight().isPercentOrCalculated() \|\| svgSVGElement().intrinsicWidth().isPercentOrCalculated();
	}

	void LegacyRenderSVGRoot::addResourceForClientInvalidation(RenderSVGResourceContainer* resource)
	{
	LegacyRenderSVGRoot* svgRoot = SVGRenderSupport::findTreeRootObject(*resource);
	if (!svgRoot)
	return;
	svgRoot->m_resourcesNeedingToInvalidateClients.add(resource);
	}

	}