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