Changeset 64275 in webkit

Timestamp:

Jul 29, 2010 6:50:51 AM (14 years ago)

Author:

Nikolas Zimmermann

Message:

2010-07-29 Nikolas Zimmermann <​nzimmermann@rim.com>

Reviewed by Dirk Schulze.

WebKit shouldn't ignore resource cycles, but break them as Opera does
​https://bugs.webkit.org/show_bug.cgi?id=43031

mask images are not updated when render objects' bounds change
​https://bugs.webkit.org/show_bug.cgi?id=15124

SVG Gradients do not resize correctly
​https://bugs.webkit.org/show_bug.cgi?id=41902

svg/dynamic-updates: SVGMarkerElement markerHeight/Width tests are broken
​https://bugs.webkit.org/show_bug.cgi?id=42616

svg/dynamic-updates: SVGMaskElement tests are all broken
​https://bugs.webkit.org/show_bug.cgi?id=42617

Don't ignore resources containing cyclic references, but break them, as discussed on SVG WG mailing lists - to be compatible with Opera which already does that.

We used to lookup RenderSVGResourceContainers objects, by extracting the URI reference from the SVGRenderStyle, then utilizing getElementById() to lookup the
node, and access its renderer. Opera ignores such references, if they point to resources that contain cyclic references. Ignoring them would mean we have
to mutate the render style to empty the resource strings. That obviously doesn't work, as it would break expectations (getComputedStyle, etc.).

Introduce a SVGResources class that stores pointers to all resources, that can be applied to a RenderObject (clipper/filter/markers/masker).
Add a SVGResourcesCache class, which is basically a HashMap<RenderObject*, SVGResources*>. Whenever a RenderObject receives style, we extract the URI references
from the SVGRenderStyle, look up the RenderSVGResourceContainer* objects, and store them in a SVGResources* class. Then we execute a cycle detection logic,
which detects cyclic references and breaks them. Breaking them means just nulling the pointer to the resource in the SVGResources object. Those SVGResources
objects are cached, and used throughout the render tree to access resources. This way it's guaranteed that all cyclic references are resolved until layout/paint
phase begins.

Add destroy/styleDidChange/updateFromElement methods to all SVG renderers, in order to keep track of resource/client changes in the SVGResourcesCache.
As side-effect the SVGResourcesCache now knows which RenderObject references which resource, and thus can handle client registration for a RenderSVGResourceContainer.
The RenderSVGResourceContainer now holds a HashSet of RenderObjects, that's always up2date, and not related to the fact wheter a resources has already been used
for painting. The old logic missed to register clients for a resource, when the resource was in an invalid state. Fixing that fixes the svg/dynamic-updates/SVGMaskElement* tests.

Rewrite all svg/custom/recursive-(filter|gradient|mask|pattern).svg tests to contain a reference image how it should be renderered. All 1:1 compatible with Opera now.

• rendering/RenderForeignObject.cpp: (WebCore::RenderForeignObject::layout): Grab selfNeedsLayout() before calling RenderBlock::layout(), otherwhise it's always false.
• rendering/RenderPath.cpp: Don't look up resources manually, use SVGResourcesCache. (WebCore::RenderPath::fillContains): Remove constness, to avoid the need to pass around const RenderObjects* to the SVGResourcesCache. (WebCore::RenderPath::strokeContains): Ditto. (WebCore::RenderPath::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/. (WebCore::RenderPath::calculateMarkerBoundsIfNeeded): Remove special client handling for markers, it's all unified now. (WebCore::RenderPath::styleWillChange): Only call setNeedsBoundariesUpdate when handling StyleDifferenceRepaint/Layout.
• rendering/RenderPath.h:
• rendering/RenderSVGBlock.cpp: (WebCore::RenderSVGBlock::destroy): Forward to SVGResourcesCache::clientDestroyed. (WebCore::RenderSVGBlock::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged. (WebCore::RenderSVGBlock::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
• rendering/RenderSVGBlock.h:
• rendering/RenderSVGContainer.cpp: (WebCore::RenderSVGContainer::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/. (WebCore::RenderSVGContainer::selfWillPaint): Don't look up resources manually, use SVGResourcesCache.
• rendering/RenderSVGContainer.h:
• rendering/RenderSVGGradientStop.cpp: (WebCore::RenderSVGGradientStop::styleDidChange): Rewrite, as invalidateResourceClients() is gone.
• rendering/RenderSVGHiddenContainer.h: Make layout() protected, as RenderSVGResourceContainer overrides it.
• rendering/RenderSVGImage.cpp: (WebCore::RenderSVGImage::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/. (WebCore::RenderSVGImage::destroy): Forward to SVGResourcesCache::clientDestroyed. (WebCore::RenderSVGImage::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged. (WebCore::RenderSVGImage::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement. (WebCore::RenderSVGImage::imageChanged): Don't look up resources manually, use SVGResourcesCache.
• rendering/RenderSVGImage.h:
• rendering/RenderSVGInline.cpp: (WebCore::RenderSVGInline::destroy): Forward to SVGResourcesCache::clientDestroyed. (WebCore::RenderSVGInline::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged. (WebCore::RenderSVGInline::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
• rendering/RenderSVGInline.h:
• rendering/RenderSVGModelObject.cpp: (WebCore::RenderSVGModelObject::destroy): Forward to SVGResourcesCache::clientDestroyed. (WebCore::RenderSVGModelObject::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged. (WebCore::RenderSVGModelObject::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
• rendering/RenderSVGModelObject.h:
• rendering/RenderSVGResource.cpp: (WebCore::RenderSVGResource::fillPaintingResource): Remove const from RenderObject parameter. (WebCore::RenderSVGResource::strokePaintingResource): Ditto. (WebCore::RenderSVGResource::markForLayoutAndParentResourceInvalidation): Early exit if we found the first parent resource.
• rendering/RenderSVGResource.h:
• rendering/RenderSVGResourceClipper.cpp: (WebCore::RenderSVGResourceClipper::~RenderSVGResourceClipper): Early exit if m_clipper is empty. (WebCore::RenderSVGResourceClipper::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourceClipper::invalidateClient): Ditto. (WebCore::RenderSVGResourceClipper::applyResource): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore. (WebCore::RenderSVGResourceClipper::createClipData): Don't look up resources manually, use SVGResourcesCache. (WebCore::RenderSVGResourceClipper::hitTestClipContent): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
• rendering/RenderSVGResourceClipper.h:
• rendering/RenderSVGResourceContainer.cpp: (WebCore::svgExtensionsFromNode): (WebCore::RenderSVGResourceContainer::RenderSVGResourceContainer): Stop registering resource from the constructor, delegate to styleDidChange. (WebCore::RenderSVGResourceContainer::~RenderSVGResourceContainer): Only deregister resource if it was ever registered. (WebCore::RenderSVGResourceContainer::layout): invalidateClients() here, to avoid the need for invalidateResourceClients() in the SVG DOM. Just call setNeedsLayout() from the SVG DOM. (WebCore::RenderSVGResourceContainer::destroy): Forward to SVGResourcesCache::resourceDestroyed. (WebCore::RenderSVGResourceContainer::styleDidChange): Register resource not in the constructor but when it first receives style. (WebCore::RenderSVGResourceContainer::idChanged): Don't duplicate code, use existing methods from SVGResourcesCache. (WebCore::RenderSVGResourceContainer::markAllClientsForInvalidation): Add new helper function, to share code between all resources. (WebCore::RenderSVGResourceContainer::markClientForInvalidation): Ditto. (WebCore::RenderSVGResourceContainer::addClient): SVGResourcesCache now manages the list of clients. It calls addClient() for each RenderObject that uses this resource. (WebCore::RenderSVGResourceContainer::removeClient): SVGResourcesCache now manages the list of clients. (WebCore::RenderSVGResourceContainer::registerResource): New helper function sharing code between idChanged / styleDidChange. (WebCore::RenderSVGResourceContainer::transformOnNonScalingStroke): Add FIXME that the function is misplaced.
• rendering/RenderSVGResourceContainer.h: Move most functions to the new RenderSVGResourceContainer.cpp file.
• rendering/RenderSVGResourceFilter.cpp: (WebCore::RenderSVGResourceFilter::~RenderSVGResourceFilter): Early exit if m_filter is empty. (WebCore::RenderSVGResourceFilter::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourceFilter::invalidateClient): Ditto.
• rendering/RenderSVGResourceGradient.cpp: (WebCore::RenderSVGResourceGradient::~RenderSVGResourceGradient): Early exit if m_gradient is empty. (WebCore::RenderSVGResourceGradient::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourceGradient::invalidateClient): Ditto.
• rendering/RenderSVGResourceMarker.cpp: (WebCore::RenderSVGResourceMarker::~RenderSVGResourceMarker): Now a no-op, markers are unified within the new client handling concept, no more special code needed. (WebCore::RenderSVGResourceMarker::layout): As RenderSVGResourceMarker skips the RenderSVGResourceContainer::layout() method, we also need to call invalidateClients() here. (WebCore::RenderSVGResourceMarker::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourceMarker::invalidateClient): Ditto. (WebCore::RenderSVGResourceMarker::draw): Remove marker specific logic to catch circular references.
• rendering/RenderSVGResourceMarker.h:
• rendering/RenderSVGResourceMasker.cpp: (WebCore::RenderSVGResourceMasker::~RenderSVGResourceMasker): Early exit if m_masker is empty. (WebCore::RenderSVGResourceMasker::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourceMasker::invalidateClient): Ditto. (WebCore::RenderSVGResourceMasker::applyResource): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
• rendering/RenderSVGResourceMasker.h:
• rendering/RenderSVGResourcePattern.cpp: (WebCore::RenderSVGResourcePattern::~RenderSVGResourcePattern): Early exit if m_pattern is empty. (WebCore::RenderSVGResourcePattern::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer. (WebCore::RenderSVGResourcePattern::invalidateClient): Ditto. (WebCore::RenderSVGResourcePattern::createTileImage): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
• rendering/RenderSVGResourcePattern.h:
• rendering/RenderSVGRoot.cpp: (WebCore::RenderSVGRoot::selfWillPaint): Don't look up resources manually, use SVGResourcesCache. (WebCore::RenderSVGRoot::destroy): Forward to SVGResourcesCache::clientDestroyed. (WebCore::RenderSVGRoot::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged. (WebCore::RenderSVGRoot::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
• rendering/RenderSVGRoot.h:
• rendering/RenderSVGText.cpp: (WebCore::RenderSVGText::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/.
• rendering/RenderSVGText.h:
• rendering/SVGInlineTextBox.cpp: (WebCore::SVGInlineTextBox::acquirePaintingResource): Add RenderObject* parameter, don't assume the style comes from the InlineTextBox parent renderer. (WebCore::SVGInlineTextBox::prepareGraphicsContextForTextPainting): Pass the parent()->renderer() to acquirePaintingResource. (WebCore::SVGInlineTextBox::paintDecoration): Pass the decoration renderer to acquirePaintingResource. (WebCore::SVGInlineTextBox::paintDecorationWithStyle): Ditto. (WebCore::SVGInlineTextBox::paintText): When a selection pseudo style is used to paint the selection, swap styles in the SVGResourcesCache, to take the right resources when painting.
• rendering/SVGInlineTextBox.h:
• rendering/SVGRenderSupport.cpp: (WebCore::SVGRenderSupport::prepareToRenderSVGContent): Don't look up resources manually, use SVGResourcesCache. (WebCore::SVGRenderSupport::finishRenderSVGContent): Ditto. (WebCore::SVGRenderSupport::intersectRepaintRectWithResources): Ditto. (WebCore::SVGRenderSupport::pointInClippingArea): Remove const from RenderObject parameter.
• rendering/SVGRenderSupport.h:
• rendering/SVGRenderTreeAsText.cpp: (WebCore::writeStyle): Add two const_cast now that fill/strokePaintingResource take RenderObject* parameters. This was the less intrusive approach, otherwhise more const_casts would be needed. (WebCore::writeResources): Add FIXME that we should dump the resources present in the SVGResourcesCache instead of manually looking them up from the SVGRenderStyle, to avoid dumping cycles.
• rendering/SVGResourcesCache.cpp: (WebCore::SVGResourcesCache::clientStyleChanged): Use markForLayoutAndParentResourceInvalidation() instead of duplicating code.
• rendering/SVGResourcesCycleSolver.cpp: (WebCore::setFollowLinkForChainableResource): Implemented stub method.
• rendering/style/SVGRenderStyle.cpp: (WebCore::SVGRenderStyle::diff): Return StyleDifferenceLayout, not Repaint for stroke paint changes, otherwhise the cached boundaries are not correctly updated.
• svg/SVGClipPathElement.cpp: (WebCore::SVGClipPathElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGClipPathElement::childrenChanged): Ditto.
• svg/SVGClipPathElement.h: (WebCore::SVGClipPathElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
• svg/SVGElement.cpp: (WebCore::SVGElement::insertedIntoDocument): Only execute buildPendingResource() logic, if needsPendingResourceHandling() returns true. Cleaned up code a bit, to deploy early returns.
• svg/SVGElement.h: (WebCore::SVGElement::needsPendingResourceHandling): Return true (default). Only needed by SVGTextPathElement/SVGUseElement, and should be removed in future.
• svg/SVGFilterElement.cpp: (WebCore::SVGFilterElement::SVGFilterElement): Initialize m_followLink=true. (WebCore::SVGFilterElement::setFilterRes): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGFilterElement::svgAttributeChanged): Ditto. (WebCore::SVGFilterElement::childrenChanged): Ditto.
• svg/SVGFilterElement.h: (WebCore::SVGFilterElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer. (WebCore::SVGFilterElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
• svg/SVGFilterPrimitiveStandardAttributes.cpp: (WebCore::SVGFilterPrimitiveStandardAttributes::childrenChanged): Don't use invalidateResourceClients(), it's a no-op as effects don't have a renderer -> use invalidateFilter().
• svg/SVGFilterPrimitiveStandardAttributes.h: (WebCore::SVGFilterPrimitiveStandardAttributes::invalidateFilter): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
• svg/SVGGradientElement.cpp: (WebCore::SVGGradientElement::SVGGradientElement): Initialize m_followLink=true. (WebCore::SVGGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGGradientElement::childrenChanged): Ditto.
• svg/SVGGradientElement.h: (WebCore::SVGGradientElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer. (WebCore::SVGGradientElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
• svg/SVGLinearGradientElement.cpp: (WebCore::SVGLinearGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGLinearGradientElement::collectGradientProperties): Only follow xlink:href links if m_followLinks == true.
• svg/SVGMarkerElement.cpp: (WebCore::SVGMarkerElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGMarkerElement::childrenChanged): Ditto. (WebCore::SVGMarkerElement::setOrientToAuto): Ditto. (WebCore::SVGMarkerElement::setOrientToAngle): Ditto.
• svg/SVGMarkerElement.h: (WebCore::SVGMarkerElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
• svg/SVGMaskElement.cpp: (WebCore::SVGMaskElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGMaskElement::childrenChanged): Ditto.
• svg/SVGMaskElement.h: (WebCore::SVGMaskElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
• svg/SVGPatternElement.cpp: (WebCore::SVGPatternElement::SVGPatternElement): Initialize m_followLink=true. (WebCore::SVGPatternElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGPatternElement::childrenChanged): Ditto. (WebCore::SVGPatternElement::collectPatternProperties): Only follow xlink:href links if m_followLinks == true.
• svg/SVGPatternElement.h: (WebCore::SVGPatternElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer. (WebCore::SVGPatternElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
• svg/SVGRadialGradientElement.cpp: (WebCore::SVGRadialGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer. (WebCore::SVGRadialGradientElement::collectGradientProperties): Only follow xlink:href links if m_followLinks == true.
• svg/SVGStyledElement.cpp: (WebCore::SVGStyledElement::attach): Call updateFromElement upon attach(), needed by all resource renderers. Defaults to a no-op in RenderObject.h
• svg/SVGStyledElement.h: Remove invalidateResourceClients(), it's not needed anymore.

2010-07-29 Nikolas Zimmermann <​nzimmermann@rim.com>

Reviewed by Dirk Schulze.

WebKit shouldn't ignore resource cycles, but break them as Opera does
​https://bugs.webkit.org/show_bug.cgi?id=43031

Rebaseline results now that cycles are broken, instead of ignored.

• platform/mac/svg/clip-path/clip-path-recursive-call-by-child-expected.txt:
• platform/mac/svg/clip-path/clip-path-recursive-call-expected.checksum:
• platform/mac/svg/clip-path/clip-path-recursive-call-expected.png:
• platform/mac/svg/custom/circular-marker-reference-4-expected.txt:
• platform/mac/svg/custom/gradient-cycle-detection-expected.checksum:
• platform/mac/svg/custom/gradient-cycle-detection-expected.png:
• platform/mac/svg/custom/recursive-clippath-expected.checksum:
• platform/mac/svg/custom/recursive-clippath-expected.png:
• platform/mac/svg/custom/recursive-clippath-expected.txt:
• platform/mac/svg/custom/recursive-filter-expected.checksum:
• platform/mac/svg/custom/recursive-filter-expected.png:
• platform/mac/svg/custom/recursive-filter-expected.txt:
• platform/mac/svg/custom/recursive-gradient-expected.checksum:
• platform/mac/svg/custom/recursive-gradient-expected.png:
• platform/mac/svg/custom/recursive-gradient-expected.txt:
• platform/mac/svg/custom/recursive-mask-expected.checksum:
• platform/mac/svg/custom/recursive-mask-expected.png:
• platform/mac/svg/custom/recursive-mask-expected.txt:
• platform/mac/svg/custom/recursive-pattern-expected.checksum:
• platform/mac/svg/custom/recursive-pattern-expected.png:
• platform/mac/svg/custom/recursive-pattern-expected.txt:
• platform/mac/svg/custom/use-events-crash-expected.txt:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.png:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.checksum:
• platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.png:
• platform/mac/svg/hixie/error/017-expected.txt:
• svg/clip-path/clip-path-recursive-call-by-child.svg: Rewrite test to match expectations, now that cycles are broken, not ignored. Looks like in Opera.
• svg/custom/js-late-clipPath-and-object-creation.svg: Don't update from within the onload event, instead use zero-ms timeouts, to test updating reliable. It failed before this patch.
• svg/custom/js-late-clipPath-creation.svg: Ditto.
• svg/custom/js-late-gradient-and-object-creation.svg: Ditto.
• svg/custom/js-late-gradient-creation.svg: Ditto.
• svg/custom/js-late-marker-and-object-creation.svg: Ditto.
• svg/custom/js-late-marker-creation.svg: Ditto.
• svg/custom/js-late-mask-and-object-creation.svg: Ditto.
• svg/custom/js-late-mask-creation.svg: Ditto.
• svg/custom/js-late-pattern-and-object-creation.svg: Ditto.
• svg/custom/js-late-pattern-creation.svg: Ditto.
• svg/custom/recursive-clippath.svg: Add a reference rendering, side by side to the test, for the ease of comparision. Passes in WebKit + Opera.
• svg/custom/recursive-filter.svg: Ditto.
• svg/custom/recursive-gradient.svg: Ditto.
• svg/custom/recursive-mask.svg: Ditto.
• svg/custom/recursive-pattern.svg: Ditto.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/platform/mac/svg/clip-path/clip-path-recursive-call-by-child-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/clip-path/clip-path-recursive-call-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/clip-path/clip-path-recursive-call-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/circular-marker-reference-4-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/gradient-cycle-detection-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/gradient-cycle-detection-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-clippath-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-clippath-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-clippath-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-filter-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-filter-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-filter-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-gradient-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-gradient-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-gradient-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-mask-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-mask-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-mask-expected.txt (modified) (2 diffs)
• LayoutTests/platform/mac/svg/custom/recursive-pattern-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/recursive-pattern-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/custom/recursive-pattern-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/custom/use-events-crash-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.checksum (modified) (1 diff)
• LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.png (modified) (previous)
• LayoutTests/platform/mac/svg/hixie/error/017-expected.txt (modified) (1 diff)
• LayoutTests/svg/clip-path/clip-path-recursive-call-by-child.svg (modified) (1 diff)
• LayoutTests/svg/custom/js-late-clipPath-and-object-creation.svg (modified) (3 diffs)
• LayoutTests/svg/custom/js-late-clipPath-creation.svg (modified) (3 diffs)
• LayoutTests/svg/custom/js-late-gradient-and-object-creation.svg (modified) (1 diff)
• LayoutTests/svg/custom/js-late-gradient-creation.svg (modified) (1 diff)
• LayoutTests/svg/custom/js-late-marker-and-object-creation.svg (modified) (4 diffs)
• LayoutTests/svg/custom/js-late-marker-creation.svg (modified) (3 diffs)
• LayoutTests/svg/custom/js-late-mask-and-object-creation.svg (modified) (4 diffs)
• LayoutTests/svg/custom/js-late-mask-creation.svg (modified) (3 diffs)
• LayoutTests/svg/custom/js-late-pattern-and-object-creation.svg (modified) (1 diff)
• LayoutTests/svg/custom/js-late-pattern-creation.svg (modified) (1 diff)
• LayoutTests/svg/custom/recursive-clippath.svg (modified) (2 diffs)
• LayoutTests/svg/custom/recursive-filter.svg (modified) (1 diff)
• LayoutTests/svg/custom/recursive-gradient.svg (modified) (1 diff)
• LayoutTests/svg/custom/recursive-mask.svg (modified) (2 diffs)
• LayoutTests/svg/custom/recursive-pattern.svg (modified) (2 diffs)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/rendering/RenderForeignObject.cpp (modified) (1 diff)
• WebCore/rendering/RenderPath.cpp (modified) (6 diffs)
• WebCore/rendering/RenderPath.h (modified) (1 diff)
• WebCore/rendering/RenderSVGBlock.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGBlock.h (modified) (1 diff)
• WebCore/rendering/RenderSVGContainer.cpp (modified) (3 diffs)
• WebCore/rendering/RenderSVGContainer.h (modified) (1 diff)
• WebCore/rendering/RenderSVGGradientStop.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGHiddenContainer.h (modified) (2 diffs)
• WebCore/rendering/RenderSVGImage.cpp (modified) (4 diffs)
• WebCore/rendering/RenderSVGImage.h (modified) (1 diff)
• WebCore/rendering/RenderSVGInline.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGInline.h (modified) (1 diff)
• WebCore/rendering/RenderSVGModelObject.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGModelObject.h (modified) (1 diff)
• WebCore/rendering/RenderSVGResource.cpp (modified) (7 diffs)
• WebCore/rendering/RenderSVGResource.h (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceClipper.cpp (modified) (8 diffs)
• WebCore/rendering/RenderSVGResourceClipper.h (modified) (1 diff)
• WebCore/rendering/RenderSVGResourceContainer.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceContainer.h (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceFilter.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceGradient.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceMarker.cpp (modified) (5 diffs)
• WebCore/rendering/RenderSVGResourceMarker.h (modified) (2 diffs)
• WebCore/rendering/RenderSVGResourceMasker.cpp (modified) (4 diffs)
• WebCore/rendering/RenderSVGResourceMasker.h (modified) (1 diff)
• WebCore/rendering/RenderSVGResourcePattern.cpp (modified) (3 diffs)
• WebCore/rendering/RenderSVGResourcePattern.h (modified) (1 diff)
• WebCore/rendering/RenderSVGRoot.cpp (modified) (3 diffs)
• WebCore/rendering/RenderSVGRoot.h (modified) (2 diffs)
• WebCore/rendering/RenderSVGText.cpp (modified) (2 diffs)
• WebCore/rendering/RenderSVGText.h (modified) (1 diff)
• WebCore/rendering/SVGInlineTextBox.cpp (modified) (6 diffs)
• WebCore/rendering/SVGInlineTextBox.h (modified) (2 diffs)
• WebCore/rendering/SVGRenderSupport.cpp (modified) (5 diffs)
• WebCore/rendering/SVGRenderSupport.h (modified) (1 diff)
• WebCore/rendering/SVGRenderTreeAsText.cpp (modified) (3 diffs)
• WebCore/rendering/SVGResourcesCache.cpp (modified) (1 diff)
• WebCore/rendering/SVGResourcesCycleSolver.cpp (modified) (1 diff)
• WebCore/rendering/style/SVGRenderStyle.cpp (modified) (2 diffs)
• WebCore/svg/SVGClipPathElement.cpp (modified) (3 diffs)
• WebCore/svg/SVGClipPathElement.h (modified) (1 diff)
• WebCore/svg/SVGElement.cpp (modified) (1 diff)
• WebCore/svg/SVGElement.h (modified) (1 diff)
• WebCore/svg/SVGFilterElement.cpp (modified) (5 diffs)
• WebCore/svg/SVGFilterElement.h (modified) (2 diffs)
• WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp (modified) (1 diff)
• WebCore/svg/SVGFilterPrimitiveStandardAttributes.h (modified) (1 diff)
• WebCore/svg/SVGGradientElement.cpp (modified) (4 diffs)
• WebCore/svg/SVGGradientElement.h (modified) (2 diffs)
• WebCore/svg/SVGLinearGradientElement.cpp (modified) (2 diffs)
• WebCore/svg/SVGMarkerElement.cpp (modified) (5 diffs)
• WebCore/svg/SVGMarkerElement.h (modified) (1 diff)
• WebCore/svg/SVGMaskElement.cpp (modified) (3 diffs)
• WebCore/svg/SVGMaskElement.h (modified) (1 diff)
• WebCore/svg/SVGPatternElement.cpp (modified) (5 diffs)
• WebCore/svg/SVGPatternElement.h (modified) (2 diffs)
• WebCore/svg/SVGRadialGradientElement.cpp (modified) (2 diffs)
• WebCore/svg/SVGStyledElement.cpp (modified) (1 diff)
• WebCore/svg/SVGStyledElement.h (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2010-07-29  Nikolas Zimmermann  <nzimmermann@rim.com>
+
+        Reviewed by Dirk Schulze.
+
+        WebKit shouldn't ignore resource cycles, but break them as Opera does
+        https://bugs.webkit.org/show_bug.cgi?id=43031
+
+        Rebaseline results now that cycles are broken, instead of ignored.
+
+        * platform/mac/svg/clip-path/clip-path-recursive-call-by-child-expected.txt:
+        * platform/mac/svg/clip-path/clip-path-recursive-call-expected.checksum:
+        * platform/mac/svg/clip-path/clip-path-recursive-call-expected.png:
+        * platform/mac/svg/custom/circular-marker-reference-4-expected.txt:
+        * platform/mac/svg/custom/gradient-cycle-detection-expected.checksum:
+        * platform/mac/svg/custom/gradient-cycle-detection-expected.png:
+        * platform/mac/svg/custom/recursive-clippath-expected.checksum:
+        * platform/mac/svg/custom/recursive-clippath-expected.png:
+        * platform/mac/svg/custom/recursive-clippath-expected.txt:
+        * platform/mac/svg/custom/recursive-filter-expected.checksum:
+        * platform/mac/svg/custom/recursive-filter-expected.png:
+        * platform/mac/svg/custom/recursive-filter-expected.txt:
+        * platform/mac/svg/custom/recursive-gradient-expected.checksum:
+        * platform/mac/svg/custom/recursive-gradient-expected.png:
+        * platform/mac/svg/custom/recursive-gradient-expected.txt:
+        * platform/mac/svg/custom/recursive-mask-expected.checksum:
+        * platform/mac/svg/custom/recursive-mask-expected.png:
+        * platform/mac/svg/custom/recursive-mask-expected.txt:
+        * platform/mac/svg/custom/recursive-pattern-expected.checksum:
+        * platform/mac/svg/custom/recursive-pattern-expected.png:
+        * platform/mac/svg/custom/recursive-pattern-expected.txt:
+        * platform/mac/svg/custom/use-events-crash-expected.txt:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.png:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.checksum:
+        * platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.png:
+        * platform/mac/svg/hixie/error/017-expected.txt:
+        * svg/clip-path/clip-path-recursive-call-by-child.svg: Rewrite test to match expectations, now that cycles are broken, not ignored. Looks like in Opera.
+        * svg/custom/js-late-clipPath-and-object-creation.svg: Don't update from within the onload event, instead use zero-ms timeouts, to test updating reliable. It failed before this patch.
+        * svg/custom/js-late-clipPath-creation.svg: Ditto.
+        * svg/custom/js-late-gradient-and-object-creation.svg: Ditto.
+        * svg/custom/js-late-gradient-creation.svg: Ditto.
+        * svg/custom/js-late-marker-and-object-creation.svg: Ditto.
+        * svg/custom/js-late-marker-creation.svg: Ditto.
+        * svg/custom/js-late-mask-and-object-creation.svg: Ditto.
+        * svg/custom/js-late-mask-creation.svg: Ditto.
+        * svg/custom/js-late-pattern-and-object-creation.svg: Ditto.
+        * svg/custom/js-late-pattern-creation.svg: Ditto.
+        * svg/custom/recursive-clippath.svg: Add a reference rendering, side by side to the test, for the ease of comparision. Passes in WebKit + Opera.
+        * svg/custom/recursive-filter.svg: Ditto.
+        * svg/custom/recursive-gradient.svg: Ditto.
+        * svg/custom/recursive-mask.svg: Ditto.
+        * svg/custom/recursive-pattern.svg: Ditto.
+
 2010-07-21 Antonio Gomes  <tonikitoo@webkit.org> , Grace Kloba  <klobag@gmail.com>
 

trunk/LayoutTests/platform/mac/svg/clip-path/clip-path-recursive-call-by-child-expected.txt

@@ -5 +5 @@
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
       RenderSVGResourceClipper {clipPath} [id="clip"] [clipPathUnits=userSpaceOnUse]
-        RenderPath {rect} at (0,0) size 100x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L100.00,0.00 L100.00,50.00 L0.00,50.00 Z"]
-          [clipPath="clip"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x50
+        RenderPath {rect} at (0,0) size 100x100 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+          [clipPath="clip"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x100
     RenderPath {rect} at (0,0) size 100x100 [fill={[type=SOLID] [color=#FF0000]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-    RenderPath {rect} at (0,0) size 100x50 [fill={[type=SOLID] [color=#008000]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      [clipPath="clip"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x50
+    RenderPath {rect} at (0,0) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+      [clipPath="clip"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x100

trunk/LayoutTests/platform/mac/svg/clip-path/clip-path-recursive-call-expected.checksum

@@ -1 @@
-853de00567d121bea0b7bece66a5d61c
+778803df0a824ed8f2c7dfa07c56832e

trunk/LayoutTests/platform/mac/svg/custom/circular-marker-reference-4-expected.txt

@@ -6 +6 @@
       RenderPath {path} at (310,240) size 180x60 [stroke={[type=SOLID] [color=#000000] [line cap=ROUND]}] [fill={[type=SOLID] [color=#000000]}] [start marker=mark2] [middle marker=mark2] [end marker=mark2] [data="M-5.00,-2.00 L0.00,-2.00 L5.00,-2.00"]
     RenderSVGResourceMarker {marker} [id="mark2"] [markerUnits=strokeWidth] [ref at (4,4)] [angle=0.00]
-      RenderPath {path} at (280,270) size 210x90 [stroke={[type=SOLID] [color=#000000] [line cap=ROUND]}] [fill={[type=SOLID] [color=#000000]}] [start marker=mark1] [middle marker=mark1] [end marker=mark1] [data="M-5.00,2.00 L0.00,2.00 L5.00,2.00"]
+      RenderPath {path} at (310,300) size 180x60 [stroke={[type=SOLID] [color=#000000] [line cap=ROUND]}] [fill={[type=SOLID] [color=#000000]}] [start marker=mark1] [middle marker=mark1] [end marker=mark1] [data="M-5.00,2.00 L0.00,2.00 L5.00,2.00"]
     RenderPath {path} at (130,270) size 450x120 [stroke={[type=SOLID] [color=#000000] [line cap=ROUND]}] [fill={[type=SOLID] [color=#000000]}] [start marker=mark1] [middle marker=mark1] [end marker=mark1] [data="M-5.00,2.00 L0.00,2.00 L5.00,2.00"]

trunk/LayoutTests/platform/mac/svg/custom/gradient-cycle-detection-expected.checksum

@@ -1 @@
-c31435453e4b5fe90b3b618f35608ef3
+a7754e874db94ad931cb2db1054e361f

trunk/LayoutTests/platform/mac/svg/custom/recursive-clippath-expected.checksum

@@ -1 @@
-67516477d9f265bd907635bbade318cd
+72e669ce7be88c04c721d627b566c3cb

trunk/LayoutTests/platform/mac/svg/custom/recursive-clippath-expected.txt

@@ -2 +2 @@
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
-  RenderSVGRoot {svg} at (0,0) size 200x300
+  RenderSVGRoot {svg} at (29,0) size 292x304
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
       RenderSVGResourceClipper {clipPath} [id="clipPath_0"] [clipPathUnits=userSpaceOnUse]
-        RenderPath {rect} at (0,0) size 100x100 [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-          [clipPath="clipPath_0"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x100
-      RenderPath {rect} at (0,100) size 100x100 [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
-        [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (0,100) size 100x100
+        RenderPath {rect} at (50,0) size 50x50 [data="M50.00,0.00 L100.00,0.00 L100.00,50.00 L50.00,50.00 Z"]
+          [clipPath="clipPath_0"] RenderSVGResourceClipper {clipPath} at (50,0) size 50x50
+      RenderPath {rect} at (50,150) size 50x50 [data="M50.00,150.00 L100.00,150.00 L100.00,200.00 L50.00,200.00 Z"]
+        [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (50,150) size 50x50
       RenderSVGResourceClipper {clipPath} [id="clipPath_1"] [clipPathUnits=userSpaceOnUse]
-        RenderSVGContainer {use} at (0,100) size 100x100
-          RenderSVGContainer {g} at (0,100) size 100x100
-            RenderPath {rect} at (0,100) size 100x100 [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
-              [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (0,100) size 100x100
-    RenderPath {rect} at (0,0) size 200x200 [fill={[type=SOLID] [color=#FF0000]}] [data="M0.00,0.00 L200.00,0.00 L200.00,200.00 L0.00,200.00 Z"]
-    RenderPath {rect} at (0,0) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M0.00,0.00 L200.00,0.00 L200.00,200.00 L0.00,200.00 Z"]
-      [clipPath="clipPath_0"] RenderSVGResourceClipper {clipPath} at (0,0) size 100x100
-    RenderPath {rect} at (0,100) size 200x200 [fill={[type=SOLID] [color=#FF0000]}] [data="M0.00,100.00 L200.00,100.00 L200.00,300.00 L0.00,300.00 Z"]
-    RenderPath {rect} at (0,100) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M0.00,100.00 L200.00,100.00 L200.00,300.00 L0.00,300.00 Z"]
-      [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (0,100) size 100x100
+        RenderSVGContainer {use} at (50,150) size 50x50
+          RenderSVGContainer {g} at (50,150) size 50x50
+            RenderPath {rect} at (50,150) size 50x50 [data="M50.00,150.00 L100.00,150.00 L100.00,200.00 L50.00,200.00 Z"]
+              [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (50,150) size 50x50
+    RenderPath {rect} at (50,0) size 100x100 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,0.00 L150.00,0.00 L150.00,100.00 L50.00,100.00 Z"]
+    RenderPath {rect} at (50,0) size 50x50 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,0.00 L150.00,0.00 L150.00,100.00 L50.00,100.00 Z"]
+      [clipPath="clipPath_0"] RenderSVGResourceClipper {clipPath} at (50,0) size 50x50
+    RenderPath {rect} at (50,150) size 100x100 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,150.00 L150.00,150.00 L150.00,250.00 L50.00,250.00 Z"]
+    RenderPath {rect} at (50,150) size 50x50 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,150.00 L150.00,150.00 L150.00,250.00 L50.00,250.00 Z"]
+      [clipPath="clipPath_1"] RenderSVGResourceClipper {clipPath} at (50,150) size 50x50
+    RenderPath {line} at (174,0) size 2x250 [stroke={[type=SOLID] [color=#FF0000]}] [fill={[type=SOLID] [color=#000000]}] [data="M175.00,0.00 L175.00,250.00"]
+    RenderSVGText {text} at (29,286) size 292x18 contains 1 chunk(s)
+      RenderSVGInlineText {#text} at (0,0) size 292x18
+        chunk 1 (middle anchor) text run 1 at (29.00,300.00) startOffset 0 endOffset 48 width 292.00: "Both sides of the red line should look identical"
+    RenderSVGContainer {g} at (200,0) size 100x250 [transform={m=((1.00,0.00)(0.00,1.00)) t=(150.00,0.00)}]
+      RenderPath {rect} at (200,0) size 100x100 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,0.00 L150.00,0.00 L150.00,100.00 L50.00,100.00 Z"]
+      RenderPath {rect} at (200,0) size 50x50 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,0.00 L100.00,0.00 L100.00,50.00 L50.00,50.00 Z"]
+      RenderPath {rect} at (200,150) size 100x100 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,150.00 L150.00,150.00 L150.00,250.00 L50.00,250.00 Z"]
+      RenderPath {rect} at (200,150) size 50x50 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,150.00 L100.00,150.00 L100.00,200.00 L50.00,200.00 Z"]

trunk/LayoutTests/platform/mac/svg/custom/recursive-filter-expected.checksum

@@ -1 @@
-dda4f1b67cf9fb2058815ce9466326fc
+0e4859e3b02f2f48bba2c68cad4e0e7b

trunk/LayoutTests/platform/mac/svg/custom/recursive-filter-expected.txt

@@ -2 +2 @@
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
-  RenderSVGRoot {svg} at (0,0) size 111x210
+  RenderSVGRoot {svg} at (29,0) size 292x304
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
+      RenderSVGResourceFilter {filter} [id="filter0"] [filterUnits=objectBoundingBox] [primitiveUnits=userSpaceOnUse]
+        [feGaussianBlur stdDeviation="4.00, 4.00"]
+          [SourceGraphic]
       RenderSVGResourceFilter {filter} [id="filter1"] [filterUnits=objectBoundingBox] [primitiveUnits=userSpaceOnUse]
         [feGaussianBlur stdDeviation="4.00, 4.00"]
           [SourceGraphic]
       RenderSVGResourceFilter {filter} [id="filter2"] [filterUnits=objectBoundingBox] [primitiveUnits=userSpaceOnUse]
-    RenderPath {rect} at (0,0) size 111x111 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      [filter="filter1"] RenderSVGResourceFilter {filter} at (-10,-10) size 120x120
-    RenderPath {rect} at (0,90) size 111x120 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
-      [filter="filter2"] RenderSVGResourceFilter {filter} at (-10,90) size 120x120
+    RenderPath {rect} at (40,0) size 120x111 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,0.00 L150.00,0.00 L150.00,100.00 L50.00,100.00 Z"]
+      [filter="filter1"] RenderSVGResourceFilter {filter} at (40,-10) size 120x120
+    RenderPath {rect} at (40,140) size 120x120 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,150.00 L150.00,150.00 L150.00,250.00 L50.00,250.00 Z"]
+      [filter="filter2"] RenderSVGResourceFilter {filter} at (40,140) size 120x120
+    RenderPath {line} at (174,0) size 2x250 [stroke={[type=SOLID] [color=#FF0000]}] [fill={[type=SOLID] [color=#000000]}] [data="M175.00,0.00 L175.00,250.00"]
+    RenderSVGText {text} at (29,286) size 292x18 contains 1 chunk(s)
+      RenderSVGInlineText {#text} at (0,0) size 292x18
+        chunk 1 (middle anchor) text run 1 at (29.00,300.00) startOffset 0 endOffset 48 width 292.00: "Both sides of the red line should look identical"
+    RenderSVGContainer {g} at (190,0) size 120x111 [transform={m=((1.00,0.00)(0.00,1.00)) t=(150.00,0.00)}]
+      RenderPath {rect} at (190,0) size 120x111 [fill={[type=SOLID] [color=#0000FF]}] [data="M50.00,0.00 L150.00,0.00 L150.00,100.00 L50.00,100.00 Z"]
+        [filter="filter0"] RenderSVGResourceFilter {filter} at (40,-10) size 120x120

trunk/LayoutTests/platform/mac/svg/custom/recursive-gradient-expected.checksum

@@ -1 @@
-efd46e2c198be8ead9a8d0392dbc1e94
+2e73268fd422007888f75dd8c8ba6490

trunk/LayoutTests/platform/mac/svg/custom/recursive-gradient-expected.txt

@@ -2 +2 @@
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
-  RenderSVGRoot {svg} at (0,0) size 201x201
+  RenderSVGRoot {svg} at (0,0) size 451x254
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
-      RenderSVGResourceRadialGradient {radialGradient} [id="gradient1"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.15,0.15)] [radius=0.50]
+      RenderSVGResourceRadialGradient {radialGradient} [id="gradient0"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.50,0.50)] [radius=0.50]
         RenderSVGGradientStop {stop} [offset=0.00] [color=#0000FF]
         RenderSVGGradientStop {stop} [offset=1.00] [color=#FF0000]
-      RenderSVGResourceRadialGradient {radialGradient} [id="gradient2"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.15,0.15)] [radius=0.50]
-      RenderSVGResourceRadialGradient {radialGradient} [id="gradient3"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.15,0.15)] [radius=0.50]
+      RenderSVGResourceRadialGradient {radialGradient} [id="gradient1"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.50,0.50)] [radius=0.50]
+        RenderSVGGradientStop {stop} [offset=0.00] [color=#0000FF]
+        RenderSVGGradientStop {stop} [offset=1.00] [color=#FF0000]
+      RenderSVGResourceRadialGradient {radialGradient} [id="gradient2"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.50,0.50)] [radius=0.50]
+      RenderSVGResourceRadialGradient {radialGradient} [id="gradient4"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.50,0.50)] [radius=0.50]
+      RenderSVGResourceRadialGradient {radialGradient} [id="gradient3"] [gradientUnits=objectBoundingBox] [center=(0.50,0.50)] [focal=(0.50,0.50)] [radius=0.50]
     RenderPath {rect} at (0,0) size 101x101 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=RADIAL-GRADIENT] [id="gradient1"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
     RenderPath {rect} at (99,0) size 102x101 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=RADIAL-GRADIENT] [id="gradient2"]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
     RenderPath {rect} at (0,99) size 101x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=RADIAL-GRADIENT] [id="gradient3"]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
+    RenderPath {line} at (224,0) size 2x200 [stroke={[type=SOLID] [color=#FF0000]}] [fill={[type=SOLID] [color=#000000]}] [data="M225.00,0.00 L225.00,200.00"]
+    RenderSVGText {text} at (79,236) size 292x18 contains 1 chunk(s)
+      RenderSVGInlineText {#text} at (0,0) size 292x18
+        chunk 1 (middle anchor) text run 1 at (79.00,250.00) startOffset 0 endOffset 48 width 292.00: "Both sides of the red line should look identical"
+    RenderSVGContainer {g} at (249,0) size 202x201 [transform={m=((1.00,0.00)(0.00,1.00)) t=(250.00,0.00)}]
+      RenderPath {rect} at (249,0) size 102x101 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=RADIAL-GRADIENT] [id="gradient0"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+      RenderPath {rect} at (349,0) size 102x101 [stroke={[type=SOLID] [color=#008000]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
+      RenderPath {rect} at (249,99) size 102x102 [stroke={[type=SOLID] [color=#008000]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]

trunk/LayoutTests/platform/mac/svg/custom/recursive-mask-expected.checksum

@@ -1 @@
-7f078b4f3971b046bbab30231bfb350c
+a3e27e4285fbd10b7edbf738101b1339

trunk/LayoutTests/platform/mac/svg/custom/recursive-mask-expected.txt

@@ -2 +2 @@
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
-  RenderSVGRoot {svg} at (0,0) size 150x250
+  RenderSVGRoot {svg} at (0,0) size 350x204
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
       RenderSVGResourceMasker {mask} [id="mask1"] [maskUnits=objectBoundingBox] [maskContentUnits=userSpaceOnUse]
@@ -14 +14 @@
         RenderPath {rect} at (0,0) size 0x0 [fill={[type=SOLID] [color=#FFFFFF]}] [data="M100.00,100.00 L150.00,100.00 L150.00,150.00 L100.00,150.00 Z"]
           [masker="mask2"] RenderSVGResourceMasker {mask} at (0,0) size 0x0
-      RenderPath {rect} at (0,200) size 50x50 [fill={[type=SOLID] [color=#FFFFFF]}] [data="M0.00,200.00 L50.00,200.00 L50.00,250.00 L0.00,250.00 Z"]
-        [masker="mask4"] RenderSVGResourceMasker {mask} at (0,200) size 50x50
+      RenderPath {rect} at (0,100) size 50x50 [fill={[type=SOLID] [color=#FFFFFF]}] [data="M0.00,100.00 L50.00,100.00 L50.00,150.00 L0.00,150.00 Z"]
+        [masker="mask4"] RenderSVGResourceMasker {mask} at (0,100) size 50x50
       RenderSVGResourceMasker {mask} [id="mask4"] [maskUnits=objectBoundingBox] [maskContentUnits=userSpaceOnUse]
-        RenderSVGContainer {use} at (0,200) size 50x50
-          RenderSVGContainer {g} at (0,200) size 50x50
-            RenderPath {rect} at (0,200) size 50x50 [fill={[type=SOLID] [color=#FFFFFF]}] [data="M0.00,200.00 L50.00,200.00 L50.00,250.00 L0.00,250.00 Z"]
-              [masker="mask4"] RenderSVGResourceMasker {mask} at (0,200) size 50x50
-    RenderPath {rect} at (0,0) size 50x50 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+        RenderSVGContainer {use} at (0,100) size 50x50
+          RenderSVGContainer {g} at (0,100) size 50x50
+            RenderPath {rect} at (0,100) size 50x50 [fill={[type=SOLID] [color=#FFFFFF]}] [data="M0.00,100.00 L50.00,100.00 L50.00,150.00 L0.00,150.00 Z"]
+              [masker="mask4"] RenderSVGResourceMasker {mask} at (0,100) size 50x50
+    RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
       [masker="mask1"] RenderSVGResourceMasker {mask} at (0,0) size 50x50
-    RenderPath {rect} at (100,0) size 50x50 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
+    RenderPath {rect} at (100,0) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
       [masker="mask2"] RenderSVGResourceMasker {mask} at (100,0) size 50x50
-    RenderPath {rect} at (0,0) size 0x0 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M100.00,100.00 L200.00,100.00 L200.00,200.00 L100.00,200.00 Z"]
+    RenderPath {rect} at (0,0) size 0x0 [fill={[type=SOLID] [color=#0000FF]}] [data="M100.00,100.00 L200.00,100.00 L200.00,200.00 L100.00,200.00 Z"]
       [masker="mask3"] RenderSVGResourceMasker {mask} at (0,0) size 0x0
-    RenderPath {rect} at (0,200) size 50x50 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,200.00 L100.00,200.00 L100.00,300.00 L0.00,300.00 Z"]
-      [masker="mask4"] RenderSVGResourceMasker {mask} at (0,200) size 50x50
+    RenderPath {rect} at (0,100) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
+      [masker="mask4"] RenderSVGResourceMasker {mask} at (0,100) size 50x50
+    RenderPath {line} at (174,0) size 2x150 [stroke={[type=SOLID] [color=#FF0000]}] [fill={[type=SOLID] [color=#000000]}] [data="M175.00,0.00 L175.00,150.00"]
+    RenderSVGText {text} at (29,186) size 292x18 contains 1 chunk(s)
+      RenderSVGInlineText {#text} at (0,0) size 292x18
+        chunk 1 (middle anchor) text run 1 at (29.00,200.00) startOffset 0 endOffset 48 width 292.00: "Both sides of the red line should look identical"
+    RenderSVGContainer {g} at (200,0) size 150x150 [transform={m=((1.00,0.00)(0.00,1.00)) t=(200.00,0.00)}]
+      RenderPath {rect} at (200,0) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderPath {rect} at (300,0) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M100.00,0.00 L150.00,0.00 L150.00,50.00 L100.00,50.00 Z"]
+      RenderPath {rect} at (200,100) size 50x50 [fill={[type=SOLID] [color=#0000FF]}] [data="M0.00,100.00 L50.00,100.00 L50.00,150.00 L0.00,150.00 Z"]

trunk/LayoutTests/platform/mac/svg/custom/recursive-pattern-expected.checksum

@@ -1 @@
-c313c4ce6fc9ac267436fef6a4d7f5d6
+2886112189091c741b0f22d4331cd31c

trunk/LayoutTests/platform/mac/svg/custom/recursive-pattern-expected.txt

@@ -2 +2 @@
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
-  RenderSVGRoot {svg} at (0,0) size 201x401
+  RenderSVGRoot {svg} at (0,0) size 650x354
     RenderSVGHiddenContainer {defs} at (0,0) size 0x0
-      RenderSVGResourcePattern {pattern} [id="pattern1"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-        RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern1"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderSVGResourcePattern {pattern} [id="pattern2"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-        RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern1"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderSVGResourcePattern {pattern} [id="pattern3"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-      RenderSVGResourcePattern {pattern} [id="pattern4"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-      RenderSVGResourcePattern {pattern} [id="pattern6"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-      RenderSVGResourcePattern {pattern} [id="pattern5"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-        RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern6"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern7"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderSVGResourcePattern {pattern} [id="pattern7"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-        RenderSVGContainer {use} at (0,0) size 100x100
-          RenderSVGContainer {g} at (0,0) size 100x100
-            RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern7"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderSVGContainer {use} at (0,0) size 100x100
-        RenderSVGContainer {g} at (0,0) size 100x100
-          RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-      RenderSVGResourcePattern {pattern} [id="pattern8"] [patternUnits=objectBoundingBox] [patternContentUnits=userSpaceOnUse]
-        RenderSVGContainer {use} at (0,0) size 100x100
-          RenderSVGContainer {g} at (0,0) size 100x100
-            RenderSVGContainer {g} at (0,0) size 100x100
-              RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-    RenderPath {rect} at (0,0) size 101x101 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern1"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
-    RenderPath {rect} at (0,99) size 101x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern2"]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
-    RenderPath {rect} at (99,0) size 102x101 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern3"]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
-    RenderPath {rect} at (99,99) size 102x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern4"]}] [data="M100.00,100.00 L200.00,100.00 L200.00,200.00 L100.00,200.00 Z"]
-    RenderPath {rect} at (0,199) size 101x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern5"]}] [data="M0.00,200.00 L100.00,200.00 L100.00,300.00 L0.00,300.00 Z"]
-    RenderPath {rect} at (99,199) size 102x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern6"]}] [data="M100.00,200.00 L200.00,200.00 L200.00,300.00 L100.00,300.00 Z"]
-    RenderPath {rect} at (0,299) size 101x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern7"]}] [data="M0.00,300.00 L100.00,300.00 L100.00,400.00 L0.00,400.00 Z"]
-    RenderPath {rect} at (99,299) size 102x102 [stroke={[type=SOLID] [color=#008000]}] [fill={[type=PATTERN] [id="pattern8"]}] [data="M100.00,300.00 L200.00,300.00 L200.00,400.00 L100.00,400.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern0"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+        RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern1"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+        RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern2"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+        RenderPath {rect} at (0,0) size 50x50 [fill={[type=PATTERN] [id="pattern1"]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern3"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+      RenderSVGResourcePattern {pattern} [id="pattern4"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+      RenderSVGResourcePattern {pattern} [id="pattern6"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+      RenderSVGResourcePattern {pattern} [id="pattern5"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+        RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+      RenderPath {rect} at (0,0) size 50x50 [fill={[type=PATTERN] [id="pattern7"]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern7"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderSVGContainer {use} at (0,0) size 50x50
+          RenderSVGContainer {g} at (0,0) size 50x50
+            RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+        RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+      RenderPath {rect} at (0,0) size 50x50 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderSVGContainer {use} at (0,0) size 50x50
+        RenderSVGContainer {g} at (0,0) size 50x50
+          RenderPath {rect} at (0,0) size 50x50 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern8"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderSVGContainer {g} at (0,0) size 150x150
+          RenderSVGContainer {use} at (50,50) size 100x100
+            RenderSVGContainer {g} at (50,50) size 100x100
+              RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+          RenderSVGContainer {use} at (0,0) size 50x50
+            RenderSVGContainer {g} at (0,0) size 50x50
+              RenderSVGContainer {g} at (0,0) size 50x50
+                RenderPath {rect} at (0,0) size 50x50 [fill={[type=SOLID] [color=#000000]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+      RenderSVGResourcePattern {pattern} [id="pattern9"] [patternUnits=userSpaceOnUse] [patternContentUnits=userSpaceOnUse]
+        RenderSVGContainer {use} at (0,0) size 150x150
+          RenderSVGContainer {g} at (0,0) size 150x150
+            RenderSVGContainer {g} at (0,0) size 150x150
+              RenderSVGContainer {g} at (50,50) size 100x100
+                RenderPath {rect} at (50,50) size 100x100 [fill={[type=SOLID] [color=#008000]}] [data="M50.00,50.00 L150.00,50.00 L150.00,150.00 L50.00,150.00 Z"]
+              RenderSVGContainer {g} at (0,0) size 50x50
+                RenderSVGContainer {g} at (0,0) size 50x50
+                  RenderPath {rect} at (0,0) size 50x50 [fill={[type=PATTERN] [id="pattern8"]}] [data="M0.00,0.00 L50.00,0.00 L50.00,50.00 L0.00,50.00 Z"]
+    RenderPath {rect} at (0,0) size 100x100 [fill={[type=PATTERN] [id="pattern1"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+    RenderPath {rect} at (100,0) size 100x100 [fill={[type=PATTERN] [id="pattern2"]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
+    RenderPath {rect} at (200,0) size 100x100 [fill={[type=PATTERN] [id="pattern3"]}] [data="M200.00,0.00 L300.00,0.00 L300.00,100.00 L200.00,100.00 Z"]
+    RenderPath {rect} at (0,100) size 100x100 [fill={[type=PATTERN] [id="pattern4"]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
+    RenderPath {rect} at (100,100) size 100x100 [fill={[type=PATTERN] [id="pattern5"]}] [data="M100.00,100.00 L200.00,100.00 L200.00,200.00 L100.00,200.00 Z"]
+    RenderPath {rect} at (200,100) size 100x100 [fill={[type=PATTERN] [id="pattern6"]}] [data="M200.00,100.00 L300.00,100.00 L300.00,200.00 L200.00,200.00 Z"]
+    RenderPath {rect} at (0,200) size 100x100 [fill={[type=PATTERN] [id="pattern7"]}] [data="M0.00,200.00 L100.00,200.00 L100.00,300.00 L0.00,300.00 Z"]
+    RenderPath {rect} at (100,200) size 100x100 [fill={[type=PATTERN] [id="pattern8"]}] [data="M100.00,200.00 L200.00,200.00 L200.00,300.00 L100.00,300.00 Z"]
+    RenderPath {rect} at (200,200) size 100x100 [fill={[type=PATTERN] [id="pattern9"]}] [data="M200.00,200.00 L300.00,200.00 L300.00,300.00 L200.00,300.00 Z"]
+    RenderPath {line} at (324,0) size 2x300 [stroke={[type=SOLID] [color=#FF0000]}] [fill={[type=SOLID] [color=#000000]}] [data="M325.00,0.00 L325.00,300.00"]
+    RenderSVGText {text} at (179,336) size 292x18 contains 1 chunk(s)
+      RenderSVGInlineText {#text} at (0,0) size 292x18
+        chunk 1 (middle anchor) text run 1 at (179.00,350.00) startOffset 0 endOffset 48 width 292.00: "Both sides of the red line should look identical"
+    RenderSVGContainer {g} at (350,0) size 300x300 [transform={m=((1.00,0.00)(0.00,1.00)) t=(350.00,0.00)}]
+      RenderPath {rect} at (350,0) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M0.00,0.00 L100.00,0.00 L100.00,100.00 L0.00,100.00 Z"]
+      RenderPath {rect} at (450,0) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M100.00,0.00 L200.00,0.00 L200.00,100.00 L100.00,100.00 Z"]
+      RenderPath {rect} at (550,0) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M200.00,0.00 L300.00,0.00 L300.00,100.00 L200.00,100.00 Z"]
+      RenderPath {rect} at (350,100) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M0.00,100.00 L100.00,100.00 L100.00,200.00 L0.00,200.00 Z"]
+      RenderPath {rect} at (450,100) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M100.00,100.00 L200.00,100.00 L200.00,200.00 L100.00,200.00 Z"]
+      RenderPath {rect} at (550,100) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M200.00,100.00 L300.00,100.00 L300.00,200.00 L200.00,200.00 Z"]
+      RenderPath {rect} at (350,200) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M0.00,200.00 L100.00,200.00 L100.00,300.00 L0.00,300.00 Z"]
+      RenderPath {rect} at (450,200) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M100.00,200.00 L200.00,200.00 L200.00,300.00 L100.00,300.00 Z"]
+      RenderPath {rect} at (550,200) size 100x100 [fill={[type=PATTERN] [id="pattern0"]}] [data="M200.00,200.00 L300.00,200.00 L300.00,300.00 L200.00,300.00 Z"]

trunk/LayoutTests/platform/mac/svg/custom/use-events-crash-expected.txt

@@ -20 +20 @@
           RenderSVGContainer {g} at (350,25) size 40x40
             RenderPath {rect} at (350,25) size 40x40 [fill={[type=SOLID] [color=#00FF00]}] [data="M0.00,0.00 L40.00,0.00 L40.00,40.00 L0.00,40.00 Z"]
-caret: position 0 of child 0 {#text} of child 1 {text} of child 1 {g} of child 3 {g} of child 3 {g} of child 1 {svg} of document

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerHeight-attr-expected.checksum

@@ -1 @@
-224fae800d3d427aba91701730990d02
+7d9ed1ba3cca05516d0a91561ed24feb

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-dom-markerWidth-attr-expected.checksum

@@ -1 @@
-11c3c4e16ba9180cdaeb785027d292e2
+5bf96e5173d6653c73e6163b7e203c72

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerHeight-prop-expected.checksum

@@ -1 @@
-c2ba9334d9a0f68b163099615799ac39
+31c467d114864ed4ea30162d45c6c289

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMarkerElement-svgdom-markerWidth-prop-expected.checksum

@@ -1 @@
-7ef89ade3d06a052d987f755b9dfcaf2
+4080ad4d8c7c50db21c1b2a2b98e0562

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-height-attr-expected.checksum

@@ -1 @@
-d11382e9cbf749aadd4a0953a865956e
+6669ab446ddc0ff912c784ee18705928

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskContentUnits-attr-expected.checksum

@@ -1 @@
-173b41ad238e25454717720add78ea84
+cca7e1243ffc4052ae39c1729fe5676a

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-maskUnits-attr-expected.checksum

@@ -1 @@
-382386d8794e17490484c55f5b025481
+4d9ca776de74d7e38d9e758a89b93d27

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-width-attr-expected.checksum

@@ -1 @@
-c17365eee489e97e9b1bb7f649414ee1
+ca73b7faa6d86098712f37b66bbc1c82

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-x-attr-expected.checksum

@@ -1 @@
-716714632a1b9c8b0c947a52a354e676
+3019c8444d91d7c726cd6a6d2540fb1e

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-dom-y-attr-expected.checksum

@@ -1 @@
-0c5df953535e3db2abb9d999b01032b7
+70ef44d927c6ad84a702c9771c169905

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-height-prop-expected.checksum

@@ -1 @@
-d6ce0b1dc577c6fbff58f0f3f4f56d32
+414528c414a3ad821d167564502995bb

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskContentUnits-prop-expected.checksum

@@ -1 @@
-0e2770c1b7a4543ad89484ef9fa5a0b6
+51768de61cfef35e4c8f5d45029ffa8c

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-maskUnits-prop-expected.checksum

@@ -1 @@
-4dcda8de30ac50477518851d437d282d
+21e1b5d7baf0d61fe046185ce31c8263

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-width-prop-expected.checksum

@@ -1 @@
-5d0b62709f3a4d7733ab98e58ccc7b1f
+d79313dfe1948cb30b740f17f7861030

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-x-prop-expected.checksum

@@ -1 @@
-b0d903966f3ebfa1be3346b5bd0a8521
+bb05754e3fbf1cd483529bc6024a8e0e

trunk/LayoutTests/platform/mac/svg/dynamic-updates/SVGMaskElement-svgdom-y-prop-expected.checksum

@@ -1 @@
-0ec6e3c4aef5a60c2b8f0efcc05b26cb
+a3b34c5887a55c800641ee576b137d06

trunk/LayoutTests/platform/mac/svg/hixie/error/017-expected.txt

@@ -7 +7 @@
         RenderSVGContainer {use} at (0,0) size 0x0
           RenderSVGContainer {g} at (0,0) size 0x0
-            RenderSVGContainer {g} at (0,0) size 0x0
-              RenderSVGContainer {g} at (0,0) size 0x0
       RenderSVGContainer {g} at (0,0) size 0x0
         RenderSVGContainer {use} at (0,0) size 0x0

trunk/LayoutTests/svg/clip-path/clip-path-recursive-call-by-child.svg

@@ -2 +2 @@
 <defs>
     <clipPath id="clip">
-        <rect x="0" y="0" width="100" height="50" clip-path="url(#clip)"/>
+        <rect x="0" y="0" width="100" height="100" clip-path="url(#clip)"/>
     </clipPath>
 </defs>

trunk/LayoutTests/svg/custom/js-late-clipPath-and-object-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createClipPath()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content" transform="scale(1, 1.5)"/>
 <script>
     var content = document.getElementById("content");
- 
+
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createObject, 0);
+
     function createObject()
     {
@@ -17 +22 @@
         text.appendChild(document.createTextNode("Clipped. INVISIBLE."));        
         content.appendChild(text);
+
+        setTimeout(createClipPath, 0);
     }
 
     function createClipPath()
     {
-        createObject();
-
         var clipPath = document.createElementNS("http://www.w3.org/2000/svg", "clipPath");
         clipPath.setAttribute("id", "dynClip");
@@ -32 +37 @@
         clipPath.appendChild(path);
         content.appendChild(clipPath);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-clipPath-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createClipPath()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content" transform="scale(1, 1.5)">
      <text font-size="60" fill="navy" clip-path="url(#dynClip)" x="10" y="70">Clipped. INVISIBLE.</text>
@@ -7 +7 @@
 <script>
     var content = document.getElementById("content");
+
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createClipPath, 0);
 
     function createClipPath()
@@ -19 +24 @@
         clipPath.appendChild(path);
         content.appendChild(clipPath);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-gradient-and-object-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createGradients()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content"/>
 
 <script>
-        var content = document.getElementById("content");
+    var content = document.getElementById("content");
 
-        function createGradients()
-        {
-                // Setup "fillLinearGradient"
-                var gradient1 = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
-                gradient1.setAttribute("id", "fillLinearGradient");
-                gradient1.setAttribute("x1", "0");
-                gradient1.setAttribute("x2", "1");
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
 
-                var stop11 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop11.setAttribute("stop-color", "blue");
-                stop11.setAttribute("offset", "0");
+    setTimeout(createGradients, 0);
 
-                var stop21 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop21.setAttribute("stop-color", "red");
-                stop21.setAttribute("offset", "1");
+    function createGradients()
+    {
+        // Setup "fillLinearGradient"
+        var gradient1 = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
+        gradient1.setAttribute("id", "fillLinearGradient");
+        gradient1.setAttribute("x1", "0");
+        gradient1.setAttribute("x2", "1");
 
-                gradient1.appendChild(stop11);
-                gradient1.appendChild(stop21);
+        var stop11 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop11.setAttribute("stop-color", "blue");
+        stop11.setAttribute("offset", "0");
 
-                content.appendChild(gradient1);
+        var stop21 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop21.setAttribute("stop-color", "red");
+        stop21.setAttribute("offset", "1");
 
-                // Setup "strokeLinearGradient"
-                var gradient2 = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
-                gradient2.setAttribute("id", "strokeLinearGradient");
-                gradient2.setAttribute("x1", "0");
-                gradient2.setAttribute("x2", "1");
+        gradient1.appendChild(stop11);
+        gradient1.appendChild(stop21);
 
-                var stop22 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop22.setAttribute("stop-color", "yellow");
-                stop22.setAttribute("offset", "0");
+        content.appendChild(gradient1);
 
-                var stop22 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop22.setAttribute("stop-color", "green");
-                stop22.setAttribute("offset", "1");
+        // Setup "strokeLinearGradient"
+        var gradient2 = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
+        gradient2.setAttribute("id", "strokeLinearGradient");
+        gradient2.setAttribute("x1", "0");
+        gradient2.setAttribute("x2", "1");
 
-                gradient2.appendChild(stop22);
-                gradient2.appendChild(stop22);
+        var stop22 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop22.setAttribute("stop-color", "yellow");
+        stop22.setAttribute("offset", "0");
 
-                content.appendChild(gradient2);
+        var stop22 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop22.setAttribute("stop-color", "green");
+        stop22.setAttribute("offset", "1");
 
-                setupGradientUsers();
-        }
+        gradient2.appendChild(stop22);
+        gradient2.appendChild(stop22);
 
-        function setupGradientUsers()
-        {
-                var text1 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text1.setAttribute("font-size", "68");
-                text1.setAttribute("x", "-150");
-                text1.setAttribute("y", "70")
-                text1.setAttribute("fill", "url(#fillLinearGradient)");
-                text1.setAttribute("stroke", "none");
-                text1.appendChild(document.createTextNode("Gradient on fill"));
+        content.appendChild(gradient2);
+        setTimeout(setupGradientUsers, 0);
+    }
 
-                content.appendChild(text1);
+    function setupGradientUsers()
+    {
+        var text1 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text1.setAttribute("font-size", "68");
+        text1.setAttribute("x", "-150");
+        text1.setAttribute("y", "70")
+        text1.setAttribute("fill", "url(#fillLinearGradient)");
+        text1.setAttribute("stroke", "none");
+        text1.appendChild(document.createTextNode("Gradient on fill"));
 
-                var text2 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text2.setAttribute("font-size", "68");
-                text2.setAttribute("x", "-150");
-                text2.setAttribute("y", "140")
-                text2.setAttribute("fill", "none");     
-                text2.setAttribute("stroke", "url(#strokeLinearGradient)");
-                text2.appendChild(document.createTextNode("Gradient on stroke"));
+        content.appendChild(text1);
 
-                content.appendChild(text2);
+        var text2 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text2.setAttribute("font-size", "68");
+        text2.setAttribute("x", "-150");
+        text2.setAttribute("y", "140")
+        text2.setAttribute("fill", "none");    
+        text2.setAttribute("stroke", "url(#strokeLinearGradient)");
+        text2.appendChild(document.createTextNode("Gradient on stroke"));
 
-                var text3 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text3.setAttribute("font-size", "68");
-                text3.setAttribute("x", "-150");
-                text3.setAttribute("y", "210")
-                text3.setAttribute("fill", "url(#fillLinearGradient)"); 
-                text3.setAttribute("stroke", "url(#strokeLinearGradient)");
-                text3.appendChild(document.createTextNode("Gradient on fill/stroke"));
+        content.appendChild(text2);
 
-                content.appendChild(text3);
-        }
+        var text3 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text3.setAttribute("font-size", "68");
+        text3.setAttribute("x", "-150");
+        text3.setAttribute("y", "210")
+        text3.setAttribute("fill", "url(#fillLinearGradient)");    
+        text3.setAttribute("stroke", "url(#strokeLinearGradient)");
+        text3.appendChild(document.createTextNode("Gradient on fill/stroke"));
+
+        content.appendChild(text3);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }
 </script>
 

trunk/LayoutTests/svg/custom/js-late-gradient-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createGradient()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content" transform="scale(1, 1.5)">
      <text font-size="68" fill="url(#dynGrad)"  x="20" y="70">Gradient on fill</text>
 </g>
 <script>
-        var content = document.getElementById("content");
+    var content = document.getElementById("content");
 
-        function createGradient()
-        {
-                var gradient = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
-                gradient.setAttribute("id", "dynGrad");
-                gradient.setAttribute("x1", "0");
-                gradient.setAttribute("x2", "1");
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
 
-                var stop1 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop1.setAttribute("stop-color", "blue");
-                stop1.setAttribute("offset", "0");
+    setTimeout(createGradient, 0);
 
-                var stop2 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop2.setAttribute("stop-color", "red");
-                stop2.setAttribute("offset", "1");
+    function createGradient()
+    {
+        var gradient = document.createElementNS("http://www.w3.org/2000/svg", "linearGradient");
+        gradient.setAttribute("id", "dynGrad");
+        gradient.setAttribute("x1", "0");
+        gradient.setAttribute("x2", "1");
 
-                gradient.appendChild(stop1);
-                gradient.appendChild(stop2);
+        var stop1 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop1.setAttribute("stop-color", "blue");
+        stop1.setAttribute("offset", "0");
 
-                content.appendChild(gradient);
-        }
+        var stop2 = document.createElementNS("http://www.w3.org/2000/svg", "stop");
+        stop2.setAttribute("stop-color", "red");
+        stop2.setAttribute("offset", "1");
+
+        gradient.appendChild(stop1);
+        gradient.appendChild(stop2);
+
+        content.appendChild(gradient);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }
 </script>
 

trunk/LayoutTests/svg/custom/js-late-marker-and-object-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createMarker()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <defs id="defs">
     <marker id="markerStart" viewBox="0 0 10 10" markerWidth="2" markerHeight="2" refX="5" refY="5" markerUnits="strokeWidth">
@@ -17 +17 @@
     var content = document.getElementById("content");
 
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createObject, 0);
+
     function createObject()
     {
@@ -29 +34 @@
 
         content.appendChild(path);
+        setTimeout(createMarker, 0);
     }
 
     function createMarker()
     {
-        createObject();
-
         var marker = document.createElementNS("http://www.w3.org/2000/svg", "marker");
         marker.setAttribute("id", "markerMiddle");
@@ -53 +57 @@
         marker.appendChild(circle);
         defs.appendChild(marker);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-marker-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createMarker()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <defs id="defs">
     <marker id="markerStart" viewBox="0 0 10 10" markerWidth="2" markerHeight="2" refX="5" refY="5" markerUnits="strokeWidth">
@@ -16 +16 @@
 <script>
     var defs = document.getElementById("defs");
+
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createMarker, 0);
 
     function createMarker()
@@ -37 +42 @@
         marker.appendChild(circle);
         defs.appendChild(marker);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-mask-and-object-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 800 600" onload="createMask()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 800 600">
 
 <g id="content"/>
@@ -7 +7 @@
 <script>
     var content = document.getElementById("content");
+
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createObject, 0);
 
     function createObject()
@@ -18 +23 @@
 
         content.appendChild(rect);
+        setTimeout(createMask, 0);
     }
 
     function createMask()
     {
-        createObject();
-
         var mask = document.createElementNS("http://www.w3.org/2000/svg", "mask");
         mask.setAttribute("id", "dynMask");
@@ -39 +43 @@
         mask.appendChild(rect);
         content.appendChild(mask);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-mask-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 800 600" onload="createMask()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 800 600">
 
 <rect x="0" y="100" width="800" height="100" fill="blue" mask="url(#dynMask)"/>
@@ -8 +8 @@
 <script>
     var content = document.getElementById("content");
+
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
+
+    setTimeout(createMask, 0);
 
     function createMask()
@@ -26 +31 @@
         mask.appendChild(rect);
         content.appendChild(mask);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
     }
 </script>

trunk/LayoutTests/svg/custom/js-late-pattern-and-object-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createPatterns()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content"/>
 
 <script>
-        var content = document.getElementById("content");
+    var content = document.getElementById("content");
 
-        function createPatterns()
-        {
-                // Setup "fillPattern"  
-                var pattern1 = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
-                pattern1.setAttribute("id", "fillPattern");
-                pattern1.setAttribute("patternUnits", "userSpaceOnUse");
-                pattern1.setAttribute("x", "0");
-                pattern1.setAttribute("y", "0");
-                pattern1.setAttribute("width", "20");
-                pattern1.setAttribute("height", "20");
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
 
-                var rect11 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect11.setAttribute("x", "5");
-                rect11.setAttribute("y", "5");
-                rect11.setAttribute("width", "10");
-                rect11.setAttribute("height", "10");
-                rect11.setAttribute("fill", "red");
+    setTimeout(createPatterns, 0);
 
-                var rect21 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect21.setAttribute("x", "10");
-                rect21.setAttribute("y", "10");
-                rect21.setAttribute("width", "10");
-                rect21.setAttribute("height", "10");
-                rect21.setAttribute("fill", "green");
+    function createPatterns()
+    {
+        // Setup "fillPattern"    
+        var pattern1 = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
+        pattern1.setAttribute("id", "fillPattern");
+        pattern1.setAttribute("patternUnits", "userSpaceOnUse");
+        pattern1.setAttribute("x", "0");
+        pattern1.setAttribute("y", "0");
+        pattern1.setAttribute("width", "20");
+        pattern1.setAttribute("height", "20");
 
-                pattern1.appendChild(rect11);
-                pattern1.appendChild(rect21);
+        var rect11 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect11.setAttribute("x", "5");
+        rect11.setAttribute("y", "5");
+        rect11.setAttribute("width", "10");
+        rect11.setAttribute("height", "10");
+        rect11.setAttribute("fill", "red");
 
-                content.appendChild(pattern1);
+        var rect21 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect21.setAttribute("x", "10");
+        rect21.setAttribute("y", "10");
+        rect21.setAttribute("width", "10");
+        rect21.setAttribute("height", "10");
+        rect21.setAttribute("fill", "green");
 
-                // Setup "strokePattern"        
-                var pattern2 = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
-                pattern2.setAttribute("id", "strokePattern");
-                pattern2.setAttribute("patternUnits", "userSpaceOnUse");
-                pattern2.setAttribute("x", "0");
-                pattern2.setAttribute("y", "0");
-                pattern2.setAttribute("width", "20");
-                pattern2.setAttribute("height", "20");
+        pattern1.appendChild(rect11);
+        pattern1.appendChild(rect21);
 
-                var rect12 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect12.setAttribute("x", "5");
-                rect12.setAttribute("y", "5");
-                rect12.setAttribute("width", "10");
-                rect12.setAttribute("height", "10");
-                rect12.setAttribute("fill", "yellow");
+        content.appendChild(pattern1);
 
-                var rect22 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect22.setAttribute("x", "10");
-                rect22.setAttribute("y", "10");
-                rect22.setAttribute("width", "10");
-                rect22.setAttribute("height", "10");
-                rect22.setAttribute("fill", "blue");
+        // Setup "strokePattern"    
+        var pattern2 = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
+        pattern2.setAttribute("id", "strokePattern");
+        pattern2.setAttribute("patternUnits", "userSpaceOnUse");
+        pattern2.setAttribute("x", "0");
+        pattern2.setAttribute("y", "0");
+        pattern2.setAttribute("width", "20");
+        pattern2.setAttribute("height", "20");
 
-                pattern2.appendChild(rect12);
-                pattern2.appendChild(rect22);
+        var rect12 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect12.setAttribute("x", "5");
+        rect12.setAttribute("y", "5");
+        rect12.setAttribute("width", "10");
+        rect12.setAttribute("height", "10");
+        rect12.setAttribute("fill", "yellow");
 
-                content.appendChild(pattern2);
+        var rect22 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect22.setAttribute("x", "10");
+        rect22.setAttribute("y", "10");
+        rect22.setAttribute("width", "10");
+        rect22.setAttribute("height", "10");
+        rect22.setAttribute("fill", "blue");
 
-                setupPatternUsers();
-        }
+        pattern2.appendChild(rect12);
+        pattern2.appendChild(rect22);
 
-        function setupPatternUsers()
-        {
-                var text1 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text1.setAttribute("font-size", "68");
-                text1.setAttribute("x", "-150");
-                text1.setAttribute("y", "70")
-                text1.setAttribute("fill", "url(#fillPattern)");
-                text1.setAttribute("stroke", "none");
-                text1.appendChild(document.createTextNode("Pattern on fill"));
+        content.appendChild(pattern2);
 
-                content.appendChild(text1);
+        setTimeout(setupPatternUsers, 0);
+    }
 
-                var text2 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text2.setAttribute("font-size", "68");
-                text2.setAttribute("x", "-150");
-                text2.setAttribute("y", "140")
-                text2.setAttribute("fill", "none");     
-                text2.setAttribute("stroke", "url(#strokePattern)");
-                text2.appendChild(document.createTextNode("Pattern on stroke"));
+    function setupPatternUsers()
+    {
+        var text1 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text1.setAttribute("font-size", "68");
+        text1.setAttribute("x", "-150");
+        text1.setAttribute("y", "70")
+        text1.setAttribute("fill", "url(#fillPattern)");
+        text1.setAttribute("stroke", "none");
+        text1.appendChild(document.createTextNode("Pattern on fill"));
 
-                content.appendChild(text2);
+        content.appendChild(text1);
 
-                var text3 = document.createElementNS("http://www.w3.org/2000/svg", "text");
-                text3.setAttribute("font-size", "68");
-                text3.setAttribute("x", "-150");
-                text3.setAttribute("y", "210")
-                text3.setAttribute("fill", "url(#fillPattern)");        
-                text3.setAttribute("stroke", "url(#strokePattern)");
-                text3.appendChild(document.createTextNode("Pattern on fill/stroke"));
+        var text2 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text2.setAttribute("font-size", "68");
+        text2.setAttribute("x", "-150");
+        text2.setAttribute("y", "140")
+        text2.setAttribute("fill", "none");    
+        text2.setAttribute("stroke", "url(#strokePattern)");
+        text2.appendChild(document.createTextNode("Pattern on stroke"));
 
-                content.appendChild(text3);
-        }
+        content.appendChild(text2);
+
+        var text3 = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text3.setAttribute("font-size", "68");
+        text3.setAttribute("x", "-150");
+        text3.setAttribute("y", "210")
+        text3.setAttribute("fill", "url(#fillPattern)");    
+        text3.setAttribute("stroke", "url(#strokePattern)");
+        text3.appendChild(document.createTextNode("Pattern on fill/stroke"));
+
+        content.appendChild(text3);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }
 </script>
 

trunk/LayoutTests/svg/custom/js-late-pattern-creation.svg

@@ -1 +1 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">  
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360" onload="createPattern()">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"  id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
 <g id="content" transform="scale(1, 1.5)">
      <text font-size="68" fill="url(#dynPattern)"  x="20" y="70">Pattern on fill</text>
 </g>
 <script>
-        var content = document.getElementById("content");
+    var content = document.getElementById("content");
 
-        function createPattern()
-        {
-                var pattern = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
-                pattern.setAttribute("id", "dynPattern");
-                pattern.setAttribute("patternUnits", "userSpaceOnUse");
-                pattern.setAttribute("x", "0");
-                pattern.setAttribute("y", "0");
-                pattern.setAttribute("width", "20");
-                pattern.setAttribute("height", "20");
+    if (window.layoutTestController)
+        layoutTestController.waitUntilDone();
 
-                var rect1 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect1.setAttribute("x", "5");
-                rect1.setAttribute("y", "5");
-                rect1.setAttribute("width", "10");
-                rect1.setAttribute("height", "10");
-                rect1.setAttribute("fill", "red");
+    setTimeout(createPattern, 0);
 
-                var rect2 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                rect2.setAttribute("x", "10");
-                rect2.setAttribute("y", "10");
-                rect2.setAttribute("width", "10");
-                rect2.setAttribute("height", "10");
-                rect2.setAttribute("fill", "green");
+    function createPattern()
+    {
+        var pattern = document.createElementNS("http://www.w3.org/2000/svg", "pattern");
+        pattern.setAttribute("id", "dynPattern");
+        pattern.setAttribute("patternUnits", "userSpaceOnUse");
+        pattern.setAttribute("x", "0");
+        pattern.setAttribute("y", "0");
+        pattern.setAttribute("width", "20");
+        pattern.setAttribute("height", "20");
 
-                pattern.appendChild(rect1);
-                pattern.appendChild(rect2);
+        var rect1 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect1.setAttribute("x", "5");
+        rect1.setAttribute("y", "5");
+        rect1.setAttribute("width", "10");
+        rect1.setAttribute("height", "10");
+        rect1.setAttribute("fill", "red");
 
-                content.appendChild(pattern);
-        }
+        var rect2 = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        rect2.setAttribute("x", "10");
+        rect2.setAttribute("y", "10");
+        rect2.setAttribute("width", "10");
+        rect2.setAttribute("height", "10");
+        rect2.setAttribute("fill", "green");
+
+        pattern.appendChild(rect1);
+        pattern.appendChild(rect2);
+
+        content.appendChild(pattern);
+
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }
 </script>
 

trunk/LayoutTests/svg/custom/recursive-clippath.svg

@@ -2 +2 @@
 <defs>
     <clipPath id='clipPath_0'>
-        <rect x='0' y='0' width='100' height='100' fill='none' clip-path='url(#clipPath_0)'/>
+        <rect x='50' y='0' width='50' height='50' fill='none' clip-path='url(#clipPath_0)'/>
     </clipPath>
 
-    <rect x='0' y='100' width='100' height='100' id="rect" fill='none' clip-path='url(#clipPath_1)'/>
+    <rect x='50' y='150' width='50' height='50' id="rect" fill='none' clip-path='url(#clipPath_1)'/>
     <clipPath id='clipPath_1'>
         <use xlink:href="#rect"/>
@@ -14 +14 @@
 Spec: clip-path: If the IRI reference is not valid (e.g it points to an object that doesn't exist or the object
                  is not a ‘clipPath’ element) the ‘clip-path’ property must be treated as if it hadn't been specified.
-
-      Our view is that an clipPath containing a cycle is not valid, and thus should be ignored.
-      But the object that references the clipPath should still be drawn.
 -->
 
-<rect x='0' y='0' width='200' height='200' fill='red'/>
-<rect x='0' y='0' width='200' height='200' fill='green' clip-path='url(#clipPath_0)'/>
+<rect x='50' y='0' width='100' height='100' fill='blue'/>
+<rect x='50' y='0' width='100' height='100' fill='green' clip-path='url(#clipPath_0)'/>
 
-<rect x='0' y='100' width='200' height='200' fill='red'/>
-<rect x='0' y='100' width='200' height='200' fill='green' clip-path='url(#clipPath_1)'/>
+<rect x='50' y='150' width='100' height='100' fill='blue'/>
+<rect x='50' y='150' width='100' height='100' fill='green' clip-path='url(#clipPath_1)'/>
+
+<line x1="175" x2="175" y1="0" y2="250" stroke="red"/>
+<text text-anchor="middle" x="175" y="300">Both sides of the red line should look identical</text>
+
+<!-- This is the reference rendering -->
+<g transform="translate(150,0)">
+    <rect x="50" y="0" width="100" height="100" fill="blue"/>
+    <rect x="50" y="0" width="50" height="50" fill="green"/>
+    <rect x="50" y="150" width="100" height="100" fill="blue"/>
+    <rect x="50" y="150" width="50" height="50" fill="green"/>
+</g>
 </svg>

trunk/LayoutTests/svg/custom/recursive-filter.svg

@@ -1 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 <defs>
+    <filter id="filter0">
+        <feGaussianBlur stdDeviation="4"/>
+    </filter>
+
     <filter id="filter1" filter="url(#filter1)">
         <feGaussianBlur stdDeviation="4"/>
     </filter>
 
+    <!-- WebKit currently does not implement filter chaining -->
     <filter id="filter2" xlink:href="#filter2"/>
 </defs>
 
 <!-- This should be blurred -->
-<rect x="0" y="0" width="100" height="100" filter="url(#filter1)" fill="blue" stroke="green"/>
+<rect x="50" y="0" width="100" height="100" filter="url(#filter1)" fill="blue"/>
 
-<!-- This should not crash and not render anything -->
-<rect x="0" y="100" width="100" height="100" filter="url(#filter2)" fill="blue" stroke="green"/>
+<!-- This should not render anything -->
+<rect x="50" y="150" width="100" height="100" filter="url(#filter2)" fill="blue"/>
+
+<line x1="175" x2="175" y1="0" y2="250" stroke="red"/>
+<text text-anchor="middle" x="175" y="300">Both sides of the red line should look identical</text>
+
+<!-- This is the reference rendering -->
+<g transform="translate(150,0)">
+    <rect x="50" y="0" width="100" height="100" filter="url(#filter0)" fill="blue"/>
+</g>
 </svg>

trunk/LayoutTests/svg/custom/recursive-gradient.svg

@@ -1 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 <defs>
+    <radialGradient id="gradient0" gradientUnits="objectBoundingBox" cx=".5" cy=".5" fx=".5" fy=".5" r=".5">
+        <stop stop-color="blue" offset="0"/>
+        <stop stop-color="red" offset="1"/>
+    </radialGradient>
+
     <radialGradient xlink:href="#gradient1" id="gradient1" gradientUnits="objectBoundingBox" cx=".5" cy=".5" fx=".5" fy=".5" r=".5">
         <stop stop-color="blue" offset="0"/>
         <stop stop-color="red" offset="1"/>
     </radialGradient>
-    <radialGradient id="gradient2" xlink:href="#gradient3"/>
+
+    <radialGradient id="gradient2" xlink:href="#gradient4"/>
+    <radialGradient id="gradient4" xlink:href="#gradient2"/>
     <radialGradient id="gradient3" xlink:href="#gradient2"/>
 </defs>
 
-<!-- This should not crash -->
+<!-- This should render with a gradient -->
 <rect x="0" y="0" width="100" height="100" fill="url(#gradient1)" stroke="green"/>
+
+<!-- This should not render anything -->
 <rect x="100" y="0" width="100" height="100" fill="url(#gradient2)" stroke="green"/>
+
+<!-- This should not render anything -->
 <rect x="0" y="100" width="100" height="100" fill="url(#gradient3)" stroke="green"/>
+
+<line x1="225" x2="225" y1="0" y2="200" stroke="red"/>
+<text text-anchor="middle" x="225" y="250">Both sides of the red line should look identical</text>
+
+<!-- This is the reference rendering -->
+<g transform="translate(250,0)">
+    <rect x="0" y="0" width="100" height="100" fill="url(#gradient0)" stroke="green"/>
+    <rect x="100" y="0" width="100" height="100" fill="none" stroke="green"/>
+    <rect x="0" y="100" width="100" height="100" fill="none" stroke="green"/>
+</g>
 </svg>

trunk/LayoutTests/svg/custom/recursive-mask.svg

@@ -14 +14 @@
     </mask>
 
-    <rect id="rect" x="0" y="200" width="50" height="50" fill="white" mask="url(#mask4)"/>
+    <rect id="rect" x="0" y="100" width="50" height="50" fill="white" mask="url(#mask4)"/>
     <mask id="mask4">
         <use xlink:href="#rect"/>
@@ -20 +20 @@
 </defs>
 
-<!-- This should be masked, resulting in a 50x50 rect -->
-<rect x="0" y="0" width="100" height="100" fill="blue" mask="url(#mask1)" stroke="green"/>
+<!-- This should result in a 50x50 rect -->
+<rect x="0" y="0" width="100" height="100" fill="blue" mask="url(#mask1)"/>
 
-<!-- This should not render anything -->
-<rect x="100" y="0" width="100" height="100" fill="blue" mask="url(#mask2)" stroke="green"/>
+<!-- This should result in a 50x50 rect -->
+<rect x="100" y="0" width="100" height="100" fill="blue" mask="url(#mask2)"/>
 
-<!-- This should not render anything -->
-<rect x="100" y="100" width="100" height="100" fill="blue" mask="url(#mask3)" stroke="green"/>
+<!-- This should not render -->
+<rect x="100" y="100" width="100" height="100" fill="blue" mask="url(#mask3)"/>
 
-<!-- This should not render anything -->
-<rect x="0" y="200" width="100" height="100" fill="blue" mask="url(#mask4)" stroke="green"/>
+<!-- This should result in a 50x50 rect -->
+<rect x="0" y="100" width="100" height="100" fill="blue" mask="url(#mask4)"/>
+
+<line x1="175" x2="175" y1="0" y2="150" stroke="red"/>
+<text text-anchor="middle" x="175" y="200">Both sides of the red line should look identical</text>
+
+<!-- This is the reference rendering -->
+<g transform="translate(200,0)">
+    <rect x="0" y="0" width="50" height="50" fill="blue"/>
+    <rect x="100" y="0" width="50" height="50" fill="blue"/>
+    <rect x="0" y="100" width="50" height="50" fill="blue"/>
+</g>
 </svg>

trunk/LayoutTests/svg/custom/recursive-pattern.svg

@@ -1 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 <defs>
-    <pattern id="pattern1" x="0" y="0" width="100" height="100">
-        <rect x="0" y="0" width="100" height="100" fill="url(#pattern1)"/>
+    <pattern patternUnits="userSpaceOnUse" id="pattern0" x="0" y="0" width="100" height="100">
+        <rect x="0" y="0" width="50" height="50" fill="black"/>
+        <rect x="50" y="50" width="100" height="100" fill="green"/>
     </pattern>
 
-    <pattern id="pattern2" x="0" y="0" width="100" height="100">
-        <rect x="0" y="0" width="100" height="100" fill="url(#pattern1)"/>
+    <pattern patternUnits="userSpaceOnUse" id="pattern1" x="0" y="0" width="100" height="100">
+        <rect x="0" y="0" width="50" height="50" fill="url(#pattern1)"/>
+        <rect x="50" y="50" width="100" height="100" fill="green"/>
+    </pattern>
+
+    <pattern patternUnits="userSpaceOnUse" id="pattern2" x="0" y="0" width="100" height="100">
+        <rect x="50" y="50" width="100" height="100" fill="green"/>
+        <rect x="0" y="0" width="50" height="50" fill="url(#pattern1)"/>
     </pattern>
 
@@ -13 +20 @@
 
     <pattern id="pattern6" xlink:href="#pattern5"/>
-    <pattern id="pattern5" x="0" y="0" width="100" height="100">
-        <rect x="0" y="0" width="100" height="100" fill="url(#pattern6)"/>
+    <pattern patternUnits="userSpaceOnUse"  id="pattern5" x="0" y="0" width="100" height="100">
+        <rect x="0" y="0" width="50" height="50" fill="url(#pattern6)"/>
+        <rect x="50" y="50" width="100" height="100" fill="green"/>
     </pattern>
 
-    <rect id="rect" x="0" y="0" width="100" height="100" fill="url(#pattern7)"/>
-    <pattern id="pattern7" x="0" y="0" width="100" height="100">
+    <rect id="rect" x="0" y="0" width="50" height="50" fill="url(#pattern7)"/>
+    <pattern patternUnits="userSpaceOnUse" id="pattern7" x="0" y="0" width="100" height="100">
         <use xlink:href="#rect"/>
+        <rect id="reuse" x="50" y="50" width="100" height="100" fill="green"/>
     </pattern>
     
-        <rect id="rect2" x="0" y="0" width="100" height="100" fill="url(#pattern8)"/>
-        <use id="use" xlink:href="#rect2"/>
-    <pattern id="pattern8" x="0" y="0" width="100" height="100">
-        <use xlink:href="#use"/>
+    <rect id="rect2" x="0" y="0" width="50" height="50" fill="url(#pattern8)"/>
+    <use id="use" xlink:href="#rect2"/>
+    <pattern patternUnits="userSpaceOnUse" id="pattern8" x="0" y="0" width="100" height="100">
+        <g id="reuse2">
+            <use xlink:href="#reuse"/>
+            <use xlink:href="#use"/>
+        </g>
+    </pattern>
+
+    <pattern patternUnits="userSpaceOnUse" id="pattern9" x="0" y="0" width="100" height="100">
+        <use xlink:href="#reuse2"/>
     </pattern>
 </defs>
 
-<!-- This should not crash -->
-<rect x="0" y="0" width="100" height="100" fill="url(#pattern1)" stroke="green"/>
-<rect x="0" y="100" width="100" height="100" fill="url(#pattern2)" stroke="green"/>
-<rect x="100" y="0" width="100" height="100" fill="url(#pattern3)" stroke="green"/>
-<rect x="100" y="100" width="100" height="100" fill="url(#pattern4)" stroke="green"/>
-<rect x="0" y="200" width="100" height="100" fill="url(#pattern5)" stroke="green"/>
-<rect x="100" y="200" width="100" height="100" fill="url(#pattern6)" stroke="green"/>
-<rect x="0" y="300" width="100" height="100" fill="url(#pattern7)" stroke="green"/>
-<rect x="100" y="300" width="100" height="100" fill="url(#pattern8)" stroke="green"/>
+<rect x="0" y="0" width="100" height="100" fill="url(#pattern1)"/>
+<rect x="100" y="0" width="100" height="100" fill="url(#pattern2)"/>
+<rect x="200" y="0" width="100" height="100" fill="url(#pattern3)"/>
+<rect x="0" y="100" width="100" height="100" fill="url(#pattern4)"/>
+<rect x="100" y="100" width="100" height="100" fill="url(#pattern5)"/>
+<rect x="200" y="100" width="100" height="100" fill="url(#pattern6)"/>
+<rect x="0" y="200" width="100" height="100" fill="url(#pattern7)"/>
+<rect x="100" y="200" width="100" height="100" fill="url(#pattern8)"/>
+<rect x="200" y="200" width="100" height="100" fill="url(#pattern9)"/>
+
+<line x1="325" x2="325" y1="0" y2="300" stroke="red"/>
+<text text-anchor="middle" x="325" y="350">Both sides of the red line should look identical</text>
+
+<!-- This is the reference rendering -->
+<g transform="translate(350,0)">
+    <rect x="0" y="0" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="100" y="0" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="200" y="0" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="0" y="100" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="100" y="100" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="200" y="100" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="0" y="200" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="100" y="200" width="100" height="100" fill="url(#pattern0)"/>
+    <rect x="200" y="200" width="100" height="100" fill="url(#pattern0)"/>
+</g>
 </svg>

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-07-29  Nikolas Zimmermann  <nzimmermann@rim.com>
+
+        Reviewed by Dirk Schulze.
+
+        WebKit shouldn't ignore resource cycles, but break them as Opera does
+        https://bugs.webkit.org/show_bug.cgi?id=43031
+
+        mask images are not updated when render objects' bounds change
+        https://bugs.webkit.org/show_bug.cgi?id=15124
+
+        SVG Gradients do not resize correctly
+        https://bugs.webkit.org/show_bug.cgi?id=41902
+
+        svg/dynamic-updates: SVGMarkerElement markerHeight/Width tests are broken
+        https://bugs.webkit.org/show_bug.cgi?id=42616
+
+        svg/dynamic-updates: SVGMaskElement tests are all broken
+        https://bugs.webkit.org/show_bug.cgi?id=42617
+
+        Don't ignore resources containing cyclic references, but break them, as discussed on SVG WG mailing lists - to be compatible with Opera which already does that.
+
+        We used to lookup RenderSVGResourceContainers objects, by extracting the URI reference from the SVGRenderStyle, then utilizing getElementById() to lookup the
+        node, and access its renderer. Opera ignores such references, if they point to resources that contain cyclic references. Ignoring them would mean we have
+        to mutate the render style to empty the resource strings. That obviously doesn't work, as it would break expectations (getComputedStyle, etc.).
+
+        Introduce a SVGResources class that stores pointers to all resources, that can be applied to a RenderObject (clipper/filter/markers/masker).
+        Add a SVGResourcesCache class, which is basically a HashMap<RenderObject*, SVGResources*>. Whenever a RenderObject receives style, we extract the URI references
+        from the SVGRenderStyle, look up the RenderSVGResourceContainer* objects, and store them in a SVGResources* class. Then we execute a cycle detection logic,
+        which detects cyclic references and breaks them. Breaking them means just nulling the pointer to the resource in the SVGResources object. Those SVGResources
+        objects are cached, and used throughout the render tree to access resources. This way it's guaranteed that all cyclic references are resolved until layout/paint
+        phase begins.
+
+        Add destroy/styleDidChange/updateFromElement methods to all SVG renderers, in order to keep track of resource/client changes in the SVGResourcesCache.
+        As side-effect the SVGResourcesCache now knows which RenderObject references which resource, and thus can handle client registration for a RenderSVGResourceContainer.
+        The RenderSVGResourceContainer now holds a HashSet of RenderObjects, that's always up2date, and not related to the fact wheter a resources has already been used
+        for painting. The old logic missed to register clients for a resource, when the resource was in an invalid state. Fixing that fixes the svg/dynamic-updates/SVGMaskElement* tests.
+
+        Rewrite all svg/custom/recursive-(filter|gradient|mask|pattern).svg tests to contain a reference image how it should be renderered. All 1:1 compatible with Opera now.
+
+        * rendering/RenderForeignObject.cpp:
+        (WebCore::RenderForeignObject::layout): Grab selfNeedsLayout() before calling RenderBlock::layout(), otherwhise it's always false.
+        * rendering/RenderPath.cpp: Don't look up resources manually, use SVGResourcesCache.
+        (WebCore::RenderPath::fillContains): Remove constness, to avoid the need to pass around const RenderObjects* to the SVGResourcesCache.
+        (WebCore::RenderPath::strokeContains): Ditto.
+        (WebCore::RenderPath::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/.
+        (WebCore::RenderPath::calculateMarkerBoundsIfNeeded): Remove special client handling for markers, it's all unified now.
+        (WebCore::RenderPath::styleWillChange): Only call setNeedsBoundariesUpdate when handling StyleDifferenceRepaint/Layout.
+        * rendering/RenderPath.h:
+        * rendering/RenderSVGBlock.cpp:
+        (WebCore::RenderSVGBlock::destroy): Forward to SVGResourcesCache::clientDestroyed.
+        (WebCore::RenderSVGBlock::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged.
+        (WebCore::RenderSVGBlock::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
+        * rendering/RenderSVGBlock.h:
+        * rendering/RenderSVGContainer.cpp:
+        (WebCore::RenderSVGContainer::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/.
+        (WebCore::RenderSVGContainer::selfWillPaint): Don't look up resources manually, use SVGResourcesCache.
+        * rendering/RenderSVGContainer.h:
+        * rendering/RenderSVGGradientStop.cpp:
+        (WebCore::RenderSVGGradientStop::styleDidChange): Rewrite, as invalidateResourceClients() is gone.
+        * rendering/RenderSVGHiddenContainer.h: Make layout() protected, as RenderSVGResourceContainer overrides it.
+        * rendering/RenderSVGImage.cpp:
+        (WebCore::RenderSVGImage::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/.
+        (WebCore::RenderSVGImage::destroy): Forward to SVGResourcesCache::clientDestroyed.
+        (WebCore::RenderSVGImage::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged.
+        (WebCore::RenderSVGImage::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
+        (WebCore::RenderSVGImage::imageChanged): Don't look up resources manually, use SVGResourcesCache.
+        * rendering/RenderSVGImage.h:
+        * rendering/RenderSVGInline.cpp:
+        (WebCore::RenderSVGInline::destroy): Forward to SVGResourcesCache::clientDestroyed.
+        (WebCore::RenderSVGInline::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged.
+        (WebCore::RenderSVGInline::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
+        * rendering/RenderSVGInline.h:
+        * rendering/RenderSVGModelObject.cpp:
+        (WebCore::RenderSVGModelObject::destroy): Forward to SVGResourcesCache::clientDestroyed.
+        (WebCore::RenderSVGModelObject::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged.
+        (WebCore::RenderSVGModelObject::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
+        * rendering/RenderSVGModelObject.h:
+        * rendering/RenderSVGResource.cpp:
+        (WebCore::RenderSVGResource::fillPaintingResource): Remove const from RenderObject parameter.
+        (WebCore::RenderSVGResource::strokePaintingResource): Ditto.
+        (WebCore::RenderSVGResource::markForLayoutAndParentResourceInvalidation): Early exit if we found the first parent resource.
+        * rendering/RenderSVGResource.h:
+        * rendering/RenderSVGResourceClipper.cpp:
+        (WebCore::RenderSVGResourceClipper::~RenderSVGResourceClipper): Early exit if m_clipper is empty.
+        (WebCore::RenderSVGResourceClipper::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourceClipper::invalidateClient): Ditto.
+        (WebCore::RenderSVGResourceClipper::applyResource): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
+        (WebCore::RenderSVGResourceClipper::createClipData): Don't look up resources manually, use SVGResourcesCache.
+        (WebCore::RenderSVGResourceClipper::hitTestClipContent): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
+        * rendering/RenderSVGResourceClipper.h:
+        * rendering/RenderSVGResourceContainer.cpp:
+        (WebCore::svgExtensionsFromNode):
+        (WebCore::RenderSVGResourceContainer::RenderSVGResourceContainer): Stop registering resource from the constructor, delegate to styleDidChange.
+        (WebCore::RenderSVGResourceContainer::~RenderSVGResourceContainer): Only deregister resource if it was ever registered.
+        (WebCore::RenderSVGResourceContainer::layout): invalidateClients() here, to avoid the need for invalidateResourceClients() in the SVG DOM. Just call setNeedsLayout() from the SVG DOM.
+        (WebCore::RenderSVGResourceContainer::destroy): Forward to SVGResourcesCache::resourceDestroyed.
+        (WebCore::RenderSVGResourceContainer::styleDidChange): Register resource not in the constructor but when it first receives style.
+        (WebCore::RenderSVGResourceContainer::idChanged): Don't duplicate code, use existing methods from SVGResourcesCache.
+        (WebCore::RenderSVGResourceContainer::markAllClientsForInvalidation): Add new helper function, to share code between all resources.
+        (WebCore::RenderSVGResourceContainer::markClientForInvalidation): Ditto.
+        (WebCore::RenderSVGResourceContainer::addClient): SVGResourcesCache now manages the list of clients. It calls addClient() for each RenderObject that uses this resource.
+        (WebCore::RenderSVGResourceContainer::removeClient): SVGResourcesCache now manages the list of clients.
+        (WebCore::RenderSVGResourceContainer::registerResource): New helper function sharing code between idChanged / styleDidChange.
+        (WebCore::RenderSVGResourceContainer::transformOnNonScalingStroke): Add FIXME that the function is misplaced.
+        * rendering/RenderSVGResourceContainer.h: Move most functions to the new RenderSVGResourceContainer.cpp file.
+        * rendering/RenderSVGResourceFilter.cpp:
+        (WebCore::RenderSVGResourceFilter::~RenderSVGResourceFilter): Early exit if m_filter is empty.
+        (WebCore::RenderSVGResourceFilter::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourceFilter::invalidateClient): Ditto.
+        * rendering/RenderSVGResourceGradient.cpp:
+        (WebCore::RenderSVGResourceGradient::~RenderSVGResourceGradient): Early exit if m_gradient is empty.
+        (WebCore::RenderSVGResourceGradient::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourceGradient::invalidateClient): Ditto.
+        * rendering/RenderSVGResourceMarker.cpp:
+        (WebCore::RenderSVGResourceMarker::~RenderSVGResourceMarker): Now a no-op, markers are unified within the new client handling concept, no more special code needed.
+        (WebCore::RenderSVGResourceMarker::layout): As RenderSVGResourceMarker skips the RenderSVGResourceContainer::layout() method, we also need to call invalidateClients() here.
+        (WebCore::RenderSVGResourceMarker::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourceMarker::invalidateClient): Ditto.
+        (WebCore::RenderSVGResourceMarker::draw): Remove marker specific logic to catch circular references.
+        * rendering/RenderSVGResourceMarker.h:
+        * rendering/RenderSVGResourceMasker.cpp:
+        (WebCore::RenderSVGResourceMasker::~RenderSVGResourceMasker): Early exit if m_masker is empty.
+        (WebCore::RenderSVGResourceMasker::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourceMasker::invalidateClient): Ditto.
+        (WebCore::RenderSVGResourceMasker::applyResource): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
+        * rendering/RenderSVGResourceMasker.h:
+        * rendering/RenderSVGResourcePattern.cpp:
+        (WebCore::RenderSVGResourcePattern::~RenderSVGResourcePattern): Early exit if m_pattern is empty.
+        (WebCore::RenderSVGResourcePattern::invalidateClients): Use new helper functions to invalidate clients, shared between all resources in RenderSVGResourceContainer.
+        (WebCore::RenderSVGResourcePattern::invalidateClient): Ditto.
+        (WebCore::RenderSVGResourcePattern::createTileImage): Remove containsCyclicReference() check, SVGResourcesCycleSolver breaks cyclic references, resources do not need to take care anymore.
+        * rendering/RenderSVGResourcePattern.h:
+        * rendering/RenderSVGRoot.cpp:
+        (WebCore::RenderSVGRoot::selfWillPaint): Don't look up resources manually, use SVGResourcesCache.
+        (WebCore::RenderSVGRoot::destroy): Forward to SVGResourcesCache::clientDestroyed.
+        (WebCore::RenderSVGRoot::styleDidChange): Forward to SVGResourcesCache::clientStyleChanged.
+        (WebCore::RenderSVGRoot::updateFromElement): Forward to SVGResourcesCache::clientUpdatedFromElement.
+        * rendering/RenderSVGRoot.h:
+        * rendering/RenderSVGText.cpp:
+        (WebCore::RenderSVGText::layout): s/RenderSVGResource::invalidateAllResourcesOfRenderer/SVGResourcesCache::clientLayoutChanged/.
+        * rendering/RenderSVGText.h:
+        * rendering/SVGInlineTextBox.cpp:
+        (WebCore::SVGInlineTextBox::acquirePaintingResource): Add RenderObject* parameter, don't assume the style comes from the InlineTextBox parent renderer.
+        (WebCore::SVGInlineTextBox::prepareGraphicsContextForTextPainting): Pass the parent()->renderer() to acquirePaintingResource.
+        (WebCore::SVGInlineTextBox::paintDecoration): Pass the decoration renderer to acquirePaintingResource.
+        (WebCore::SVGInlineTextBox::paintDecorationWithStyle): Ditto.
+        (WebCore::SVGInlineTextBox::paintText): When a selection pseudo style is used to paint the selection, swap styles in the SVGResourcesCache, to take the right resources when painting.
+        * rendering/SVGInlineTextBox.h:
+        * rendering/SVGRenderSupport.cpp:
+        (WebCore::SVGRenderSupport::prepareToRenderSVGContent): Don't look up resources manually, use SVGResourcesCache.
+        (WebCore::SVGRenderSupport::finishRenderSVGContent): Ditto.
+        (WebCore::SVGRenderSupport::intersectRepaintRectWithResources): Ditto.
+        (WebCore::SVGRenderSupport::pointInClippingArea): Remove const from RenderObject parameter. 
+        * rendering/SVGRenderSupport.h:
+        * rendering/SVGRenderTreeAsText.cpp:
+        (WebCore::writeStyle): Add two const_cast now that fill/strokePaintingResource take RenderObject* parameters. This was the less intrusive approach, otherwhise more const_casts would be needed.
+        (WebCore::writeResources): Add FIXME that we should dump the resources present in the SVGResourcesCache instead of manually looking them up from the SVGRenderStyle, to avoid dumping cycles.
+        * rendering/SVGResourcesCache.cpp:
+        (WebCore::SVGResourcesCache::clientStyleChanged): Use markForLayoutAndParentResourceInvalidation() instead of duplicating code.
+        * rendering/SVGResourcesCycleSolver.cpp:
+        (WebCore::setFollowLinkForChainableResource): Implemented stub method.
+        * rendering/style/SVGRenderStyle.cpp:
+        (WebCore::SVGRenderStyle::diff): Return StyleDifferenceLayout, not Repaint for stroke paint changes, otherwhise the cached boundaries are not correctly updated.
+        * svg/SVGClipPathElement.cpp:
+        (WebCore::SVGClipPathElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGClipPathElement::childrenChanged): Ditto.
+        * svg/SVGClipPathElement.h:
+        (WebCore::SVGClipPathElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::insertedIntoDocument): Only execute buildPendingResource() logic, if needsPendingResourceHandling() returns true. Cleaned up code a bit, to deploy early returns.
+        * svg/SVGElement.h:
+        (WebCore::SVGElement::needsPendingResourceHandling): Return true (default). Only needed by SVGTextPathElement/SVGUseElement, and should be removed in future.
+        * svg/SVGFilterElement.cpp:
+        (WebCore::SVGFilterElement::SVGFilterElement): Initialize m_followLink=true.
+        (WebCore::SVGFilterElement::setFilterRes): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGFilterElement::svgAttributeChanged): Ditto.
+        (WebCore::SVGFilterElement::childrenChanged): Ditto.
+        * svg/SVGFilterElement.h:
+        (WebCore::SVGFilterElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        (WebCore::SVGFilterElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
+        * svg/SVGFilterPrimitiveStandardAttributes.cpp:
+        (WebCore::SVGFilterPrimitiveStandardAttributes::childrenChanged): Don't use invalidateResourceClients(), it's a no-op as effects don't have a renderer -> use invalidateFilter().
+        * svg/SVGFilterPrimitiveStandardAttributes.h:
+        (WebCore::SVGFilterPrimitiveStandardAttributes::invalidateFilter): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        * svg/SVGGradientElement.cpp:
+        (WebCore::SVGGradientElement::SVGGradientElement): Initialize m_followLink=true.
+        (WebCore::SVGGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGGradientElement::childrenChanged): Ditto.
+        * svg/SVGGradientElement.h:
+        (WebCore::SVGGradientElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        (WebCore::SVGGradientElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
+        * svg/SVGLinearGradientElement.cpp:
+        (WebCore::SVGLinearGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGLinearGradientElement::collectGradientProperties): Only follow xlink:href links if m_followLinks == true.
+        * svg/SVGMarkerElement.cpp:
+        (WebCore::SVGMarkerElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGMarkerElement::childrenChanged): Ditto.
+        (WebCore::SVGMarkerElement::setOrientToAuto): Ditto.
+        (WebCore::SVGMarkerElement::setOrientToAngle): Ditto.
+        * svg/SVGMarkerElement.h:
+        (WebCore::SVGMarkerElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        * svg/SVGMaskElement.cpp:
+        (WebCore::SVGMaskElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGMaskElement::childrenChanged): Ditto.
+        * svg/SVGMaskElement.h:
+        (WebCore::SVGMaskElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        * svg/SVGPatternElement.cpp:
+        (WebCore::SVGPatternElement::SVGPatternElement): Initialize m_followLink=true.
+        (WebCore::SVGPatternElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGPatternElement::childrenChanged): Ditto.
+        (WebCore::SVGPatternElement::collectPatternProperties): Only follow xlink:href links if m_followLinks == true.
+        * svg/SVGPatternElement.h:
+        (WebCore::SVGPatternElement::needsPendingResourceHandling): Return false, buildPendingResource() logic not needed anymore for resources, handled by RenderSVGResourceContainer.
+        (WebCore::SVGPatternElement::setFollowLink): Used by SVGResourcesCycleSolver, to stop following xlink:href links, if that leads to cyclic references.
+        * svg/SVGRadialGradientElement.cpp:
+        (WebCore::SVGRadialGradientElement::svgAttributeChanged): Don't use invalidateResourceClients(), it's not needed anymore, only call setNeedsLayout() on the renderer.
+        (WebCore::SVGRadialGradientElement::collectGradientProperties): Only follow xlink:href links if m_followLinks == true.
+        * svg/SVGStyledElement.cpp:
+        (WebCore::SVGStyledElement::attach): Call updateFromElement upon attach(), needed by all resource renderers. Defaults to a no-op in RenderObject.h
+        * svg/SVGStyledElement.h: Remove invalidateResourceClients(), it's not needed anymore.
+
 2010-07-29  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
 

trunk/WebCore/rendering/RenderForeignObject.cpp

@@ -118 +118 @@
     // FIXME: Investigate in location rounding issues - only affects RenderForeignObject & RenderSVGText
     setLocation(roundedIntPoint(viewportLocation));
+
+    bool layoutChanged = m_everHadLayout && selfNeedsLayout();
     RenderBlock::layout();
+    ASSERT(!needsLayout());
 
-    // Invalidate all resources of this client, if we changed something.
-    if (m_everHadLayout && selfNeedsLayout())
-        RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+    // Invalidate all resources of this client if our layout changed.
+    if (layoutChanged)
+        SVGResourcesCache::clientLayoutChanged(this);
 
     repainter.repaintAfterLayout();
-    setNeedsLayout(false);
 }
 

trunk/WebCore/rendering/RenderPath.cpp

@@ -36 +36 @@
 #include "RenderSVGContainer.h"
 #include "RenderSVGResourceMarker.h"
-#include "StrokeStyleApplier.h"
 #include "SVGRenderSupport.h"
+#include "SVGResources.h"
 #include "SVGStyledTransformableElement.h"
 #include "SVGTransformList.h"
 #include "SVGURIReference.h"
+#include "StrokeStyleApplier.h"
 #include <wtf/MathExtras.h>
 
@@ -73 +74 @@
 }
 
-bool RenderPath::fillContains(const FloatPoint& point, bool requiresFill, WindRule fillRule) const
+bool RenderPath::fillContains(const FloatPoint& point, bool requiresFill, WindRule fillRule)
 {
     if (!m_fillBoundingBox.contains(point))
@@ -84 +85 @@
 }
 
-bool RenderPath::strokeContains(const FloatPoint& point, bool requiresStroke) const
+bool RenderPath::strokeContains(const FloatPoint& point, bool requiresStroke)
 {
     if (!m_strokeAndMarkerBoundingBox.contains(point))
@@ -112 +113 @@
     }
 
-    // Invalidate all resources of this client, if we changed something.
+    // Invalidate all resources of this client if our layout changed.
     if (m_everHadLayout && selfNeedsLayout())
-        RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+        SVGResourcesCache::clientLayoutChanged(this);
 
     // At this point LayoutRepainter already grabbed the old bounds,
@@ -235 +236 @@
 FloatRect RenderPath::calculateMarkerBoundsIfNeeded()
 {
-    Document* doc = document();
-
     SVGElement* svgElement = static_cast<SVGElement*>(node());
     ASSERT(svgElement && svgElement->document());
@@ -249 +248 @@
     ASSERT(svgStyle->hasMarkers());
 
-    AtomicString startMarkerId(svgStyle->markerStartResource());
-    AtomicString midMarkerId(svgStyle->markerMidResource());
-    AtomicString endMarkerId(svgStyle->markerEndResource());
-
-    RenderSVGResourceMarker* startMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, startMarkerId);
-    RenderSVGResourceMarker* midMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, midMarkerId);
-    RenderSVGResourceMarker* endMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(doc, endMarkerId);
-
-    if (!startMarker && !startMarkerId.isEmpty())
-        svgElement->document()->accessSVGExtensions()->addPendingResource(startMarkerId, styledElement);
-    else if (startMarker)
-        startMarker->addClient(this);
-
-    if (!midMarker && !midMarkerId.isEmpty())
-        svgElement->document()->accessSVGExtensions()->addPendingResource(midMarkerId, styledElement);
-    else if (midMarker)
-        midMarker->addClient(this);
-
-    if (!endMarker && !endMarkerId.isEmpty())
-        svgElement->document()->accessSVGExtensions()->addPendingResource(endMarkerId, styledElement);
-    else if (endMarker)
-        endMarker->addClient(this);
-
-    if (!startMarker && !midMarker && !endMarker)
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
+    if (!resources)
         return FloatRect();
 
+    RenderSVGResourceMarker* markerStart = resources->markerStart();
+    RenderSVGResourceMarker* markerMid = resources->markerMid();
+    RenderSVGResourceMarker* markerEnd = resources->markerEnd();
+    if (!markerStart && !markerMid && !markerEnd)
+        return FloatRect();
+
     float strokeWidth = SVGRenderStyle::cssPrimitiveToLength(this, svgStyle->strokeWidth(), 1.0f);
-    return m_markerLayoutInfo.calculateBoundaries(startMarker, midMarker, endMarker, strokeWidth, m_path);
+    return m_markerLayoutInfo.calculateBoundaries(markerStart, markerMid, markerEnd, strokeWidth, m_path);
 }
 
 void RenderPath::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
 {
-    setNeedsBoundariesUpdate();
+    if (diff == StyleDifferenceLayout)
+        setNeedsBoundariesUpdate();
     RenderSVGModelObject::styleWillChange(diff, newStyle);
 }

trunk/WebCore/rendering/RenderPath.h

@@ -48 +48 @@
 private:
     // Hit-detection seperated for the fill and the stroke
-    bool fillContains(const FloatPoint&, bool requiresFill = true, WindRule fillRule = RULE_NONZERO) const;
-    bool strokeContains(const FloatPoint&, bool requiresStroke = true) const;
+    bool fillContains(const FloatPoint&, bool requiresFill = true, WindRule fillRule = RULE_NONZERO);
+    bool strokeContains(const FloatPoint&, bool requiresStroke = true);
 
     virtual FloatRect objectBoundingBox() const { return m_fillBoundingBox; }

trunk/WebCore/rendering/RenderSVGBlock.cpp

@@ -26 +26 @@
 #include "RenderSVGBlock.h"
 
+#include "RenderSVGResource.h"
 #include "SVGElement.h"
 
@@ -74 +75 @@
     ASSERT_NOT_REACHED();
 }
+
+void RenderSVGBlock::destroy()
+{
+    SVGResourcesCache::clientDestroyed(this);
+    RenderBlock::destroy();
+}
+
+void RenderSVGBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+    RenderBlock::styleDidChange(diff, oldStyle);
+    SVGResourcesCache::clientStyleChanged(this, diff, style());
+}
+
+void RenderSVGBlock::updateFromElement()
+{
+    RenderBlock::updateFromElement();
+    SVGResourcesCache::clientUpdatedFromElement(this, style());
+}
+
 }
 

trunk/WebCore/rendering/RenderSVGBlock.h

@@ -39 +39 @@
 
     virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);
+
+    virtual void destroy();
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+    virtual void updateFromElement();
 };
 

trunk/WebCore/rendering/RenderSVGContainer.cpp

@@ -32 +32 @@
 #include "RenderView.h"
 #include "SVGRenderSupport.h"
+#include "SVGResources.h"
 #include "SVGStyledElement.h"
 
@@ -59 +60 @@
     SVGRenderSupport::layoutChildren(this, selfNeedsLayout());
 
-    // Invalidate all resources of this client, if we changed something.
+    // Invalidate all resources of this client if our layout changed.
     if (m_everHadLayout && selfNeedsLayout())
-        RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+        SVGResourcesCache::clientLayoutChanged(this);
 
     repainter.repaintAfterLayout();
@@ -67 +68 @@
 }
 
-bool RenderSVGContainer::selfWillPaint() const
+bool RenderSVGContainer::selfWillPaint()
 {
 #if ENABLE(FILTERS)
-    const SVGRenderStyle* svgStyle = style()->svgStyle();
-    RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(document(), svgStyle->filterResource());
-    if (filter)
-        return true;
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
+    return resources && resources->filter();
 #endif
     return false;

trunk/WebCore/rendering/RenderSVGContainer.h

@@ -70 +70 @@
     virtual bool pointIsInsideViewportClip(const FloatPoint& /*pointInParent*/) { return true; }
 
-    bool selfWillPaint() const;
+    bool selfWillPaint();
 
 private:

trunk/WebCore/rendering/RenderSVGGradientStop.cpp

@@ -26 +26 @@
 #include "RenderSVGGradientStop.h"
 
+#include "RenderSVGResourceContainer.h"
 #include "SVGGradientElement.h"
 #include "SVGNames.h"
+#include "SVGResourcesCache.h"
 #include "SVGStopElement.h"
 
@@ -49 +51 @@
     // <stop> elements should only be allowed to make renderers under gradient elements
     // but I can imagine a few cases we might not be catching, so let's not crash if our parent isn't a gradient.
-    if (SVGGradientElement* gradient = gradientElement())
-        gradient->invalidateResourceClients();
+    SVGGradientElement* gradient = gradientElement();
+    if (!gradient)
+        return;
+
+    RenderObject* renderer = gradient->renderer();
+    if (!renderer)
+        return;
+
+    ASSERT(renderer->isSVGResourceContainer());
+    RenderSVGResourceContainer* container = renderer->toRenderSVGResourceContainer();
+    container->invalidateClients();
 }
 

trunk/WebCore/rendering/RenderSVGHiddenContainer.h

@@ -25 +25 @@
 
 #if ENABLE(SVG)
-
 #include "RenderSVGContainer.h"
 
@@ -40 +39 @@
         virtual const char* renderName() const { return "RenderSVGHiddenContainer"; }
 
+    protected:
+        virtual void layout();
+
     private:
         virtual bool isSVGHiddenContainer() const { return true; }
         virtual bool requiresLayer() const { return false; }
 
-        virtual void layout();
         virtual void paint(PaintInfo&, int parentX, int parentY);
         

trunk/WebCore/rendering/RenderSVGImage.cpp

@@ -40 +40 @@
 #include "SVGPreserveAspectRatio.h"
 #include "SVGRenderSupport.h"
+#include "SVGResources.h"
 
 namespace WebCore {
@@ -71 +72 @@
     m_cachedLocalRepaintRect = FloatRect();
 
-    // Invalidate all resources of this client, if we changed something.
+    // Invalidate all resources of this client if our layout changed.
     if (m_everHadLayout && selfNeedsLayout())
-        RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+        SVGResourcesCache::clientLayoutChanged(this);
 
     repainter.repaintAfterLayout();
@@ -111 +112 @@
 void RenderSVGImage::destroy()
 {
-    RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+    SVGResourcesCache::clientDestroyed(this);
     RenderImage::destroy();
+}
+
+void RenderSVGImage::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+    RenderImage::styleDidChange(diff, oldStyle);
+    SVGResourcesCache::clientStyleChanged(this, diff, style());
+}
+
+void RenderSVGImage::updateFromElement()
+{
+    RenderImage::updateFromElement();
+    SVGResourcesCache::clientUpdatedFromElement(this, style());
 }
 
@@ -161 +174 @@
 {
     RenderImage::imageChanged(image, rect);
-#if ENABLE(FILTERS)
+
     // The image resource defaults to nullImage until the resource arrives.
-    // This empty image may be cached by SVG filter effects which must be invalidated.
-    if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(document(), style()->svgStyle()->filterResource()))
-        filter->invalidateClient(this);
-#endif
+    // This empty image may be cached by SVG resources which must be invalidated.
+    if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this))
+        resources->invalidateClient(this);
+
     repaint();
 }

trunk/WebCore/rendering/RenderSVGImage.h

@@ -66 +66 @@
 
     virtual void destroy();
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+    virtual void updateFromElement();
 
     virtual bool requiresLayer() const { return false; }

trunk/WebCore/rendering/RenderSVGInline.cpp

@@ -27 +27 @@
 #include "RenderSVGInline.h"
 
+#include "RenderSVGResource.h"
 #include "SVGInlineFlowBox.h"
 
@@ -93 +94 @@
 }
 
+void RenderSVGInline::destroy()
+{
+    SVGResourcesCache::clientDestroyed(this);
+    RenderInline::destroy();
+}
+
+void RenderSVGInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+    RenderInline::styleDidChange(diff, oldStyle);
+    SVGResourcesCache::clientStyleChanged(this, diff, style());
+}
+
+void RenderSVGInline::updateFromElement()
+{
+    RenderInline::updateFromElement();
+    SVGResourcesCache::clientUpdatedFromElement(this, style());
+}
+
 
 }

trunk/WebCore/rendering/RenderSVGInline.h

@@ -55 +55 @@
 private:
     virtual InlineFlowBox* createInlineFlowBox();
+
+    virtual void destroy();
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+    virtual void updateFromElement();
 };
 

trunk/WebCore/rendering/RenderSVGModelObject.cpp

@@ -84 +84 @@
 void RenderSVGModelObject::destroy()
 {
-    RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+    SVGResourcesCache::clientDestroyed(this);
     RenderObject::destroy();
 }
@@ -91 +91 @@
 {
     RenderObject::styleDidChange(diff, oldStyle);
+    SVGResourcesCache::clientStyleChanged(this, diff, style());
+}
 
-    if (style() && (diff == StyleDifferenceLayout || diff == StyleDifferenceRepaint))
-        RenderSVGResource::markForLayoutAndParentResourceInvalidation(this, false);
+void RenderSVGModelObject::updateFromElement()
+{
+    RenderObject::updateFromElement();
+    SVGResourcesCache::clientUpdatedFromElement(this, style());
 }
 

trunk/WebCore/rendering/RenderSVGModelObject.h

@@ -63 +63 @@
     virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&) const;
     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+    virtual void updateFromElement();
 
 private:

trunk/WebCore/rendering/RenderSVGResource.cpp

@@ -27 +27 @@
 #include "RenderSVGResource.h"
 
-#include "RenderSVGResourceClipper.h"
 #include "RenderSVGResourceContainer.h"
-#include "RenderSVGResourceFilter.h"
-#include "RenderSVGResourceMarker.h"
-#include "RenderSVGResourceMasker.h"
 #include "RenderSVGResourceSolidColor.h"
+#include "SVGResources.h"
 #include "SVGURIReference.h"
 
 namespace WebCore {
-
-static inline void registerPendingResource(const AtomicString& id, const SVGPaint::SVGPaintType& paintType, const RenderObject* object)
-{
-    if (paintType != SVGPaint::SVG_PAINTTYPE_URI)
-        return;
-
-    SVGElement* svgElement = static_cast<SVGElement*>(object->node());
-    ASSERT(svgElement);
-    ASSERT(svgElement->isStyled());
-
-    object->document()->accessSVGExtensions()->addPendingResource(id, static_cast<SVGStyledElement*>(svgElement));
-}
 
 inline void RenderSVGResource::adjustColorForPseudoRules(const RenderStyle* style, bool useFillPaint, Color& color)
@@ -70 +55 @@
 
 // FIXME: This method and strokePaintingResource() should be refactored, to share even more code
-RenderSVGResource* RenderSVGResource::fillPaintingResource(const RenderObject* object, const RenderStyle* style)
+RenderSVGResource* RenderSVGResource::fillPaintingResource(RenderObject* object, const RenderStyle* style)
 {
     ASSERT(object);
@@ -85 +70 @@
 
     SVGPaint::SVGPaintType paintType = fillPaint->paintType();
-    if (paintType == SVGPaint::SVG_PAINTTYPE_URI
-        || paintType == SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR) {
-        AtomicString id(SVGURIReference::getTarget(fillPaint->uri()));
-        fillPaintingResource = getRenderSVGResourceContainerById(object->document(), id);
-
-        if (!fillPaintingResource)
-            registerPendingResource(id, paintType, object);
+    if (paintType == SVGPaint::SVG_PAINTTYPE_URI || paintType == SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR) {
+        if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object))
+            fillPaintingResource = resources->fill();
     }
 
@@ -123 +104 @@
 }
 
-RenderSVGResource* RenderSVGResource::strokePaintingResource(const RenderObject* object, const RenderStyle* style)
+RenderSVGResource* RenderSVGResource::strokePaintingResource(RenderObject* object, const RenderStyle* style)
 {
     ASSERT(object);
@@ -139 +120 @@
 
     SVGPaint::SVGPaintType paintType = strokePaint->paintType();
-    if (!objectBoundingBox.isEmpty()
-        && (paintType == SVGPaint::SVG_PAINTTYPE_URI || paintType == SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR)) {
-        AtomicString id(SVGURIReference::getTarget(strokePaint->uri()));
-        strokePaintingResource = getRenderSVGResourceContainerById(object->document(), id);
-
-        if (!strokePaintingResource)
-            registerPendingResource(id, paintType, object);
+    if (!objectBoundingBox.isEmpty() && (paintType == SVGPaint::SVG_PAINTTYPE_URI || paintType == SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR)) {
+        if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object))
+            strokePaintingResource = resources->stroke();
     }
 
@@ -185 +162 @@
 }
 
-void RenderSVGResource::markForLayoutAndResourceInvalidation(RenderObject* object, bool needsBoundariesUpdate)
-{
-    ASSERT(object);
-    ASSERT(object->node());
-    ASSERT(object->node()->isSVGElement());
-
-    // Eventually mark the renderer needing a boundaries update
-    if (needsBoundariesUpdate)
-        object->setNeedsBoundariesUpdate();
-
-    markForLayoutAndParentResourceInvalidation(object);
-}
-
-static inline void invalidatePaintingResource(SVGPaint* paint, RenderObject* object)
-{
-    ASSERT(paint);
-
-    SVGPaint::SVGPaintType paintType = paint->paintType();
-    if (paintType != SVGPaint::SVG_PAINTTYPE_URI && paintType != SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR)
-        return;
-
-    AtomicString id(SVGURIReference::getTarget(paint->uri()));
-    if (RenderSVGResourceContainer* paintingResource = getRenderSVGResourceContainerById(object->document(), id))
-        paintingResource->invalidateClient(object);
-}
-
-void RenderSVGResource::invalidateAllResourcesOfRenderer(RenderObject* object)
-{
-    ASSERT(object);
-    ASSERT(object->style());
-
-    Document* document = object->document();
-    ASSERT(document);
-
-    const SVGRenderStyle* svgStyle = object->style()->svgStyle();
-    ASSERT(svgStyle);
-
-    // Masker
-    if (RenderSVGResourceMasker* masker = getRenderSVGResourceById<RenderSVGResourceMasker>(document, svgStyle->maskerResource()))
-        masker->invalidateClient(object);
-
-    // Clipper
-    if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(document, svgStyle->clipperResource()))
-        clipper->invalidateClient(object);
-
-    // Filter
-#if ENABLE(FILTERS)
-    if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(document, svgStyle->filterResource()))
-        filter->invalidateClient(object);
-#endif
-
-    // Markers
-    if (RenderSVGResourceMarker* startMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(document, svgStyle->markerStartResource()))
-        startMarker->invalidateClient(object);
-    if (RenderSVGResourceMarker* midMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(document, svgStyle->markerMidResource()))
-        midMarker->invalidateClient(object);
-    if (RenderSVGResourceMarker* endMarker = getRenderSVGResourceById<RenderSVGResourceMarker>(document, svgStyle->markerEndResource()))
-        endMarker->invalidateClient(object);
-
-    // Gradients/Patterns
-    if (svgStyle->hasFill())
-        invalidatePaintingResource(svgStyle->fillPaint(), object);
-    if (svgStyle->hasStroke())
-        invalidatePaintingResource(svgStyle->strokePaint(), object);
-}
-
 void RenderSVGResource::markForLayoutAndParentResourceInvalidation(RenderObject* object, bool needsLayout)
 {
@@ -260 +171 @@
     RenderObject* current = object->parent();
     while (current) {
-        if (current->isSVGResourceContainer()) 
+        if (current->isSVGResourceContainer()) {
             current->toRenderSVGResourceContainer()->invalidateClients();
+            break;
+        }
 
         current = current->parent();

trunk/WebCore/rendering/RenderSVGResource.h

@@ -23 +23 @@
 
 #if ENABLE(SVG)
+#include "RenderStyleConstants.h"
 #include "SVGDocumentExtensions.h"
 
@@ -76 +77 @@
 
     // Helper utilities used in the render tree to access resources used for painting shapes/text (gradients & patterns only)
-    static RenderSVGResource* fillPaintingResource(const RenderObject*, const RenderStyle*);
-    static RenderSVGResource* strokePaintingResource(const RenderObject*, const RenderStyle*);
+    static RenderSVGResource* fillPaintingResource(RenderObject*, const RenderStyle*);
+    static RenderSVGResource* strokePaintingResource(RenderObject*, const RenderStyle*);
     static RenderSVGResourceSolidColor* sharedSolidPaintingResource();
 
-    static void invalidateAllResourcesOfRenderer(RenderObject*);
     static void markForLayoutAndParentResourceInvalidation(RenderObject*, bool needsLayout = true);
 
 private:
     static void adjustColorForPseudoRules(const RenderStyle*, bool useFillPaint, Color&);
-    
-protected:
-    void markForLayoutAndResourceInvalidation(RenderObject*, bool needsBoundariesUpdate = true);
 };
 

trunk/WebCore/rendering/RenderSVGResourceClipper.cpp

@@ -22 +22 @@
 
 #include "config.h"
+
 #if ENABLE(SVG)
 #include "RenderSVGResourceClipper.h"
@@ -33 +34 @@
 #include "IntRect.h"
 #include "RenderObject.h"
+#include "RenderSVGResource.h"
 #include "RenderStyle.h"
-#include "RenderSVGResource.h"
 #include "SVGClipPathElement.h"
 #include "SVGElement.h"
 #include "SVGRenderSupport.h"
+#include "SVGResources.h"
 #include "SVGStyledElement.h"
 #include "SVGStyledTransformableElement.h"
@@ -56 +58 @@
 RenderSVGResourceClipper::~RenderSVGResourceClipper()
 {
+    if (m_clipper.isEmpty())
+        return;
+
     deleteAllValues(m_clipper);
     m_clipper.clear();
@@ -65 +70 @@
         return;
 
-    HashMap<RenderObject*, ClipperData*>::const_iterator end = m_clipper.end();
-    for (HashMap<RenderObject*, ClipperData*>::const_iterator it = m_clipper.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(it->first);
-
-    deleteAllValues(m_clipper);
-    m_clipper.clear();
     m_clipBoundaries = FloatRect();
-}
-
-void RenderSVGResourceClipper::invalidateClient(RenderObject* object)
-{
+    if (!m_clipper.isEmpty()) {
+        deleteAllValues(m_clipper);
+        m_clipper.clear();
+    }
+
+    markAllClientsForInvalidation(LayoutAndBoundariesInvalidation);
+}
+
+void RenderSVGResourceClipper::invalidateClient(RenderObject* client)
+{
+    ASSERT(client);
     if (m_invalidationBlocked)
         return;
 
-    ASSERT(object);
-    if (!m_clipper.contains(object))
-        return;
-
-    delete m_clipper.take(object);
-    markForLayoutAndResourceInvalidation(object);
+    ASSERT(client->selfNeedsLayout());
+    if (m_clipper.contains(client))
+        delete m_clipper.take(client);
+
+    markClientForInvalidation(client, BoundariesInvalidation);
 }
 
@@ -96 +101 @@
     UNUSED_PARAM(resourceMode);
 #endif
-
-    // Early exit, if this resource contains a child which references ourselves.
-    if (containsCyclicReference(node()))
-        return false;
 
     applyClippingToContext(object, object->objectBoundingBox(), object->repaintRectInLocalCoordinates(), context);
@@ -192 +193 @@
 
     // clipPath can also be clipped by another clipPath.
-    if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(this->document(), style()->svgStyle()->clipperResource())) {
-        if (!clipper->applyClippingToContext(this, objectBoundingBox, repaintRect, maskContext)) {
-            maskContext->restore();
-            return false;
-        }            
+    if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this)) {
+        if (RenderSVGResourceClipper* clipper = resources->clipper()) {
+            if (!clipper->applyClippingToContext(this, objectBoundingBox, repaintRect, maskContext)) {
+                maskContext->restore();
+                return false;
+            }
+        }
     }
 
@@ -281 +284 @@
 bool RenderSVGResourceClipper::hitTestClipContent(const FloatRect& objectBoundingBox, const FloatPoint& nodeAtPoint)
 {
-    // FIXME: We should be able to check whether m_clipper.contains(object) - this doesn't work at the moment
-    // as resourceBoundingBox() has already created ClipperData, even if applyResource() returned false.
-    // Early exit, if this resource contains a child which references ourselves.
-    if (containsCyclicReference(node()))
-        return false;
-
     FloatPoint point = nodeAtPoint;
     if (!SVGRenderSupport::pointInClippingArea(this, point))
@@ -311 +308 @@
 
     return false;
-}
-
-bool RenderSVGResourceClipper::childElementReferencesResource(const SVGRenderStyle* style, const String& referenceId) const
-{
-    if (!style->hasClipper())
-        return false;
-
-    return style->clipperResource() == referenceId;
 }
 

trunk/WebCore/rendering/RenderSVGResourceClipper.h

@@ -69 +69 @@
     void calculateClipContentRepaintRect();
 
-    virtual bool childElementReferencesResource(const SVGRenderStyle*, const String&) const;
-
     bool m_invalidationBlocked;
     FloatRect m_clipBoundaries;

trunk/WebCore/rendering/RenderSVGResourceContainer.cpp

@@ -29 +29 @@
 namespace WebCore {
 
+static inline SVGDocumentExtensions* svgExtensionsFromNode(Node* node)
+{
+    ASSERT(node);
+    ASSERT(node->document());
+    return node->document()->accessSVGExtensions();
+}
+
 RenderSVGResourceContainer::RenderSVGResourceContainer(SVGStyledElement* node)
     : RenderSVGHiddenContainer(node)
-    , RenderSVGResource()
     , m_id(node->hasID() ? node->getIdAttribute() : nullAtom)
+    , m_registered(false)
 {
-    ASSERT(node->document());
-    node->document()->accessSVGExtensions()->addResource(m_id, this);
 }
 
 RenderSVGResourceContainer::~RenderSVGResourceContainer()
 {
-    ASSERT(node());
-    ASSERT(node()->document());
-    node()->document()->accessSVGExtensions()->removeResource(m_id);
+    if (m_registered)
+        svgExtensionsFromNode(node())->removeResource(m_id);
+}
+
+void RenderSVGResourceContainer::layout()
+{
+    // Invalidate all resources if our layout changed.
+    if (m_everHadLayout && selfNeedsLayout())
+        invalidateClients();
+
+    RenderSVGHiddenContainer::layout();
+}
+
+void RenderSVGResourceContainer::destroy()
+{
+    SVGResourcesCache::resourceDestroyed(this);
+    RenderSVGHiddenContainer::destroy();
+}
+
+void RenderSVGResourceContainer::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+    RenderSVGHiddenContainer::styleDidChange(diff, oldStyle);
+
+    if (!m_registered) {
+        m_registered = true;
+        registerResource();
+    }
 }
 
 void RenderSVGResourceContainer::idChanged()
 {
-    ASSERT(node());
-    ASSERT(node()->document());
-    SVGDocumentExtensions* extensions = node()->document()->accessSVGExtensions();
+    // Invalidate all our current clients.
+    invalidateClients();
 
-    // Remove old id, that is guaranteed to be present in cache
+    // Remove old id, that is guaranteed to be present in cache.
+    SVGDocumentExtensions* extensions = svgExtensionsFromNode(node());
     extensions->removeResource(m_id);
     m_id = static_cast<Element*>(node())->getIdAttribute();
 
-    // It's possible that an element is referencing us with the new id, and has to be notified that we're existing now
-    if (extensions->isPendingResource(m_id)) {
-        OwnPtr<HashSet<SVGStyledElement*> > clients(extensions->removePendingResource(m_id));
-        if (clients->isEmpty())
-            return;
+    registerResource();
+}
 
-        HashSet<SVGStyledElement*>::const_iterator it = clients->begin();
-        const HashSet<SVGStyledElement*>::const_iterator end = clients->end();
+void RenderSVGResourceContainer::markAllClientsForInvalidation(InvalidationMode mode)
+{
+    if (m_clients.isEmpty())
+        return;
 
-        for (; it != end; ++it) {
-            if (RenderObject* renderer = (*it)->renderer())
-                renderer->setNeedsLayout(true);
-        }
+    bool needsLayout = mode == LayoutAndBoundariesInvalidation;
+
+    HashSet<RenderObject*>::iterator end = m_clients.end();
+    for (HashSet<RenderObject*>::iterator it = m_clients.begin(); it != end; ++it) {
+        markClientForInvalidation(*it, mode);
+        RenderSVGResource::markForLayoutAndParentResourceInvalidation(*it, needsLayout);
+    }
+}
+
+void RenderSVGResourceContainer::markClientForInvalidation(RenderObject* client, InvalidationMode mode)
+{
+    ASSERT(client);
+    ASSERT(!m_clients.isEmpty());
+
+    switch (mode) {
+    case LayoutAndBoundariesInvalidation:
+    case BoundariesInvalidation:
+        client->setNeedsBoundariesUpdate();
+        break;
+    case RepaintInvalidation:
+        if (client->view())
+            client->repaint();
+        break;
+    }
+}
+
+void RenderSVGResourceContainer::addClient(RenderObject* client)
+{
+    ASSERT(client);
+    m_clients.add(client);
+}
+
+void RenderSVGResourceContainer::removeClient(RenderObject* client)
+{
+    ASSERT(client);
+    m_clients.remove(client);
+}
+
+void RenderSVGResourceContainer::registerResource()
+{
+    SVGDocumentExtensions* extensions = svgExtensionsFromNode(node());
+    if (!extensions->isPendingResource(m_id)) {
+        extensions->addResource(m_id, this);
+        return;
     }
 
-    // Recache us with the new id
+    OwnPtr<HashSet<SVGStyledElement*> > clients(extensions->removePendingResource(m_id));
+
+    // Cache us with the new id.
     extensions->addResource(m_id, this);
+
+    // Update cached resources of pending clients.
+    const HashSet<SVGStyledElement*>::const_iterator end = clients->end();
+    for (HashSet<SVGStyledElement*>::const_iterator it = clients->begin(); it != end; ++it) {
+        RenderObject* renderer = (*it)->renderer();
+        if (!renderer)
+            continue;
+        SVGResourcesCache::clientUpdatedFromElement(renderer, renderer->style());
+        renderer->setNeedsLayout(true);
+    }
 }
 
+// FIXME: This does not belong here.
 AffineTransform RenderSVGResourceContainer::transformOnNonScalingStroke(RenderObject* object, const AffineTransform& resourceTransform)
 {
@@ -85 +166 @@
 }
 
-bool RenderSVGResourceContainer::containsCyclicReference(const Node* startNode) const
-{
-    ASSERT(startNode->document());
-
-    for (Node* node = startNode->firstChild(); node; node = node->nextSibling()) {
-        if (!node->isSVGElement())
-            continue;
-
-        RenderObject* renderer = node->renderer();
-        if (!renderer)
-            continue;
-
-        RenderStyle* style = renderer->style();
-        if (!style)
-            continue;
-
-        const SVGRenderStyle* svgStyle = style->svgStyle();
-        ASSERT(svgStyle);
-
-        // Let the class inheriting from us decide whether the child element references ourselves.
-        if (childElementReferencesResource(svgStyle, m_id))
-            return true;
-
-        // Dive into shadow tree to check for cycles there.
-        if (node->hasTagName(SVGNames::useTag)) {
-            ASSERT(renderer->isSVGShadowTreeRootContainer());
-            if (Node* shadowRoot = static_cast<RenderSVGShadowTreeRootContainer*>(renderer)->rootElement()) {
-                if (containsCyclicReference(shadowRoot))
-                    return true;
-            }
-
-        }
-
-        if (node->hasChildNodes()) {
-            if (containsCyclicReference(node))
-                return true;
-        }
-    }
-
-    return false;
-}
-
 }
 

trunk/WebCore/rendering/RenderSVGResourceContainer.h

@@ -24 +24 @@
 #if ENABLE(SVG)
 #include "RenderSVGHiddenContainer.h"
-
-#include "SVGStyledTransformableElement.h"
 #include "RenderSVGResource.h"
-#include "RenderSVGShadowTreeRootContainer.h"
 
 namespace WebCore {
@@ -37 +34 @@
     virtual ~RenderSVGResourceContainer();
 
-    void idChanged();
+    virtual void layout();
+    virtual void destroy();
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
 
     virtual bool isSVGResourceContainer() const { return true; }
     virtual bool drawsContents() { return false; }
-
     virtual RenderSVGResourceContainer* toRenderSVGResourceContainer() { return this; }
-    virtual bool childElementReferencesResource(const SVGRenderStyle*, const String&) const { return false; }
 
     static AffineTransform transformOnNonScalingStroke(RenderObject*, const AffineTransform& resourceTransform);
 
-    bool containsCyclicReference(const Node* startNode) const;
+    void idChanged();
+
+protected:
+    enum InvalidationMode {
+        LayoutAndBoundariesInvalidation,
+        BoundariesInvalidation,
+        RepaintInvalidation
+    };
+
+    // Used from the invalidateClient/invalidateClients methods from classes, inheriting from us.
+    void markAllClientsForInvalidation(InvalidationMode);
+    void markClientForInvalidation(RenderObject*, InvalidationMode);
 
 private:
     friend class SVGResourcesCache;
-
-    // FIXME: No-ops for now, until follow-up patch on bug 43031 lands.
-    void addClient(RenderObject*) { }
-    void removeClient(RenderObject*) { }
+    void addClient(RenderObject*);
+    void removeClient(RenderObject*);
 
 private:
+    void registerResource();
+
     AtomicString m_id;
+    bool m_registered;
+    HashSet<RenderObject*> m_clients;
 };
 

trunk/WebCore/rendering/RenderSVGResourceFilter.cpp

@@ -61 +61 @@
 RenderSVGResourceFilter::~RenderSVGResourceFilter()
 {
+    if (m_filter.isEmpty())
+        return;
+
     deleteAllValues(m_filter);
     m_filter.clear();
@@ -67 +70 @@
 void RenderSVGResourceFilter::invalidateClients()
 {
-    HashMap<RenderObject*, FilterData*>::const_iterator end = m_filter.end();
-    for (HashMap<RenderObject*, FilterData*>::const_iterator it = m_filter.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(it->first);
-
-    deleteAllValues(m_filter);
-    m_filter.clear();
-}
-
-void RenderSVGResourceFilter::invalidateClient(RenderObject* object)
-{
-    ASSERT(object);
-    if (!m_filter.contains(object))
-        return;
-
-    delete m_filter.take(object);
-    markForLayoutAndResourceInvalidation(object);
+    if (!m_filter.isEmpty()) {
+        deleteAllValues(m_filter);
+        m_filter.clear();
+    }
+
+    markAllClientsForInvalidation(LayoutAndBoundariesInvalidation);
+}
+
+void RenderSVGResourceFilter::invalidateClient(RenderObject* client)
+{
+    ASSERT(client);
+    ASSERT(client->selfNeedsLayout());
+
+    if (m_filter.contains(client))
+        delete m_filter.take(client);
+
+    markClientForInvalidation(client, BoundariesInvalidation);
 }
 

trunk/WebCore/rendering/RenderSVGResourceGradient.cpp

@@ -44 +44 @@
 RenderSVGResourceGradient::~RenderSVGResourceGradient()
 {
+    if (m_gradient.isEmpty())
+        return;
+
     deleteAllValues(m_gradient);
     m_gradient.clear();
@@ -50 +53 @@
 void RenderSVGResourceGradient::invalidateClients()
 {
-    const HashMap<RenderObject*, GradientData*>::const_iterator end = m_gradient.end();
-    for (HashMap<RenderObject*, GradientData*>::const_iterator it = m_gradient.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(it->first, false);
-
-    deleteAllValues(m_gradient);
-    m_gradient.clear();
-}
-
-void RenderSVGResourceGradient::invalidateClient(RenderObject* object)
-{
-    ASSERT(object);
-    if (!m_gradient.contains(object))
-        return;
-
-    delete m_gradient.take(object);
-    markForLayoutAndResourceInvalidation(object, false);
+    if (!m_gradient.isEmpty()) {
+        deleteAllValues(m_gradient);
+        m_gradient.clear();
+    }
+
+    markAllClientsForInvalidation(RepaintInvalidation);
+}
+
+void RenderSVGResourceGradient::invalidateClient(RenderObject* client)
+{
+    ASSERT(client);
+    ASSERT(client->selfNeedsLayout());
+
+    if (m_gradient.contains(client))
+        delete m_gradient.take(client);
+
+    markClientForInvalidation(client, RepaintInvalidation);
 }
 

trunk/WebCore/rendering/RenderSVGResourceMarker.cpp

@@ -22 +22 @@
 
 #include "config.h"
+
 #if ENABLE(SVG)
 #include "RenderSVGResourceMarker.h"
@@ -44 +45 @@
 RenderSVGResourceMarker::~RenderSVGResourceMarker()
 {
-    m_marker.clear();
 }
 
 void RenderSVGResourceMarker::layout()
 {
+    // Invalidate all resources if our layout changed.
+    if (m_everHadLayout && selfNeedsLayout())
+        invalidateClients();
+
     // RenderSVGHiddenContainer overwrites layout(). We need the
     // layouting of RenderSVGContainer for calculating  local
@@ -55 +59 @@
 }
 
-void RenderSVGResourceMarker::addClient(const RenderObject* object)
+void RenderSVGResourceMarker::invalidateClients()
 {
-    m_marker.add(object);
+    markAllClientsForInvalidation(LayoutAndBoundariesInvalidation);
 }
 
-void RenderSVGResourceMarker::invalidateClients()
+void RenderSVGResourceMarker::invalidateClient(RenderObject* client)
 {
-    const HashSet<const RenderObject*>::const_iterator end = m_marker.end();
-    for (HashSet<const RenderObject*>::const_iterator it = m_marker.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(const_cast<RenderObject*>(*it));
-
-    m_marker.clear();
-}
-
-void RenderSVGResourceMarker::invalidateClient(RenderObject* object)
-{
-    ASSERT(object);
-    if (!m_marker.contains(object))
-        return;
-
-    m_marker.remove(object);
-    markForLayoutAndResourceInvalidation(object);
+    ASSERT(client);
+    ASSERT(client->selfNeedsLayout());
+    markClientForInvalidation(client, BoundariesInvalidation);
 }
 
@@ -141 +133 @@
 void RenderSVGResourceMarker::draw(PaintInfo& paintInfo, const AffineTransform& transform)
 {
-    DEFINE_STATIC_LOCAL(HashSet<RenderSVGResourceMarker*>, currentlyDrawingMarkers, ());
-
-    // avoid drawing circular marker references
-    if (currentlyDrawingMarkers.contains(this))
-        return;
-
-    currentlyDrawingMarkers.add(this);
     PaintInfo info(paintInfo);
     info.context->save();
@@ -153 +138 @@
     RenderSVGContainer::paint(info, 0, 0);
     info.context->restore();
-
-    currentlyDrawingMarkers.remove(this);
 }
 

trunk/WebCore/rendering/RenderSVGResourceMarker.h

@@ -42 +42 @@
     virtual const char* renderName() const { return "RenderSVGResourceMarker"; }
 
-    void addClient(const RenderObject*);
     virtual void invalidateClients();
     virtual void invalidateClient(RenderObject*);
@@ -75 +74 @@
     AffineTransform viewportTransform() const;
 
-    // Save objects using this marker for invalidation.
-    HashSet<const RenderObject*> m_marker;
-
     mutable AffineTransform m_localToParentTransform;
     FloatRect m_viewport;

trunk/WebCore/rendering/RenderSVGResourceMasker.cpp

@@ -20 +20 @@
 
 #include "config.h"
+
 #if ENABLE(SVG)
 #include "RenderSVGResourceMasker.h"
@@ -52 +53 @@
 RenderSVGResourceMasker::~RenderSVGResourceMasker()
 {
+    if (m_masker.isEmpty())
+        return;
+
     deleteAllValues(m_masker);
     m_masker.clear();
@@ -58 +62 @@
 void RenderSVGResourceMasker::invalidateClients()
 {
-    HashMap<RenderObject*, MaskerData*>::const_iterator end = m_masker.end();
-    for (HashMap<RenderObject*, MaskerData*>::const_iterator it = m_masker.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(it->first);
-
-    deleteAllValues(m_masker);
-    m_masker.clear();
     m_maskBoundaries = FloatRect();
-}
-
-void RenderSVGResourceMasker::invalidateClient(RenderObject* object)
-{
-    ASSERT(object);
-    if (!m_masker.contains(object))
-        return;
-
-    delete m_masker.take(object);
-    markForLayoutAndResourceInvalidation(object);
-}
-
-bool RenderSVGResourceMasker::childElementReferencesResource(const SVGRenderStyle* style, const String& referenceId) const
-{
-    if (!style->hasMasker())
-        return false;
-
-    return style->maskerResource() == referenceId;
+    if (!m_masker.isEmpty()) {
+        deleteAllValues(m_masker);
+        m_masker.clear();
+    }
+
+    markAllClientsForInvalidation(LayoutAndBoundariesInvalidation);
+}
+
+void RenderSVGResourceMasker::invalidateClient(RenderObject* client)
+{
+    ASSERT(client);
+    ASSERT(client->selfNeedsLayout());
+
+    if (m_masker.contains(client))
+        delete m_masker.take(client);
+
+    markClientForInvalidation(client, BoundariesInvalidation);
 }
 
@@ -103 +100 @@
         if (!maskElement)
             return false;
-
-        // Early exit, if this resource contains a child which references ourselves.
-        if (containsCyclicReference(node()))
-            return false;
-
         createMaskImage(maskerData, maskElement, object);
     }

trunk/WebCore/rendering/RenderSVGResourceMasker.h

@@ -70 +70 @@
     void calculateMaskContentRepaintRect();
 
-    virtual bool childElementReferencesResource(const SVGRenderStyle*, const String&) const;
-
     FloatRect m_maskBoundaries;
     HashMap<RenderObject*, MaskerData*> m_masker;

trunk/WebCore/rendering/RenderSVGResourcePattern.cpp

@@ -41 +41 @@
 RenderSVGResourcePattern::~RenderSVGResourcePattern()
 {
+    if (m_pattern.isEmpty())
+        return;
+
     deleteAllValues(m_pattern);
     m_pattern.clear();
@@ -47 +50 @@
 void RenderSVGResourcePattern::invalidateClients()
 {
-    const HashMap<RenderObject*, PatternData*>::const_iterator end = m_pattern.end();
-    for (HashMap<RenderObject*, PatternData*>::const_iterator it = m_pattern.begin(); it != end; ++it)
-        markForLayoutAndResourceInvalidation(it->first, false);
-
-    deleteAllValues(m_pattern);
-    m_pattern.clear();
-}
-
-void RenderSVGResourcePattern::invalidateClient(RenderObject* object)
-{
-    ASSERT(object);
-    if (!m_pattern.contains(object))
-        return;
-
-    delete m_pattern.take(object);
-    markForLayoutAndResourceInvalidation(object, false);
-}
-
-bool RenderSVGResourcePattern::childElementReferencesResource(const SVGRenderStyle* style, const String& referenceId) const
-{
-    if (style->hasFill()) {
-        if (style->fillPaint()->matchesTargetURI(referenceId))
-            return true;
-    }
-
-    if (style->hasStroke()) {
-        if (style->strokePaint()->matchesTargetURI(referenceId))
-            return true;
-    }
-
-    return false;
+    if (!m_pattern.isEmpty()) {
+        deleteAllValues(m_pattern);
+        m_pattern.clear();
+    }
+
+    markAllClientsForInvalidation(RepaintInvalidation);
+}
+
+void RenderSVGResourcePattern::invalidateClient(RenderObject* client)
+{
+    ASSERT(client);
+    ASSERT(client->selfNeedsLayout());
+
+    if (m_pattern.contains(client))
+        delete m_pattern.take(client);
+
+    markClientForInvalidation(client, RepaintInvalidation);
 }
 
@@ -245 +234 @@
         return 0;
 
-    // Early exit, if this resource contains a child which references ourselves.
-    if (containsCyclicReference(attributes.patternContentElement()))
-        return 0;
-
     FloatRect objectBoundingBox = object->objectBoundingBox();    
     FloatRect patternBoundaries = calculatePatternBoundaries(attributes, objectBoundingBox, patternElement); 

trunk/WebCore/rendering/RenderSVGResourcePattern.h

@@ -68 +68 @@
                                                           const AffineTransform& viewBoxCTM, const FloatRect& patternBoundaries) const;
 
-    virtual bool childElementReferencesResource(const SVGRenderStyle*, const String&) const;
-
     HashMap<RenderObject*, PatternData*> m_pattern;
 };

trunk/WebCore/rendering/RenderSVGRoot.cpp

@@ -33 +33 @@
 #include "SVGLength.h"
 #include "SVGRenderSupport.h"
+#include "SVGResources.h"
 #include "SVGSVGElement.h"
 #include "SVGStyledElement.h"
@@ -130 +131 @@
 }
 
-bool RenderSVGRoot::selfWillPaint() const
+bool RenderSVGRoot::selfWillPaint()
 {
 #if ENABLE(FILTERS)
-    const SVGRenderStyle* svgStyle = style()->svgStyle();
-    RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(document(), svgStyle->filterResource());
-    if (filter)
-        return true;
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(this);
+    return resources && resources->filter();
 #endif
     return false;
@@ -193 +192 @@
 void RenderSVGRoot::destroy()
 {
-    RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+    SVGResourcesCache::clientDestroyed(this);
     RenderBox::destroy();
+}
+
+void RenderSVGRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+    RenderBox::styleDidChange(diff, oldStyle);
+    SVGResourcesCache::clientStyleChanged(this, diff, style());
+}
+
+void RenderSVGRoot::updateFromElement()
+{
+    RenderBox::updateFromElement();
+    SVGResourcesCache::clientUpdatedFromElement(this, style());
 }
 

trunk/WebCore/rendering/RenderSVGRoot.h

@@ -59 +59 @@
 
     virtual void destroy();
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+    virtual void updateFromElement();
 
     virtual const AffineTransform& localToParentTransform() const;
@@ -78 +80 @@
     void calcViewport();
 
-    bool selfWillPaint() const;
+    bool selfWillPaint();
 
     IntSize parentOriginToBorderBox() const;

trunk/WebCore/rendering/RenderSVGText.cpp

@@ -99 +99 @@
     forceLayoutInlineChildren();
 
-    // Invalidate all resources of this client, if we changed something.
+    // Invalidate all resources of this client if our layout changed.
     if (m_everHadLayout && selfNeedsLayout())
-        RenderSVGResource::invalidateAllResourcesOfRenderer(this);
+        SVGResourcesCache::clientLayoutChanged(this);
 
     repainter.repaintAfterLayout();
@@ -131 +131 @@
 
     return false;
-}
-
-void RenderSVGText::destroy()
-{
-    RenderSVGResource::invalidateAllResourcesOfRenderer(this);
-    RenderSVGBlock::destroy();
 }
 

trunk/WebCore/rendering/RenderSVGText.h

@@ -52 +52 @@
     virtual void layout();
 
-    virtual void destroy();
-
     virtual void absoluteQuads(Vector<FloatQuad>&);
 

trunk/WebCore/rendering/SVGInlineTextBox.cpp

@@ -296 +296 @@
 }
 
-bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, RenderStyle* style)
-{
+bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, RenderObject* renderer, RenderStyle* style)
+{
+    ASSERT(renderer);
+    ASSERT(style);
     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
 
-    RenderObject* parentRenderer = parent()->renderer();
-    ASSERT(parentRenderer);
-
     if (m_paintingResourceMode & ApplyToFillMode)
-        m_paintingResource = RenderSVGResource::fillPaintingResource(parentRenderer, style);
+        m_paintingResource = RenderSVGResource::fillPaintingResource(renderer, style);
     else if (m_paintingResourceMode & ApplyToStrokeMode)
-        m_paintingResource = RenderSVGResource::strokePaintingResource(parentRenderer, style);
+        m_paintingResource = RenderSVGResource::strokePaintingResource(renderer, style);
     else {
         // We're either called for stroking or filling.
@@ -315 +314 @@
         return false;
 
-    m_paintingResource->applyResource(parentRenderer, style, context, m_paintingResourceMode);
+    m_paintingResource->applyResource(renderer, style, context, m_paintingResourceMode);
     return true;
 }
@@ -332 +331 @@
 bool SVGInlineTextBox::prepareGraphicsContextForTextPainting(GraphicsContext*& context, TextRun& textRun, RenderStyle* style)
 {
-    bool acquiredResource = acquirePaintingResource(context, style);
+    bool acquiredResource = acquirePaintingResource(context, parent()->renderer(), style);
 
 #if ENABLE(SVG_FONTS)
@@ -509 +508 @@
     if (hasDecorationFill) {
         m_paintingResourceMode = ApplyToFillMode;
-        paintDecorationWithStyle(context, textOrigin, decorationStyle, decoration);
+        paintDecorationWithStyle(context, textOrigin, decorationRenderer, decoration);
     }
 
     if (hasDecorationStroke) {
         m_paintingResourceMode = ApplyToStrokeMode;
-        paintDecorationWithStyle(context, textOrigin, decorationStyle, decoration);
-    }
-}
-
-void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext* context, const FloatPoint& textOrigin, RenderStyle* decorationStyle, ETextDecoration decoration)
+        paintDecorationWithStyle(context, textOrigin, decorationRenderer, decoration);
+    }
+}
+
+void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext* context, const FloatPoint& textOrigin, RenderObject* decorationRenderer, ETextDecoration decoration)
 {
     ASSERT(!m_paintingResource);
     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
     ASSERT(m_currentChunkPart.isValid());
+
+    RenderStyle* decorationStyle = decorationRenderer->style();
+    ASSERT(decorationStyle);
 
     const Font& font = decorationStyle->font();
@@ -535 +537 @@
     context->addPath(Path::createRectangle(FloatRect(x, y, m_currentChunkPart.width, thickness)));
 
-    if (acquirePaintingResource(context, decorationStyle))
+    if (acquirePaintingResource(context, decorationRenderer, decorationStyle))
         releasePaintingResource(context);
 
@@ -615 +617 @@
 
     // Draw text using selection style from the start to the end position of the selection
+    if (style != selectionStyle)
+        SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, selectionStyle);
+
     TextRun selectionTextRun(constructTextRun(selectionStyle));
     paintTextWithShadows(context, textOrigin, selectionStyle, textRun, startPos, endPos);
+
+    if (style != selectionStyle)
+        SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, style);
 
     // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part

trunk/WebCore/rendering/SVGInlineTextBox.h

@@ -76 +76 @@
     AffineTransform buildChunkTransformation(SVGChar& firstCharacter) const;
 
-    bool acquirePaintingResource(GraphicsContext*&, RenderStyle*);
+    bool acquirePaintingResource(GraphicsContext*&, RenderObject*, RenderStyle*);
     void releasePaintingResource(GraphicsContext*&);
 
@@ -84 +84 @@
     void computeTextMatchMarkerRect(RenderStyle*);
     void paintDecoration(GraphicsContext*, const FloatPoint& textOrigin, ETextDecoration, bool hasSelection);
-    void paintDecorationWithStyle(GraphicsContext*, const FloatPoint& textOrigin, RenderStyle*, ETextDecoration);
+    void paintDecorationWithStyle(GraphicsContext*, const FloatPoint& textOrigin, RenderObject*, ETextDecoration);
     void paintSelection(GraphicsContext*, const FloatPoint& textOrigin, RenderStyle*);
     void paintText(GraphicsContext*, const FloatPoint& textOrigin, RenderStyle*, RenderStyle* selectionStyle, bool hasSelection, bool paintSelectedTextOnly);

trunk/WebCore/rendering/SVGRenderSupport.cpp

@@ -41 +41 @@
 #include "RenderSVGResourceMasker.h"
 #include "RenderSVGRoot.h"
+#include "SVGResources.h"
 #include "SVGStyledElement.h"
 #include "TransformState.h"
@@ -83 +84 @@
     ASSERT(svgElement && svgElement->document() && svgElement->isStyled());
 
-    SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(svgElement);
     RenderStyle* style = object->style();
     ASSERT(style);
@@ -110 +110 @@
     }
 
-    Document* document = object->document();
-
-    if (svgStyle->hasMasker()) {
-        AtomicString maskerId(svgStyle->maskerResource());
-        if (RenderSVGResourceMasker* masker = getRenderSVGResourceById<RenderSVGResourceMasker>(document, maskerId)) {
-            if (!masker->applyResource(object, style, paintInfo.context, ApplyToDefaultMode))
-                return false;
-        } else
-            document->accessSVGExtensions()->addPendingResource(maskerId, styledElement);
-    }
-
-    if (svgStyle->hasClipper()) {
-        AtomicString clipperId(svgStyle->clipperResource());
-        if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(document, clipperId))
-            clipper->applyResource(object, style, paintInfo.context, ApplyToDefaultMode);
-        else
-            document->accessSVGExtensions()->addPendingResource(clipperId, styledElement);
-    }
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object);
+    if (!resources)
+        return true;
+
+    if (RenderSVGResourceMasker* masker = resources->masker()) {
+        if (!masker->applyResource(object, style, paintInfo.context, ApplyToDefaultMode))
+            return false;
+    }
+
+    if (RenderSVGResourceClipper* clipper = resources->clipper())
+        clipper->applyResource(object, style, paintInfo.context, ApplyToDefaultMode);
 
 #if ENABLE(FILTERS)
-    if (svgStyle->hasFilter()) {
-        AtomicString filterId(svgStyle->filterResource());
-        if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(document, filterId)) { 
-            if (!filter->applyResource(object, style, paintInfo.context, ApplyToDefaultMode))
-                return false;
-        } else
-            document->accessSVGExtensions()->addPendingResource(filterId, styledElement);
+    if (RenderSVGResourceFilter* filter = resources->filter()) {
+        if (!filter->applyResource(object, style, paintInfo.context, ApplyToDefaultMode))
+            return false;
     }
 #endif
@@ -158 +147 @@
 
 #if ENABLE(FILTERS)
-    if (svgStyle->hasFilter()) {
-        AtomicString filterId(svgStyle->filterResource());
-        if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(object->document(), filterId)) { 
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object);
+    if (resources) {
+        if (RenderSVGResourceFilter* filter = resources->filter()) {
             filter->postApplyResource(object, paintInfo.context, ApplyToDefaultMode);
             paintInfo.context = savedContext;
@@ -290 +279 @@
 {
     ASSERT(object);
-    ASSERT(object->style());
-    const SVGRenderStyle* svgStyle = object->style()->svgStyle();
-    if (!svgStyle)
+
+    RenderStyle* style = object->style();
+    ASSERT(style);
+
+    const SVGRenderStyle* svgStyle = style->svgStyle();
+    ASSERT(svgStyle);
+
+    RenderObject* renderer = const_cast<RenderObject*>(object);
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(renderer);
+    if (!resources) {
+        svgStyle->inflateForShadow(repaintRect);
         return;
-        
-    RenderObject* renderer = const_cast<RenderObject*>(object);
+    }
+
 #if ENABLE(FILTERS)
-    if (svgStyle->hasFilter()) {
-        if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(object->document(), svgStyle->filterResource()))
-            repaintRect = filter->resourceBoundingBox(renderer);
-    }
-#endif
-
-    if (svgStyle->hasClipper()) {
-        if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(object->document(), svgStyle->clipperResource()))
-            repaintRect.intersect(clipper->resourceBoundingBox(renderer));
-    }
-    
-    if (svgStyle->hasMasker()) {
-        if (RenderSVGResourceMasker* masker = getRenderSVGResourceById<RenderSVGResourceMasker>(object->document(), svgStyle->maskerResource()))
-            repaintRect.intersect(masker->resourceBoundingBox(renderer));
-    }
-    
+    if (RenderSVGResourceFilter* filter = resources->filter())
+        repaintRect = filter->resourceBoundingBox(renderer);
+#endif
+
+    if (RenderSVGResourceClipper* clipper = resources->clipper())
+        repaintRect.intersect(clipper->resourceBoundingBox(renderer));
+
+    if (RenderSVGResourceMasker* masker = resources->masker())
+        repaintRect.intersect(masker->resourceBoundingBox(renderer));
+
     svgStyle->inflateForShadow(repaintRect);
 }
 
-bool SVGRenderSupport::pointInClippingArea(const RenderObject* object, const FloatPoint& point)
+bool SVGRenderSupport::pointInClippingArea(RenderObject* object, const FloatPoint& point)
 {
     ASSERT(object);
-    ASSERT(object->style());
-
-    Document* document = object->document();
-    ASSERT(document);
-
-    const SVGRenderStyle* svgStyle = object->style()->svgStyle();
+
+    RenderStyle* style = object->style();
+    ASSERT(style);
+
+    const SVGRenderStyle* svgStyle = style->svgStyle();
     ASSERT(svgStyle);
 
     // We just take clippers into account to determine if a point is on the node. The Specification may
     // change later and we also need to check maskers.
-    if (svgStyle->hasClipper()) {
-        if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(document, svgStyle->clipperResource()))
-            return clipper->hitTestClipContent(object->objectBoundingBox(), point);
-    }
+    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object);
+    if (!resources)
+        return true;
+
+    if (RenderSVGResourceClipper* clipper = resources->clipper())
+        return clipper->hitTestClipContent(object->objectBoundingBox(), point);
 
     return true;

trunk/WebCore/rendering/SVGRenderSupport.h

@@ -57 +57 @@
 
     // Determines whether the passed point lies in a clipping area
-    static bool pointInClippingArea(const RenderObject*, const FloatPoint&);
+    static bool pointInClippingArea(RenderObject*, const FloatPoint&);
 
     enum ContainerBoundingBoxMode {

trunk/WebCore/rendering/SVGRenderTreeAsText.cpp

@@ -367 +367 @@
         const RenderPath& path = static_cast<const RenderPath&>(object);
 
-        if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(&path, path.style())) {
+        if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(const_cast<RenderPath*>(&path), path.style())) {
             TextStreamSeparator s(" ");
             ts << " [stroke={" << s;
@@ -388 +388 @@
         }
 
-        if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(&path, path.style())) {
+        if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(const_cast<RenderPath*>(&path), path.style())) {
             TextStreamSeparator s(" ");
             ts << " [fill={" << s;
@@ -735 +735 @@
     const SVGRenderStyle* svgStyle = style->svgStyle();
 
+    // FIXME: We want to use SVGResourcesCache to determine which resources are present, instead of quering the resource <-> id cache.
+    // For now leave the DRT output as is, but later on we should change this so cycles are properly ignored in the DRT output.
     RenderObject& renderer = const_cast<RenderObject&>(object);
     if (!svgStyle->maskerResource().isEmpty()) {

trunk/WebCore/rendering/SVGResourcesCache.cpp

@@ -132 +132 @@
 
     clientUpdatedFromElement(renderer, newStyle);
-
-    // Invalidate resources in ancestor chain, if needed.
-    RenderObject* parent = renderer->parent();
-    while (parent) {
-        if (parent->isSVGResourceContainer()) {
-            parent->toRenderSVGResourceContainer()->invalidateClients();
-            break;
-        }
-
-        parent = parent->parent();
-    }
+    RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer, false);
 }
  

trunk/WebCore/rendering/SVGResourcesCycleSolver.cpp

@@ -112 +112 @@
 }
 
-static inline void setFollowLinkForChainableResource(SVGElement*, bool)
-{
-    // FIXME: Enable once the follow-up patch for bug 43031 lands
+static inline void setFollowLinkForChainableResource(SVGElement* element, bool followLink)
+{
+    if (element->hasTagName(SVGNames::patternTag))
+        static_cast<SVGPatternElement*>(element)->setFollowLink(followLink);
+    else if (element->hasTagName(SVGNames::linearGradientTag) || element->hasTagName(SVGNames::radialGradientTag))
+        static_cast<SVGGradientElement*>(element)->setFollowLink(followLink);
+    else if (element->hasTagName(SVGNames::filterTag))
+        static_cast<SVGFilterElement*>(element)->setFollowLink(followLink);
 }
 

trunk/WebCore/rendering/style/SVGRenderStyle.cpp

@@ -166 +166 @@
     if (stroke != other->stroke) {
         if (stroke->width != other->stroke->width
+            || stroke->paint != other->stroke->paint
             || stroke->miterLimit != other->stroke->miterLimit
             || stroke->dashArray != other->stroke->dashArray
@@ -171 +172 @@
             return StyleDifferenceLayout;
 
-        // Only these two cases remain, where we only need a repaint.
-        ASSERT(stroke->paint != other->stroke->paint || stroke->opacity != other->stroke->opacity);
+        // Only the stroke-opacity case remains, where we only need a repaint.
+        ASSERT(stroke->opacity != other->stroke->opacity);
         return StyleDifferenceRepaint;
     }

trunk/WebCore/svg/SVGClipPathElement.cpp

@@ -70 +70 @@
     SVGStyledTransformableElement::svgAttributeChanged(attrName);
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (attrName == SVGNames::clipPathUnitsAttr ||
         SVGTests::isKnownAttribute(attrName) || 
@@ -75 +79 @@
         SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
         SVGStyledTransformableElement::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -98 +102 @@
     SVGStyledTransformableElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 

trunk/WebCore/svg/SVGClipPathElement.h

@@ -40 +40 @@
 
     virtual bool isValid() const { return SVGTests::isValid(); }
+    virtual bool needsPendingResourceHandling() const { return false; }
 
     virtual void parseMappedAttribute(Attribute*);

trunk/WebCore/svg/SVGElement.cpp

@@ -279 +279 @@
 {
     StyledElement::insertedIntoDocument();
+
+    if (!needsPendingResourceHandling())
+        return;
+
     SVGDocumentExtensions* extensions = document()->accessSVGExtensions();
-
     String resourceId = getIdAttribute();
-    if (extensions->isPendingResource(resourceId)) {
-        OwnPtr<HashSet<SVGStyledElement*> > clients(extensions->removePendingResource(resourceId));
-        if (clients->isEmpty())
-            return;
-
-        HashSet<SVGStyledElement*>::const_iterator it = clients->begin();
-        const HashSet<SVGStyledElement*>::const_iterator end = clients->end();
-
-        for (; it != end; ++it)
-            (*it)->buildPendingResource();
-    }
+    if (!extensions->isPendingResource(resourceId))
+        return;
+    
+    OwnPtr<HashSet<SVGStyledElement*> > clients(extensions->removePendingResource(resourceId));
+    if (clients->isEmpty())
+        return;
+
+    const HashSet<SVGStyledElement*>::const_iterator end = clients->end();
+    for (HashSet<SVGStyledElement*>::const_iterator it = clients->begin(); it != end; ++it)
+        (*it)->buildPendingResource();
 }
 

trunk/WebCore/svg/SVGElement.h

@@ -98 +98 @@
 
         virtual ContainerNode* eventParentNode();
+
+        virtual bool needsPendingResourceHandling() const { return true; }
         virtual void buildPendingResource() { }
 

trunk/WebCore/svg/SVGFilterElement.cpp

@@ -48 +48 @@
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
+    , m_followLink(true)
     , m_filterUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
     , m_primitiveUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
@@ -67 +68 @@
     setFilterResXBaseValue(filterResX);
     setFilterResYBaseValue(filterResY);
-    invalidateResourceClients();
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 
@@ -122 +125 @@
     }
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (invalidateClients
         || attrName == SVGNames::filterUnitsAttr
@@ -130 +137 @@
         || SVGLangSpace::isKnownAttribute(attrName)
         || SVGExternalResourcesRequired::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -176 +183 @@
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 

trunk/WebCore/svg/SVGFilterElement.h

@@ -44 +44 @@
     virtual ~SVGFilterElement();
 
+    virtual bool needsPendingResourceHandling() const { return false; }
+
     void setFilterRes(unsigned long filterResX, unsigned long filterResY);
     FloatRect filterBoundingBox(const FloatRect&) const;
@@ -54 +56 @@
     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 
+    // FIXME: Add xlink:href support for filters, and use this property
+    void setFollowLink(bool followLink) { m_followLink = followLink; }
+
 private:
     virtual bool selfHasRelativeLengths() const;
+
+    bool m_followLink;
 
     DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::filterUnitsAttr, int, FilterUnits, filterUnits)

trunk/WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp

@@ -108 +108 @@
 
     if (!changedByParser)
-        invalidateResourceClients();
+        invalidateFilter();
 }
 

trunk/WebCore/svg/SVGFilterPrimitiveStandardAttributes.h

@@ -56 +56 @@
         if (!inDocument() || !parentNode()->hasTagName(SVGNames::filterTag))
             return;
-        static_cast<SVGFilterElement*>(parentNode())->invalidateResourceClients();
+        if (RenderObject* object = parentNode()->renderer())
+            object->setNeedsLayout(true);
     }
 

trunk/WebCore/svg/SVGGradientElement.cpp

@@ -43 +43 @@
     , SVGURIReference()
     , SVGExternalResourcesRequired()
+    , m_followLink(true)
     , m_gradientUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
     , m_gradientTransform(SVGTransformList::create(SVGNames::gradientTransformAttr))
@@ -86 +87 @@
     SVGStyledElement::svgAttributeChanged(attrName);
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (attrName == SVGNames::gradientUnitsAttr
         || attrName == SVGNames::gradientTransformAttr
@@ -92 +97 @@
         || SVGExternalResourcesRequired::isKnownAttribute(attrName)
         || SVGStyledElement::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -124 +129 @@
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 

trunk/WebCore/svg/SVGGradientElement.h

@@ -38 +38 @@
         virtual ~SVGGradientElement();
 
+        virtual bool needsPendingResourceHandling() const { return false; }
+
         virtual void parseMappedAttribute(Attribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
@@ -46 +48 @@
         Vector<Gradient::ColorStop> buildStops();
  
+        void setFollowLink(bool followLink) { m_followLink = followLink; }
+
     protected:
+        bool m_followLink;
+
         DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::spreadMethodAttr, int, SpreadMethod, spreadMethod)
         DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::gradientUnitsAttr, int, GradientUnits, gradientUnits)

trunk/WebCore/svg/SVGLinearGradientElement.cpp

@@ -77 +77 @@
         || attrName == SVGNames::y2Attr) {
         updateRelativeLengthsInformation();
-        invalidateResourceClients();
+
+        RenderObject* object = renderer();
+        if (!object)
+            return;
+
+        object->setNeedsLayout(true);
     }
 }
@@ -151 +156 @@
 
         // Respect xlink:href, take attributes from referenced element
-        Node* refNode = ownerDocument()->getElementById(SVGURIReference::getTarget(current->href()));
+        Node* refNode = m_followLink ? ownerDocument()->getElementById(SVGURIReference::getTarget(current->href())) : 0;
         if (refNode && (refNode->hasTagName(SVGNames::linearGradientTag) || refNode->hasTagName(SVGNames::radialGradientTag))) {
             current = static_cast<SVGGradientElement*>(refNode);
 
             // Cycle detection
-            if (processedGradients.contains(current))
-                return LinearGradientAttributes();
+            if (processedGradients.contains(current)) {
+                current = 0;
+                break;
+            }
 
             isLinear = current->hasTagName(SVGNames::linearGradientTag);

trunk/WebCore/svg/SVGMarkerElement.cpp

@@ -114 +114 @@
     }
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (invalidateClients
         || attrName == SVGNames::markerUnitsAttr
@@ -121 +125 @@
         || SVGFitToViewBox::isKnownAttribute(attrName)
         || SVGStyledElement::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -167 +171 @@
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 
@@ -176 +183 @@
     setOrientAngleBaseValue(SVGAngle());
 
-    invalidateResourceClients();
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 
@@ -184 +192 @@
     setOrientAngleBaseValue(angle);
 
-    invalidateResourceClients();
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 

trunk/WebCore/svg/SVGMarkerElement.h

@@ -57 +57 @@
     virtual ~SVGMarkerElement();
 
+    virtual bool needsPendingResourceHandling() const { return false; }
+
     AffineTransform viewBoxToViewTransform(float viewWidth, float viewHeight) const;
 

trunk/WebCore/svg/SVGMaskElement.cpp

@@ -103 +103 @@
     }
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (invalidateClients
         || attrName == SVGNames::maskUnitsAttr
@@ -110 +114 @@
         || SVGExternalResourcesRequired::isKnownAttribute(attrName)
         || SVGStyledElement::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -142 +146 @@
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 

trunk/WebCore/svg/SVGMaskElement.h

@@ -41 +41 @@
 
         virtual bool isValid() const { return SVGTests::isValid(); }
+        virtual bool needsPendingResourceHandling() const { return false; }
 
         FloatRect maskBoundingBox(const FloatRect&) const;

trunk/WebCore/svg/SVGPatternElement.cpp

@@ -57 +57 @@
     , SVGExternalResourcesRequired()
     , SVGFitToViewBox()
+    , m_followLink(true)
     , m_x(LengthModeWidth)
     , m_y(LengthModeHeight)
@@ -130 +131 @@
     }
 
+    RenderObject* object = renderer();
+    if (!object)
+        return;
+
     if (invalidateClients
         || attrName == SVGNames::patternUnitsAttr
@@ -140 +145 @@
         || SVGFitToViewBox::isKnownAttribute(attrName)
         || SVGStyledElement::isKnownAttribute(attrName))
-        invalidateResourceClients();
+        object->setNeedsLayout(true);
 }
 
@@ -189 +194 @@
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
-    if (!changedByParser)
-        invalidateResourceClients();
+    if (changedByParser)
+        return;
+
+    if (RenderObject* object = renderer())
+        object->setNeedsLayout(true);
 }
 
@@ -232 +240 @@
 
         // Respect xlink:href, take attributes from referenced element
-        Node* refNode = ownerDocument()->getElementById(SVGURIReference::getTarget(current->href()));
+        Node* refNode = m_followLink ? ownerDocument()->getElementById(SVGURIReference::getTarget(current->href())) : 0;
         if (refNode && refNode->hasTagName(SVGNames::patternTag)) {
             current = static_cast<const SVGPatternElement*>(const_cast<const Node*>(refNode));
 
             // Cycle detection
-            if (processedPatterns.contains(current))
-                return PatternAttributes();
+            if (processedPatterns.contains(current)) {
+                current = 0;
+                break;
+            }
         } else
             current = 0;

trunk/WebCore/svg/SVGPatternElement.h

@@ -48 +48 @@
         
         virtual bool isValid() const { return SVGTests::isValid(); }
+        virtual bool needsPendingResourceHandling() const { return false; }
 
         virtual void parseMappedAttribute(Attribute*);
@@ -57 +58 @@
 
         PatternAttributes collectPatternProperties() const;
+        void setFollowLink(bool followLink) { m_followLink = followLink; }
 
     private:
         virtual bool selfHasRelativeLengths() const;
+
+        bool m_followLink;
 
         DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::xAttr, SVGLength, X, x)

trunk/WebCore/svg/SVGRadialGradientElement.cpp

@@ -84 +84 @@
         || attrName == SVGNames::rAttr) {
         updateRelativeLengthsInformation();
-        invalidateResourceClients();
+        
+        RenderObject* object = renderer();
+        if (!object)
+            return;
+
+        object->setNeedsLayout(true);
     }
 }
@@ -164 +169 @@
 
         // Respect xlink:href, take attributes from referenced element
-        Node* refNode = ownerDocument()->getElementById(SVGURIReference::getTarget(current->href()));
+        Node* refNode = m_followLink ? ownerDocument()->getElementById(SVGURIReference::getTarget(current->href())) : 0;
         if (refNode && (refNode->hasTagName(SVGNames::radialGradientTag) || refNode->hasTagName(SVGNames::linearGradientTag))) {
             current = static_cast<SVGGradientElement*>(refNode);
 
             // Cycle detection
-            if (processedGradients.contains(current))
-                return RadialGradientAttributes();
+            if (processedGradients.contains(current)) {
+                current = 0;
+                break;
+            }
 
             isRadial = current->hasTagName(SVGNames::radialGradientTag);

trunk/WebCore/svg/SVGStyledElement.cpp

@@ -259 +259 @@
 }
 
-void SVGStyledElement::invalidateResourceClients()
-{
-    if (document()->parsing())
-        return;
-
-    RenderObject* object = renderer();
-    if (!object)
-        return;
-
-    if (object->isSVGResourceContainer())
-        object->toRenderSVGResourceContainer()->invalidateClients();
+void SVGStyledElement::attach()
+{
+    SVGElement::attach();
+
+    if (RenderObject* object = renderer())
+        object->updateFromElement();
 }
 

trunk/WebCore/svg/SVGStyledElement.h

@@ -58 +58 @@
         virtual void synchronizeProperty(const QualifiedName&);
 
+        virtual void attach();
         virtual void insertedIntoDocument();
         virtual void removedFromDocument();
@@ -64 +65 @@
         // Centralized place to force a manual style resolution. Hacky but needed for now.
         PassRefPtr<RenderStyle> resolveStyle(RenderStyle* parentStyle);
-
-        void invalidateResourceClients();
 
         bool instanceUpdatesBlocked() const;