Use enum classes and OptionSets for PaintPhase and PaintBehavior
[WebKit-https.git] / Source / WebCore / rendering / svg / RenderSVGRoot.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
3  * Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis@kde.org>
4  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
5  * Copyright (C) 2009 Google, Inc.
6  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "RenderSVGRoot.h"
26
27 #include "Frame.h"
28 #include "GraphicsContext.h"
29 #include "HitTestResult.h"
30 #include "LayoutRepainter.h"
31 #include "LayoutState.h"
32 #include "Page.h"
33 #include "RenderIterator.h"
34 #include "RenderLayer.h"
35 #include "RenderSVGResource.h"
36 #include "RenderSVGResourceContainer.h"
37 #include "RenderSVGResourceFilter.h"
38 #include "RenderTreeBuilder.h"
39 #include "RenderView.h"
40 #include "SVGImage.h"
41 #include "SVGRenderingContext.h"
42 #include "SVGResources.h"
43 #include "SVGResourcesCache.h"
44 #include "SVGSVGElement.h"
45 #include "SVGViewSpec.h"
46 #include "TransformState.h"
47 #include <wtf/IsoMallocInlines.h>
48 #include <wtf/StackStats.h>
49
50 namespace WebCore {
51
52 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderSVGRoot);
53
54 RenderSVGRoot::RenderSVGRoot(SVGSVGElement& element, RenderStyle&& style)
55     : RenderReplaced(element, WTFMove(style))
56     , m_objectBoundingBoxValid(false)
57     , m_isLayoutSizeChanged(false)
58     , m_needsBoundariesOrTransformUpdate(true)
59     , m_hasSVGShadow(false)
60     , m_hasBoxDecorations(false)
61 {
62 }
63
64 RenderSVGRoot::~RenderSVGRoot() = default;
65
66 SVGSVGElement& RenderSVGRoot::svgSVGElement() const
67 {
68     return downcast<SVGSVGElement>(nodeForNonAnonymous());
69 }
70
71 void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
72 {
73     // Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
74     // SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.
75
76     // The intrinsic aspect ratio of the viewport of SVG content is necessary for example, when including SVG from an ‘object’
77     // element in HTML styled with CSS. It is possible (indeed, common) for an SVG graphic to have an intrinsic aspect ratio but
78     // not to have an intrinsic width or height. The intrinsic aspect ratio must be calculated based upon the following rules:
79     // - The aspect ratio is calculated by dividing a width by a height.
80     // - If the ‘width’ and ‘height’ of the rootmost ‘svg’ element are both specified with unit identifiers (in, mm, cm, pt, pc,
81     //   px, em, ex) or in user units, then the aspect ratio is calculated from the ‘width’ and ‘height’ attributes after
82     //   resolving both values to user units.
83     intrinsicSize.setWidth(floatValueForLength(svgSVGElement().intrinsicWidth(), 0));
84     intrinsicSize.setHeight(floatValueForLength(svgSVGElement().intrinsicHeight(), 0));
85
86
87     if (!intrinsicSize.isEmpty())
88         intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
89     else {
90         // - If either/both of the ‘width’ and ‘height’ of the rootmost ‘svg’ element are in percentage units (or omitted), the
91         //   aspect ratio is calculated from the width and height values of the ‘viewBox’ specified for the current SVG document
92         //   fragment. If the ‘viewBox’ is not correctly specified, or set to 'none', the intrinsic aspect ratio cannot be
93         //   calculated and is considered unspecified.
94         FloatSize viewBoxSize = svgSVGElement().viewBox().size();
95         if (!viewBoxSize.isEmpty()) {
96             // The viewBox can only yield an intrinsic ratio, not an intrinsic size.
97             intrinsicRatio = viewBoxSize.width() / static_cast<double>(viewBoxSize.height());
98         }
99     }
100 }
101
102 bool RenderSVGRoot::isEmbeddedThroughSVGImage() const
103 {
104     return isInSVGImage(&svgSVGElement());
105 }
106
107 bool RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
108 {
109     // If our frame has an owner renderer, we're embedded through eg. object/embed/iframe,
110     // but we only negotiate if we're in an SVG document.
111     if (!frame().ownerRenderer())
112         return false;
113     return frame().document()->isSVGDocument();
114 }
115
116 LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
117 {
118     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
119     if (!m_containerSize.isEmpty())
120         return m_containerSize.width();
121
122     if (isEmbeddedThroughFrameContainingSVGDocument())
123         return containingBlock()->availableLogicalWidth();
124
125     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
126     return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
127 }
128
129 LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight(std::optional<LayoutUnit> estimatedUsedWidth) const
130 {
131     // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
132     if (!m_containerSize.isEmpty())
133         return m_containerSize.height();
134
135     if (isEmbeddedThroughFrameContainingSVGDocument())
136         return containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding);
137
138     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
139     return RenderReplaced::computeReplacedLogicalHeight(estimatedUsedWidth);
140 }
141
142 void RenderSVGRoot::layout()
143 {
144     StackStats::LayoutCheckPoint layoutCheckPoint;
145     ASSERT(needsLayout());
146
147     m_resourcesNeedingToInvalidateClients.clear();
148
149     // Arbitrary affine transforms are incompatible with LayoutState.
150     LayoutStateDisabler layoutStateDisabler(view().frameView().layoutContext());
151
152     bool needsLayout = selfNeedsLayout();
153     LayoutRepainter repainter(*this, checkForRepaintDuringLayout() && needsLayout);
154
155     LayoutSize oldSize = size();
156     updateLogicalWidth();
157     updateLogicalHeight();
158     buildLocalToBorderBoxTransform();
159
160     m_isLayoutSizeChanged = needsLayout || (svgSVGElement().hasRelativeLengths() && oldSize != size());
161     SVGRenderSupport::layoutChildren(*this, needsLayout || SVGRenderSupport::filtersForceContainerLayout(*this));
162
163     if (!m_resourcesNeedingToInvalidateClients.isEmpty()) {
164         // Invalidate resource clients, which may mark some nodes for layout.
165         for (auto& resource :  m_resourcesNeedingToInvalidateClients) {
166             resource->removeAllClientsFromCache();
167             SVGResourcesCache::clientStyleChanged(*resource, StyleDifference::Layout, resource->style());
168         }
169
170         m_isLayoutSizeChanged = false;
171         SVGRenderSupport::layoutChildren(*this, false);
172     }
173
174     // At this point LayoutRepainter already grabbed the old bounds,
175     // recalculate them now so repaintAfterLayout() uses the new bounds.
176     if (m_needsBoundariesOrTransformUpdate) {
177         updateCachedBoundaries();
178         m_needsBoundariesOrTransformUpdate = false;
179     }
180
181     clearOverflow();
182     if (!shouldApplyViewportClip()) {
183         FloatRect contentRepaintRect = repaintRectInLocalCoordinates();
184         contentRepaintRect = m_localToBorderBoxTransform.mapRect(contentRepaintRect);
185         addVisualOverflow(enclosingLayoutRect(contentRepaintRect));
186     }
187
188     updateLayerTransform();
189     m_hasBoxDecorations = isDocumentElementRenderer() ? hasVisibleBoxDecorationStyle() : hasVisibleBoxDecorations();
190     invalidateBackgroundObscurationStatus();
191
192     repainter.repaintAfterLayout();
193
194     clearNeedsLayout();
195 }
196
197 bool RenderSVGRoot::shouldApplyViewportClip() const
198 {
199     // the outermost svg is clipped if auto, and svg document roots are always clipped
200     // When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
201     // be applied, noting that the window scrollbars should be hidden if overflow=hidden.
202     return style().overflowX() == Overflow::Hidden
203         || style().overflowX() == Overflow::Auto
204         || style().overflowX() == Overflow::Scroll
205         || this->isDocumentElementRenderer();
206 }
207
208 void RenderSVGRoot::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
209 {
210     // An empty viewport disables rendering.
211     if (borderBoxRect().isEmpty())
212         return;
213
214     // Don't paint, if the context explicitly disabled it.
215     if (paintInfo.context().paintingDisabled())
216         return;
217
218     // SVG outlines are painted during PaintPhase::Foreground.
219     if (paintInfo.phase == PaintPhase::Outline || paintInfo.phase == PaintPhase::SelfOutline)
220         return;
221
222     // An empty viewBox also disables rendering.
223     // (http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute)
224     if (svgSVGElement().hasEmptyViewBox())
225         return;
226
227     // Don't paint if we don't have kids, except if we have filters we should paint those.
228     if (!firstChild()) {
229         auto* resources = SVGResourcesCache::cachedResourcesForRenderer(*this);
230         if (!resources || !resources->filter()) {
231             if (paintInfo.phase == PaintPhase::Foreground)
232                 page().addRelevantUnpaintedObject(this, visualOverflowRect());
233             return;
234         }
235     }
236
237     if (paintInfo.phase == PaintPhase::Foreground)
238         page().addRelevantRepaintedObject(this, visualOverflowRect());
239
240     // Make a copy of the PaintInfo because applyTransform will modify the damage rect.
241     PaintInfo childPaintInfo(paintInfo);
242     childPaintInfo.context().save();
243
244     // Apply initial viewport clip
245     if (shouldApplyViewportClip())
246         childPaintInfo.context().clip(snappedIntRect(overflowClipRect(paintOffset)));
247
248     // Convert from container offsets (html renderers) to a relative transform (svg renderers).
249     // Transform from our paint container's coordinate system to our local coords.
250     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
251     childPaintInfo.applyTransform(AffineTransform::translation(adjustedPaintOffset.x(), adjustedPaintOffset.y()) * localToBorderBoxTransform());
252
253     // SVGRenderingContext must be destroyed before we restore the childPaintInfo.context(), because a filter may have
254     // changed the context and it is only reverted when the SVGRenderingContext destructor finishes applying the filter.
255     {
256         SVGRenderingContext renderingContext;
257         bool continueRendering = true;
258         if (childPaintInfo.phase == PaintPhase::Foreground) {
259             renderingContext.prepareToRenderSVGContent(*this, childPaintInfo);
260             continueRendering = renderingContext.isRenderingPrepared();
261         }
262
263         if (continueRendering) {
264             childPaintInfo.updateSubtreePaintRootForChildren(this);
265             for (auto& child : childrenOfType<RenderElement>(*this))
266                 child.paint(childPaintInfo, location());
267         }
268     }
269
270     childPaintInfo.context().restore();
271 }
272
273 void RenderSVGRoot::willBeDestroyed()
274 {
275     RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot&>(*this));
276
277     SVGResourcesCache::clientDestroyed(*this);
278     RenderReplaced::willBeDestroyed();
279 }
280
281 void RenderSVGRoot::insertedIntoTree()
282 {
283     RenderReplaced::insertedIntoTree();
284     SVGResourcesCache::clientWasAddedToTree(*this);
285 }
286
287 void RenderSVGRoot::willBeRemovedFromTree()
288 {
289     SVGResourcesCache::clientWillBeRemovedFromTree(*this);
290     RenderReplaced::willBeRemovedFromTree();
291 }
292
293 void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
294 {
295     if (diff == StyleDifference::Layout)
296         setNeedsBoundariesUpdate();
297
298     // Box decorations may have appeared/disappeared - recompute status.
299     if (diff == StyleDifference::Repaint)
300         m_hasBoxDecorations = hasVisibleBoxDecorationStyle();
301
302     RenderReplaced::styleDidChange(diff, oldStyle);
303     SVGResourcesCache::clientStyleChanged(*this, diff, style());
304 }
305
306 // RenderBox methods will expect coordinates w/o any transforms in coordinates
307 // relative to our borderBox origin.  This method gives us exactly that.
308 void RenderSVGRoot::buildLocalToBorderBoxTransform()
309 {
310     float scale = style().effectiveZoom();
311     FloatPoint translate = svgSVGElement().currentTranslateValue();
312     LayoutSize borderAndPadding(borderLeft() + paddingLeft(), borderTop() + paddingTop());
313     m_localToBorderBoxTransform = svgSVGElement().viewBoxToViewTransform(contentWidth() / scale, contentHeight() / scale);
314     if (borderAndPadding.isZero() && scale == 1 && translate == FloatPoint::zero())
315         return;
316     m_localToBorderBoxTransform = AffineTransform(scale, 0, 0, scale, borderAndPadding.width() + translate.x(), borderAndPadding.height() + translate.y()) * m_localToBorderBoxTransform;
317 }
318
319 const AffineTransform& RenderSVGRoot::localToParentTransform() const
320 {
321     // Slightly optimized version of m_localToParentTransform = AffineTransform::translation(x(), y()) * m_localToBorderBoxTransform;
322     m_localToParentTransform = m_localToBorderBoxTransform;
323     if (x())
324         m_localToParentTransform.setE(m_localToParentTransform.e() + roundToInt(x()));
325     if (y())
326         m_localToParentTransform.setF(m_localToParentTransform.f() + roundToInt(y()));
327     return m_localToParentTransform;
328 }
329
330 LayoutRect RenderSVGRoot::clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const
331 {
332     if (style().visibility() != Visibility::Visible && !enclosingLayer()->hasVisibleContent())
333         return LayoutRect();
334
335     FloatRect contentRepaintRect = m_localToBorderBoxTransform.mapRect(repaintRectInLocalCoordinates());
336     contentRepaintRect.intersect(snappedIntRect(borderBoxRect()));
337
338     LayoutRect repaintRect = enclosingLayoutRect(contentRepaintRect);
339     if (m_hasBoxDecorations || hasRenderOverflow())
340         repaintRect.unite(unionRect(localSelectionRect(false), visualOverflowRect()));
341
342     return RenderReplaced::computeRectForRepaint(enclosingIntRect(repaintRect), repaintContainer);
343 }
344
345 FloatRect RenderSVGRoot::computeFloatRectForRepaint(const FloatRect& repaintRect, const RenderLayerModelObject* repaintContainer, bool fixed) const
346 {
347     // Apply our local transforms (except for x/y translation), then our shadow, 
348     // and then call RenderBox's method to handle all the normal CSS Box model bits
349     FloatRect adjustedRect = m_localToBorderBoxTransform.mapRect(repaintRect);
350
351     const SVGRenderStyle& svgStyle = style().svgStyle();
352     if (const ShadowData* shadow = svgStyle.shadow())
353         shadow->adjustRectForShadow(adjustedRect);
354
355     // Apply initial viewport clip
356     if (shouldApplyViewportClip())
357         adjustedRect.intersect(snappedIntRect(borderBoxRect()));
358
359     if (m_hasBoxDecorations || hasRenderOverflow()) {
360         // The selectionRect can project outside of the overflowRect, so take their union
361         // for repainting to avoid selection painting glitches.
362         LayoutRect decoratedRepaintRect = unionRect(localSelectionRect(false), visualOverflowRect());
363         adjustedRect.unite(decoratedRepaintRect);
364     }
365     return RenderReplaced::computeRectForRepaint(enclosingIntRect(adjustedRect), repaintContainer, {fixed, false});
366 }
367
368 // This method expects local CSS box coordinates.
369 // Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
370 // to convert from SVG viewport coordinates to local CSS box coordinates.
371 void RenderSVGRoot::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
372 {
373     ASSERT(mode & ~IsFixed); // We should have no fixed content in the SVG rendering tree.
374     ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
375
376     RenderReplaced::mapLocalToContainer(repaintContainer, transformState, mode | ApplyContainerFlip, wasFixed);
377 }
378
379 const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
380 {
381     return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
382 }
383
384 void RenderSVGRoot::updateCachedBoundaries()
385 {
386     SVGRenderSupport::computeContainerBoundingBoxes(*this, m_objectBoundingBox, m_objectBoundingBoxValid, m_strokeBoundingBox, m_repaintBoundingBoxExcludingShadow);
387     SVGRenderSupport::intersectRepaintRectWithResources(*this, m_repaintBoundingBoxExcludingShadow);
388     m_repaintBoundingBoxExcludingShadow.inflate(horizontalBorderAndPaddingExtent());
389
390     m_repaintBoundingBox = m_repaintBoundingBoxExcludingShadow;
391     SVGRenderSupport::intersectRepaintRectWithShadows(*this, m_repaintBoundingBox);
392 }
393
394 bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
395 {
396     LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);
397     LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());
398
399     // Test SVG content if the point is in our content box or it is inside the visualOverflowRect and the overflow is visible.
400     // FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
401     if (contentBoxRect().contains(pointInBorderBox) || (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInParent))) {
402         FloatPoint localPoint = localToParentTransform().inverse().value_or(AffineTransform()).mapPoint(FloatPoint(pointInParent));
403
404         for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
405             // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
406             if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) {
407                 updateHitTestResult(result, pointInBorderBox);
408                 if (result.addNodeToListBasedTestResult(child->node(), request, locationInContainer) == HitTestProgress::Stop)
409                     return true;
410             }
411         }
412     }
413
414     // 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.
415     if ((hitTestAction == HitTestBlockBackground || hitTestAction == HitTestChildBlockBackground) && visibleToHitTesting()) {
416         // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase,
417         // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need
418         // 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 
419         // to detect these hits anymore.
420         LayoutRect boundsRect(accumulatedOffset + location(), size());
421         if (locationInContainer.intersects(boundsRect)) {
422             updateHitTestResult(result, pointInBorderBox);
423             if (result.addNodeToListBasedTestResult(&svgSVGElement(), request, locationInContainer, boundsRect) == HitTestProgress::Stop)
424                 return true;
425         }
426     }
427
428     return false;
429 }
430
431 bool RenderSVGRoot::hasRelativeDimensions() const
432 {
433     return svgSVGElement().intrinsicHeight().isPercentOrCalculated() || svgSVGElement().intrinsicWidth().isPercentOrCalculated();
434 }
435
436 void RenderSVGRoot::addResourceForClientInvalidation(RenderSVGResourceContainer* resource)
437 {
438     RenderSVGRoot* svgRoot = SVGRenderSupport::findTreeRootObject(*resource);
439     if (!svgRoot)
440         return;
441     svgRoot->m_resourcesNeedingToInvalidateClients.add(resource);
442 }
443
444 }