Source/WebCore/svg/SVGUseElement.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
   4  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
   5  * Copyright (C) 2011 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
   6  * Copyright (C) 2012 University of Szeged
   7  * Copyright (C) 2012 Renata Hodovan <reni@webkit.org>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 #include "config.h"
  26
  27 #if ENABLE(SVG)
  28 #include "SVGUseElement.h"
  29
  30 #include "Attribute.h"
  31 #include "CachedResourceLoader.h"
  32 #include "CachedResourceRequest.h"
  33 #include "CachedSVGDocument.h"
  34 #include "Document.h"
  35 #include "ElementTraversal.h"
  36 #include "Event.h"
  37 #include "EventListener.h"
  38 #include "HTMLNames.h"
  39 #include "NodeRenderStyle.h"
  40 #include "RegisteredEventListener.h"
  41 #include "RenderSVGResource.h"
  42 #include "RenderSVGTransformableContainer.h"
  43 #include "ShadowRoot.h"
  44 #include "SVGElementInstance.h"
  45 #include "SVGElementRareData.h"
  46 #include "SVGElementInstanceList.h"
  47 #include "SVGGElement.h"
  48 #include "SVGLengthContext.h"
  49 #include "SVGNames.h"
  50 #include "SVGSMILElement.h"
  51 #include "SVGSVGElement.h"
  52 #include "SVGSymbolElement.h"
  53 #include "StyleResolver.h"
  54 #include "XLinkNames.h"
  55 #include "XMLDocumentParser.h"
  56 #include "XMLSerializer.h"
  57
  58 // Dump SVGElementInstance object tree - useful to debug instanceRoot problems
  59 // #define DUMP_INSTANCE_TREE
  60
  61 // Dump the deep-expanded shadow tree (where the renderers are built from)
  62 // #define DUMP_SHADOW_TREE
  63
  64 namespace WebCore {
  65
  66 // Animated property definitions
  67 DEFINE_ANIMATED_LENGTH(SVGUseElement, SVGNames::xAttr, X, x)
  68 DEFINE_ANIMATED_LENGTH(SVGUseElement, SVGNames::yAttr, Y, y)
  69 DEFINE_ANIMATED_LENGTH(SVGUseElement, SVGNames::widthAttr, Width, width)
  70 DEFINE_ANIMATED_LENGTH(SVGUseElement, SVGNames::heightAttr, Height, height)
  71 DEFINE_ANIMATED_STRING(SVGUseElement, XLinkNames::hrefAttr, Href, href)
  72 DEFINE_ANIMATED_BOOLEAN(SVGUseElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
  73
  74 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGUseElement)
  75     REGISTER_LOCAL_ANIMATED_PROPERTY(x)
  76     REGISTER_LOCAL_ANIMATED_PROPERTY(y)
  77     REGISTER_LOCAL_ANIMATED_PROPERTY(width)
  78     REGISTER_LOCAL_ANIMATED_PROPERTY(height)
  79     REGISTER_LOCAL_ANIMATED_PROPERTY(href)
  80     REGISTER_LOCAL_ANIMATED_PROPERTY(externalResourcesRequired)
  81     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGGraphicsElement)
  82 END_REGISTER_ANIMATED_PROPERTIES
  83
  84 inline SVGUseElement::SVGUseElement(const QualifiedName& tagName, Document& document, bool wasInsertedByParser)
  85     : SVGGraphicsElement(tagName, document)
  86     , m_x(LengthModeWidth)
  87     , m_y(LengthModeHeight)
  88     , m_width(LengthModeWidth)
  89     , m_height(LengthModeHeight)
  90     , m_wasInsertedByParser(wasInsertedByParser)
  91     , m_haveFiredLoadEvent(false)
  92     , m_needsShadowTreeRecreation(false)
  93     , m_svgLoadEventTimer(this, &SVGElement::svgLoadEventTimerFired)
  94 {
  95     ASSERT(hasCustomStyleResolveCallbacks());
  96     ASSERT(hasTagName(SVGNames::useTag));
  97     registerAnimatedPropertiesForSVGUseElement();
  98 }
  99
 100 PassRefPtr<SVGUseElement> SVGUseElement::create(const QualifiedName& tagName, Document& document, bool wasInsertedByParser)
 101 {
 102     // Always build a #shadow-root for SVGUseElement.
 103     RefPtr<SVGUseElement> use = adoptRef(new SVGUseElement(tagName, document, wasInsertedByParser));
 104     use->ensureUserAgentShadowRoot();
 105     return use.release();
 106 }
 107
 108 SVGUseElement::~SVGUseElement()
 109 {
 110     setCachedDocument(0);
 111
 112     clearResourceReferences();
 113 }
 114
 115 SVGElementInstance* SVGUseElement::instanceRoot()
 116 {
 117     // If there is no element instance tree, force immediate SVGElementInstance tree
 118     // creation by asking the document to invoke our recalcStyle function - as we can't
 119     // wait for the lazy creation to happen if e.g. JS wants to access the instanceRoot
 120     // object right after creating the element on-the-fly
 121     if (!m_targetElementInstance)
 122         document().updateLayoutIgnorePendingStylesheets();
 123
 124     return m_targetElementInstance.get();
 125 }
 126
 127 SVGElementInstance* SVGUseElement::animatedInstanceRoot() const
 128 {
 129     // FIXME: Implement me.
 130     return 0;
 131 }
 132
 133 bool SVGUseElement::isSupportedAttribute(const QualifiedName& attrName)
 134 {
 135     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
 136     if (supportedAttributes.isEmpty()) {
 137         SVGLangSpace::addSupportedAttributes(supportedAttributes);
 138         SVGExternalResourcesRequired::addSupportedAttributes(supportedAttributes);
 139         SVGURIReference::addSupportedAttributes(supportedAttributes);
 140         supportedAttributes.add(SVGNames::xAttr);
 141         supportedAttributes.add(SVGNames::yAttr);
 142         supportedAttributes.add(SVGNames::widthAttr);
 143         supportedAttributes.add(SVGNames::heightAttr);
 144     }
 145     return supportedAttributes.contains<SVGAttributeHashTranslator>(attrName);
 146 }
 147
 148 void SVGUseElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 149 {
 150     SVGParsingError parseError = NoError;
 151
 152     if (!isSupportedAttribute(name))
 153         SVGGraphicsElement::parseAttribute(name, value);
 154     else if (name == SVGNames::xAttr)
 155         setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
 156     else if (name == SVGNames::yAttr)
 157         setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
 158     else if (name == SVGNames::widthAttr)
 159         setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError, ForbidNegativeLengths));
 160     else if (name == SVGNames::heightAttr)
 161         setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
 162     else if (SVGLangSpace::parseAttribute(name, value)
 163              || SVGExternalResourcesRequired::parseAttribute(name, value)
 164              || SVGURIReference::parseAttribute(name, value)) {
 165     } else
 166         ASSERT_NOT_REACHED();
 167
 168     reportAttributeParsingError(parseError, name, value);
 169 }
 170
 171 static inline bool isWellFormedDocument(Document& document)
 172 {
 173     if (document.isSVGDocument() || document.isXHTMLDocument())
 174         return static_cast<XMLDocumentParser*>(document.parser())->wellFormed();
 175     return true;
 176 }
 177
 178 Node::InsertionNotificationRequest SVGUseElement::insertedInto(ContainerNode* rootParent)
 179 {
 180     // This functions exists to assure assumptions made in the code regarding SVGElementInstance creation/destruction are satisfied.
 181     SVGGraphicsElement::insertedInto(rootParent);
 182     if (!rootParent->inDocument())
 183         return InsertionDone;
 184     ASSERT(!m_targetElementInstance || !isWellFormedDocument(document()));
 185     ASSERT(!hasPendingResources() || !isWellFormedDocument(document()));
 186     if (!m_wasInsertedByParser)
 187         buildPendingResource();
 188     SVGExternalResourcesRequired::insertedIntoDocument(this);
 189     return InsertionDone;
 190 }
 191
 192 void SVGUseElement::removedFrom(ContainerNode* rootParent)
 193 {
 194     SVGGraphicsElement::removedFrom(rootParent);
 195     if (rootParent->inDocument())
 196         clearResourceReferences();
 197 }
 198
 199 Document* SVGUseElement::referencedDocument() const
 200 {
 201     if (!isExternalURIReference(href(), document()))
 202         return &document();
 203     return externalDocument();
 204 }
 205
 206 Document* SVGUseElement::externalDocument() const
 207 {
 208     if (m_cachedDocument && m_cachedDocument->isLoaded()) {
 209         // Gracefully handle error condition.
 210         if (m_cachedDocument->errorOccurred())
 211             return 0;
 212         ASSERT(m_cachedDocument->document());
 213         return m_cachedDocument->document();
 214     }
 215     return 0;
 216 }
 217
 218 void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
 219 {
 220     if (!isSupportedAttribute(attrName)) {
 221         SVGGraphicsElement::svgAttributeChanged(attrName);
 222         return;
 223     }
 224
 225     SVGElementInstance::InvalidationGuard invalidationGuard(this);
 226
 227     RenderObject* renderer = this->renderer();
 228     if (attrName == SVGNames::xAttr
 229         || attrName == SVGNames::yAttr
 230         || attrName == SVGNames::widthAttr
 231         || attrName == SVGNames::heightAttr) {
 232         updateRelativeLengthsInformation();
 233         if (renderer)
 234             RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
 235         return;
 236     }
 237
 238     if (SVGExternalResourcesRequired::handleAttributeChange(this, attrName))
 239         return;
 240
 241     if (SVGURIReference::isKnownAttribute(attrName)) {
 242         bool isExternalReference = isExternalURIReference(href(), document());
 243         if (isExternalReference) {
 244             KURL url = document().completeURL(href());
 245             if (url.hasFragmentIdentifier()) {
 246                 CachedResourceRequest request(ResourceRequest(url.string()));
 247                 request.setInitiator(this);
 248                 setCachedDocument(document().cachedResourceLoader()->requestSVGDocument(request));
 249             }
 250         } else
 251             setCachedDocument(0);
 252
 253         if (!m_wasInsertedByParser)
 254             buildPendingResource();
 255
 256         return;
 257     }
 258
 259     if (!renderer)
 260         return;
 261
 262     if (SVGLangSpace::isKnownAttribute(attrName)
 263         || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
 264         invalidateShadowTree();
 265         return;
 266     }
 267
 268     ASSERT_NOT_REACHED();
 269 }
 270
 271 bool SVGUseElement::willRecalcStyle(Style::Change)
 272 {
 273     if (!m_wasInsertedByParser && m_needsShadowTreeRecreation && renderer() && needsStyleRecalc())
 274         buildPendingResource();
 275     return true;
 276 }
 277
 278 #ifdef DUMP_INSTANCE_TREE
 279 static void dumpInstanceTree(unsigned int& depth, String& text, SVGElementInstance* targetInstance)
 280 {
 281     SVGElement* element = targetInstance->correspondingElement();
 282     ASSERT(element);
 283
 284     if (element->hasTagName(SVGNames::useTag)) {
 285         if (toSVGUseElement(element)->cachedDocumentIsStillLoading())
 286             return;
 287     }
 288
 289     SVGElement* shadowTreeElement = targetInstance->shadowTreeElement();
 290     ASSERT(shadowTreeElement);
 291
 292     SVGUseElement* directUseElement = targetInstance->directUseElement();
 293     String directUseElementName = directUseElement ? directUseElement->nodeName() : "null";
 294
 295     String elementId = element->getIdAttribute();
 296     String elementNodeName = element->nodeName();
 297     String shadowTreeElementNodeName = shadowTreeElement->nodeName();
 298     String parentNodeName = element->parentNode() ? element->parentNode()->nodeName() : "null";
 299     String firstChildNodeName = element->firstChild() ? element->firstChild()->nodeName() : "null";
 300
 301     for (unsigned int i = 0; i < depth; ++i)
 302         text += "  ";
 303
 304     text += String::format("SVGElementInstance this=%p, (parentNode=%s (%p), firstChild=%s (%p), correspondingElement=%s (%p), directUseElement=%s (%p), shadowTreeElement=%s (%p), id=%s)\n",
 305                            targetInstance, parentNodeName.latin1().data(), element->parentNode(), firstChildNodeName.latin1().data(), element->firstChild(),
 306                            elementNodeName.latin1().data(), element, directUseElementName.latin1().data(), directUseElement, shadowTreeElementNodeName.latin1().data(), shadowTreeElement, elementId.latin1().data());
 307
 308     for (unsigned int i = 0; i < depth; ++i)
 309         text += "  ";
 310
 311     const HashSet<SVGElementInstance*>& elementInstances = element->instancesForElement();
 312     text += "Corresponding element is associated with " + String::number(elementInstances.size()) + " instance(s):\n";
 313
 314     const HashSet<SVGElementInstance*>::const_iterator end = elementInstances.end();
 315     for (HashSet<SVGElementInstance*>::const_iterator it = elementInstances.begin(); it != end; ++it) {
 316         for (unsigned int i = 0; i < depth; ++i)
 317             text += "  ";
 318
 319         text += String::format(" -> SVGElementInstance this=%p, (refCount: %i, shadowTreeElement in document? %i)\n",
 320                                *it, (*it)->refCount(), (*it)->shadowTreeElement()->inDocument());
 321     }
 322
 323     ++depth;
 324
 325     for (SVGElementInstance* instance = targetInstance->firstChild(); instance; instance = instance->nextSibling())
 326         dumpInstanceTree(depth, text, instance);
 327
 328     --depth;
 329 }
 330 #endif
 331
 332 static bool isDisallowedElement(Node* node)
 333 {
 334     // Spec: "Any 'svg', 'symbol', 'g', graphics element or other 'use' is potentially a template object that can be re-used
 335     // (i.e., "instanced") in the SVG document via a 'use' element."
 336     // "Graphics Element" is defined as 'circle', 'ellipse', 'image', 'line', 'path', 'polygon', 'polyline', 'rect', 'text'
 337     // Excluded are anything that is used by reference or that only make sense to appear once in a document.
 338     // We must also allow the shadow roots of other use elements.
 339     if (node->isShadowRoot() || node->isTextNode())
 340         return false;
 341
 342     if (!node->isSVGElement())
 343         return true;
 344
 345     Element* element = toElement(node);
 346
 347     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, allowedElementTags, ());
 348     if (allowedElementTags.isEmpty()) {
 349         allowedElementTags.add(SVGNames::aTag);
 350         allowedElementTags.add(SVGNames::circleTag);
 351         allowedElementTags.add(SVGNames::descTag);
 352         allowedElementTags.add(SVGNames::ellipseTag);
 353         allowedElementTags.add(SVGNames::gTag);
 354         allowedElementTags.add(SVGNames::imageTag);
 355         allowedElementTags.add(SVGNames::lineTag);
 356         allowedElementTags.add(SVGNames::metadataTag);
 357         allowedElementTags.add(SVGNames::pathTag);
 358         allowedElementTags.add(SVGNames::polygonTag);
 359         allowedElementTags.add(SVGNames::polylineTag);
 360         allowedElementTags.add(SVGNames::rectTag);
 361         allowedElementTags.add(SVGNames::svgTag);
 362         allowedElementTags.add(SVGNames::switchTag);
 363         allowedElementTags.add(SVGNames::symbolTag);
 364         allowedElementTags.add(SVGNames::textTag);
 365         allowedElementTags.add(SVGNames::textPathTag);
 366         allowedElementTags.add(SVGNames::titleTag);
 367         allowedElementTags.add(SVGNames::trefTag);
 368         allowedElementTags.add(SVGNames::tspanTag);
 369         allowedElementTags.add(SVGNames::useTag);
 370     }
 371     return !allowedElementTags.contains<SVGAttributeHashTranslator>(element->tagQName());
 372 }
 373
 374 static bool subtreeContainsDisallowedElement(Node* start)
 375 {
 376     if (isDisallowedElement(start))
 377         return true;
 378
 379     for (Node* cur = start->firstChild(); cur; cur = cur->nextSibling()) {
 380         if (subtreeContainsDisallowedElement(cur))
 381             return true;
 382     }
 383
 384     return false;
 385 }
 386
 387 void SVGUseElement::clearResourceReferences()
 388 {
 389     // FIXME: We should try to optimize this, to at least allow partial reclones.
 390     if (ShadowRoot* shadowTreeRootElement = shadowRoot())
 391         shadowTreeRootElement->removeChildren();
 392
 393     if (m_targetElementInstance) {
 394         m_targetElementInstance->detach();
 395         m_targetElementInstance = 0;
 396     }
 397
 398     m_needsShadowTreeRecreation = false;
 399
 400     document().accessSVGExtensions()->removeAllTargetReferencesForElement(this);
 401 }
 402
 403 void SVGUseElement::buildPendingResource()
 404 {
 405     if (!referencedDocument() || isInShadowTree())
 406         return;
 407     clearResourceReferences();
 408     if (!inDocument())
 409         return;
 410
 411     String id;
 412     Element* target = SVGURIReference::targetElementFromIRIString(href(), document(), &id, externalDocument());
 413     if (!target || !target->inDocument()) {
 414         // If we can't find the target of an external element, just give up.
 415         // We can't observe if the target somewhen enters the external document, nor should we do it.
 416         if (externalDocument())
 417             return;
 418         if (id.isEmpty())
 419             return;
 420
 421         referencedDocument()->accessSVGExtensions()->addPendingResource(id, this);
 422         ASSERT(hasPendingResources());
 423         return;
 424     }
 425
 426     if (target->isSVGElement()) {
 427         buildShadowAndInstanceTree(toSVGElement(target));
 428         invalidateDependentShadowTrees();
 429     }
 430
 431     ASSERT(!m_needsShadowTreeRecreation);
 432 }
 433
 434 void SVGUseElement::buildShadowAndInstanceTree(SVGElement* target)
 435 {
 436     ASSERT(!m_targetElementInstance);
 437
 438     // Do not build the shadow/instance tree for <use> elements living in a shadow tree.
 439     // The will be expanded soon anyway - see expandUseElementsInShadowTree().
 440     if (isInShadowTree())
 441         return;
 442
 443     // Do not allow self-referencing.
 444     // 'target' may be null, if it's a non SVG namespaced element.
 445     if (!target || target == this)
 446         return;
 447
 448     // Why a seperated instance/shadow tree? SVG demands it:
 449     // The instance tree is accesable from JavaScript, and has to
 450     // expose a 1:1 copy of the referenced tree, whereas internally we need
 451     // to alter the tree for correct "use-on-symbol", "use-on-svg" support.
 452
 453     // Build instance tree. Create root SVGElementInstance object for the first sub-tree node.
 454     //
 455     // Spec: If the 'use' element references a simple graphics element such as a 'rect', then there is only a
 456     // single SVGElementInstance object, and the correspondingElement attribute on this SVGElementInstance object
 457     // is the SVGRectElement that corresponds to the referenced 'rect' element.
 458     m_targetElementInstance = SVGElementInstance::create(this, this, target);
 459
 460     // Eventually enter recursion to build SVGElementInstance objects for the sub-tree children
 461     bool foundProblem = false;
 462     buildInstanceTree(target, m_targetElementInstance.get(), foundProblem, false);
 463
 464     if (instanceTreeIsLoading(m_targetElementInstance.get()))
 465         return;
 466
 467     // SVG specification does not say a word about <use> & cycles. My view on this is: just ignore it!
 468     // Non-appearing <use> content is easier to debug, then half-appearing content.
 469     if (foundProblem) {
 470         clearResourceReferences();
 471         return;
 472     }
 473
 474     // Assure instance tree building was successfull
 475     ASSERT(m_targetElementInstance);
 476     ASSERT(!m_targetElementInstance->shadowTreeElement());
 477     ASSERT(m_targetElementInstance->correspondingUseElement() == this);
 478     ASSERT(m_targetElementInstance->directUseElement() == this);
 479     ASSERT(m_targetElementInstance->correspondingElement() == target);
 480
 481     ShadowRoot* shadowTreeRootElement = shadowRoot();
 482     ASSERT(shadowTreeRootElement);
 483
 484     // Build shadow tree from instance tree
 485     // This also handles the special cases: <use> on <symbol>, <use> on <svg>.
 486     buildShadowTree(target, m_targetElementInstance.get());
 487
 488     // Expand all <use> elements in the shadow tree.
 489     // Expand means: replace the actual <use> element by what it references.
 490     expandUseElementsInShadowTree(shadowTreeRootElement);
 491
 492     // Expand all <symbol> elements in the shadow tree.
 493     // Expand means: replace the actual <symbol> element by the <svg> element.
 494     expandSymbolElementsInShadowTree(shadowTreeRootElement);
 495
 496     // Now that the shadow tree is completly expanded, we can associate
 497     // shadow tree elements <-> instances in the instance tree.
 498     associateInstancesWithShadowTreeElements(shadowTreeRootElement->firstChild(), m_targetElementInstance.get());
 499
 500     // If no shadow tree element is present, this means that the reference root
 501     // element was removed, as it is disallowed (ie. <use> on <foreignObject>)
 502     // Do NOT leave an inconsistent instance tree around, instead destruct it.
 503     if (!m_targetElementInstance->shadowTreeElement()) {
 504         clearResourceReferences();
 505         return;
 506     }
 507
 508     ASSERT(m_targetElementInstance->shadowTreeElement()->parentNode() == shadowTreeRootElement);
 509
 510     // Transfer event listeners assigned to the referenced element to our shadow tree elements.
 511     transferEventListenersToShadowTree(m_targetElementInstance.get());
 512
 513     // Update relative length information.
 514     updateRelativeLengthsInformation();
 515
 516     // Eventually dump instance tree
 517 #ifdef DUMP_INSTANCE_TREE
 518     String text;
 519     unsigned int depth = 0;
 520
 521     dumpInstanceTree(depth, text, m_targetElementInstance.get());
 522     fprintf(stderr, "\nDumping <use> instance tree:\n%s\n", text.latin1().data());
 523 #endif
 524
 525     // Eventually dump shadow tree
 526 #ifdef DUMP_SHADOW_TREE
 527     RefPtr<XMLSerializer> serializer = XMLSerializer::create();
 528     String markup = serializer->serializeToString(shadowTreeRootElement, ASSERT_NO_EXCEPTION);
 529     fprintf(stderr, "Dumping <use> shadow tree markup:\n%s\n", markup.latin1().data());
 530 #endif
 531 }
 532
 533 RenderElement* SVGUseElement::createRenderer(RenderArena& arena, RenderStyle&)
 534 {
 535     return new (arena) RenderSVGTransformableContainer(*this);
 536 }
 537
 538 static bool isDirectReference(const Node* node)
 539 {
 540     return node->hasTagName(SVGNames::pathTag)
 541            || node->hasTagName(SVGNames::rectTag)
 542            || node->hasTagName(SVGNames::circleTag)
 543            || node->hasTagName(SVGNames::ellipseTag)
 544            || node->hasTagName(SVGNames::polygonTag)
 545            || node->hasTagName(SVGNames::polylineTag)
 546            || node->hasTagName(SVGNames::textTag);
 547 }
 548
 549 void SVGUseElement::toClipPath(Path& path)
 550 {
 551     ASSERT(path.isEmpty());
 552
 553     Node* n = m_targetElementInstance ? m_targetElementInstance->shadowTreeElement() : 0;
 554     if (!n)
 555         return;
 556
 557     if (n->isSVGElement() && toSVGElement(n)->isSVGGraphicsElement()) {
 558         if (!isDirectReference(n))
 559             // Spec: Indirect references are an error (14.3.5)
 560             document().accessSVGExtensions()->reportError("Not allowed to use indirect reference in <clip-path>");
 561         else {
 562             toSVGGraphicsElement(n)->toClipPath(path);
 563             // FIXME: Avoid manual resolution of x/y here. Its potentially harmful.
 564             SVGLengthContext lengthContext(this);
 565             path.translate(FloatSize(x().value(lengthContext), y().value(lengthContext)));
 566             path.transform(animatedLocalTransform());
 567         }
 568     }
 569 }
 570
 571 RenderObject* SVGUseElement::rendererClipChild() const
 572 {
 573     Node* n = m_targetElementInstance ? m_targetElementInstance->shadowTreeElement() : 0;
 574     if (!n)
 575         return 0;
 576
 577     if (n->isSVGElement() && isDirectReference(n))
 578         return toSVGElement(n)->renderer();
 579
 580     return 0;
 581 }
 582
 583 void SVGUseElement::buildInstanceTree(SVGElement* target, SVGElementInstance* targetInstance, bool& foundProblem, bool foundUse)
 584 {
 585     ASSERT(target);
 586     ASSERT(targetInstance);
 587
 588     // Spec: If the referenced object is itself a 'use', or if there are 'use' subelements within the referenced
 589     // object, the instance tree will contain recursive expansion of the indirect references to form a complete tree.
 590     bool targetHasUseTag = target->hasTagName(SVGNames::useTag);
 591     SVGElement* newTarget = 0;
 592     if (targetHasUseTag) {
 593         foundProblem = hasCycleUseReferencing(toSVGUseElement(target), targetInstance, newTarget);
 594         if (foundProblem)
 595             return;
 596
 597         // We only need to track first degree <use> dependencies. Indirect references are handled
 598         // as the invalidation bubbles up the dependency chain.
 599         if (!foundUse) {
 600             document().accessSVGExtensions()->addElementReferencingTarget(this, target);
 601             foundUse = true;
 602         }
 603     } else if (isDisallowedElement(target)) {
 604         foundProblem = true;
 605         return;
 606     }
 607
 608     // A general description from the SVG spec, describing what buildInstanceTree() actually does.
 609     //
 610     // Spec: If the 'use' element references a 'g' which contains two 'rect' elements, then the instance tree
 611     // contains three SVGElementInstance objects, a root SVGElementInstance object whose correspondingElement
 612     // is the SVGGElement object for the 'g', and then two child SVGElementInstance objects, each of which has
 613     // its correspondingElement that is an SVGRectElement object.
 614
 615     for (Node* node = target->firstChild(); node; node = node->nextSibling()) {
 616         SVGElement* element = 0;
 617         if (node->isSVGElement())
 618             element = toSVGElement(node);
 619
 620         // Skip any non-svg nodes or any disallowed element.
 621         if (!element || isDisallowedElement(element))
 622             continue;
 623
 624         // Create SVGElementInstance object, for both container/non-container nodes.
 625         RefPtr<SVGElementInstance> instance = SVGElementInstance::create(this, 0, element);
 626         SVGElementInstance* instancePtr = instance.get();
 627         targetInstance->appendChild(instance.release());
 628
 629         // Enter recursion, appending new instance tree nodes to the "instance" object.
 630         buildInstanceTree(element, instancePtr, foundProblem, foundUse);
 631         if (foundProblem)
 632             return;
 633     }
 634
 635     if (!targetHasUseTag || !newTarget)
 636         return;
 637
 638     RefPtr<SVGElementInstance> newInstance = SVGElementInstance::create(this, toSVGUseElement(target), newTarget);
 639     SVGElementInstance* newInstancePtr = newInstance.get();
 640     targetInstance->appendChild(newInstance.release());
 641     buildInstanceTree(newTarget, newInstancePtr, foundProblem, foundUse);
 642 }
 643
 644 bool SVGUseElement::hasCycleUseReferencing(SVGUseElement* use, SVGElementInstance* targetInstance, SVGElement*& newTarget)
 645 {
 646     ASSERT(referencedDocument());
 647     Element* targetElement = SVGURIReference::targetElementFromIRIString(use->href(), *referencedDocument());
 648     newTarget = 0;
 649     if (targetElement && targetElement->isSVGElement())
 650         newTarget = toSVGElement(targetElement);
 651
 652     if (!newTarget)
 653         return false;
 654
 655     // Shortcut for self-references
 656     if (newTarget == this)
 657         return true;
 658
 659     AtomicString targetId = newTarget->getIdAttribute();
 660     SVGElementInstance* instance = targetInstance->parentNode();
 661     while (instance) {
 662         SVGElement* element = instance->correspondingElement();
 663
 664         if (element->hasID() && element->getIdAttribute() == targetId && &element->document() == &newTarget->document())
 665             return true;
 666
 667         instance = instance->parentNode();
 668     }
 669     return false;
 670 }
 671
 672 static inline void removeDisallowedElementsFromSubtree(Element* subtree)
 673 {
 674     ASSERT(!subtree->inDocument());
 675     Element* element = ElementTraversal::firstWithin(subtree);
 676     while (element) {
 677         if (isDisallowedElement(element)) {
 678             Element* next = ElementTraversal::nextSkippingChildren(element, subtree);
 679             // The subtree is not in document so this won't generate events that could mutate the tree.
 680             element->parentNode()->removeChild(element);
 681             element = next;
 682         } else
 683             element = ElementTraversal::next(element, subtree);
 684     }
 685 }
 686
 687 void SVGUseElement::buildShadowTree(SVGElement* target, SVGElementInstance* targetInstance)
 688 {
 689     // For instance <use> on <foreignObject> (direct case).
 690     if (isDisallowedElement(target))
 691         return;
 692
 693     RefPtr<Element> newChild = targetInstance->correspondingElement()->cloneElementWithChildren();
 694
 695     // We don't walk the target tree element-by-element, and clone each element,
 696     // but instead use cloneElementWithChildren(). This is an optimization for the common
 697     // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
 698     // Though if there are disallowed elements in the subtree, we have to remove them.
 699     // For instance: <use> on <g> containing <foreignObject> (indirect case).
 700     if (subtreeContainsDisallowedElement(newChild.get()))
 701         removeDisallowedElementsFromSubtree(newChild.get());
 702
 703     shadowRoot()->appendChild(newChild.release());
 704 }
 705
 706 void SVGUseElement::expandUseElementsInShadowTree(Node* element)
 707 {
 708     // Why expand the <use> elements in the shadow tree here, and not just
 709     // do this directly in buildShadowTree, if we encounter a <use> element?
 710     //
 711     // Short answer: Because we may miss to expand some elements. Ie. if a <symbol>
 712     // contains <use> tags, we'd miss them. So once we're done with settin' up the
 713     // actual shadow tree (after the special case modification for svg/symbol) we have
 714     // to walk it completely and expand all <use> elements.
 715     if (element->hasTagName(SVGNames::useTag)) {
 716         SVGUseElement* use = toSVGUseElement(element);
 717         ASSERT(!use->cachedDocumentIsStillLoading());
 718
 719         ASSERT(referencedDocument());
 720         Element* targetElement = SVGURIReference::targetElementFromIRIString(use->href(), *referencedDocument());
 721         SVGElement* target = 0;
 722         if (targetElement && targetElement->isSVGElement())
 723             target = toSVGElement(targetElement);
 724
 725         // Don't ASSERT(target) here, it may be "pending", too.
 726         // Setup sub-shadow tree root node
 727         RefPtr<SVGGElement> cloneParent = SVGGElement::create(SVGNames::gTag, *referencedDocument());
 728         use->cloneChildNodes(cloneParent.get());
 729
 730         // Spec: In the generated content, the 'use' will be replaced by 'g', where all attributes from the
 731         // 'use' element except for x, y, width, height and xlink:href are transferred to the generated 'g' element.
 732         transferUseAttributesToReplacedElement(use, cloneParent.get());
 733
 734         if (target && !isDisallowedElement(target)) {
 735             RefPtr<Element> newChild = target->cloneElementWithChildren();
 736             ASSERT(newChild->isSVGElement());
 737             cloneParent->appendChild(newChild.release());
 738         }
 739
 740         // We don't walk the target tree element-by-element, and clone each element,
 741         // but instead use cloneElementWithChildren(). This is an optimization for the common
 742         // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
 743         // Though if there are disallowed elements in the subtree, we have to remove them.
 744         // For instance: <use> on <g> containing <foreignObject> (indirect case).
 745         if (subtreeContainsDisallowedElement(cloneParent.get()))
 746             removeDisallowedElementsFromSubtree(cloneParent.get());
 747
 748         RefPtr<Node> replacingElement(cloneParent.get());
 749
 750         // Replace <use> with referenced content.
 751         ASSERT(use->parentNode());
 752         use->parentNode()->replaceChild(cloneParent.release(), use);
 753
 754         // Expand the siblings because the *element* is replaced and we will
 755         // lose the sibling chain when we are back from recursion.
 756         element = replacingElement.get();
 757         for (RefPtr<Node> sibling = element->nextSibling(); sibling; sibling = sibling->nextSibling())
 758             expandUseElementsInShadowTree(sibling.get());
 759     }
 760
 761     for (RefPtr<Node> child = element->firstChild(); child; child = child->nextSibling())
 762         expandUseElementsInShadowTree(child.get());
 763 }
 764
 765 void SVGUseElement::expandSymbolElementsInShadowTree(Node* element)
 766 {
 767     if (element->hasTagName(SVGNames::symbolTag)) {
 768         // Spec: The referenced 'symbol' and its contents are deep-cloned into the generated tree,
 769         // with the exception that the 'symbol' is replaced by an 'svg'. This generated 'svg' will
 770         // always have explicit values for attributes width and height. If attributes width and/or
 771         // height are provided on the 'use' element, then these attributes will be transferred to
 772         // the generated 'svg'. If attributes width and/or height are not specified, the generated
 773         // 'svg' element will use values of 100% for these attributes.
 774         RefPtr<SVGSVGElement> svgElement = SVGSVGElement::create(SVGNames::svgTag, *referencedDocument());
 775
 776         // Transfer all data (attributes, etc.) from <symbol> to the new <svg> element.
 777         svgElement->cloneDataFromElement(*toElement(element));
 778
 779         // Only clone symbol children, and add them to the new <svg> element
 780         for (Node* child = element->firstChild(); child; child = child->nextSibling()) {
 781             RefPtr<Node> newChild = child->cloneNode(true);
 782             svgElement->appendChild(newChild.release());
 783         }
 784
 785         // We don't walk the target tree element-by-element, and clone each element,
 786         // but instead use cloneNode(deep=true). This is an optimization for the common
 787         // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
 788         // Though if there are disallowed elements in the subtree, we have to remove them.
 789         // For instance: <use> on <g> containing <foreignObject> (indirect case).
 790         if (subtreeContainsDisallowedElement(svgElement.get()))
 791             removeDisallowedElementsFromSubtree(svgElement.get());
 792
 793         RefPtr<Node> replacingElement(svgElement.get());
 794
 795         // Replace <symbol> with <svg>.
 796         element->parentNode()->replaceChild(svgElement.release(), element);
 797
 798         // Expand the siblings because the *element* is replaced and we will
 799         // lose the sibling chain when we are back from recursion.
 800         element = replacingElement.get();
 801         for (RefPtr<Node> sibling = element->nextSibling(); sibling; sibling = sibling->nextSibling())
 802             expandSymbolElementsInShadowTree(sibling.get());
 803     }
 804
 805     for (RefPtr<Node> child = element->firstChild(); child; child = child->nextSibling())
 806         expandSymbolElementsInShadowTree(child.get());
 807 }
 808
 809 void SVGUseElement::transferEventListenersToShadowTree(SVGElementInstance* target)
 810 {
 811     if (!target)
 812         return;
 813
 814     SVGElement* originalElement = target->correspondingElement();
 815     ASSERT(originalElement);
 816
 817     if (SVGElement* shadowTreeElement = target->shadowTreeElement()) {
 818         if (EventTargetData* data = originalElement->eventTargetData())
 819             data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(shadowTreeElement);
 820     }
 821
 822     for (SVGElementInstance* instance = target->firstChild(); instance; instance = instance->nextSibling())
 823         transferEventListenersToShadowTree(instance);
 824 }
 825
 826 void SVGUseElement::associateInstancesWithShadowTreeElements(Node* target, SVGElementInstance* targetInstance)
 827 {
 828     if (!target || !targetInstance)
 829         return;
 830
 831     SVGElement* originalElement = targetInstance->correspondingElement();
 832
 833     if (originalElement->hasTagName(SVGNames::useTag)) {
 834         // <use> gets replaced by <g>
 835         ASSERT(target->nodeName() == SVGNames::gTag);
 836     } else if (originalElement->hasTagName(SVGNames::symbolTag)) {
 837         // <symbol> gets replaced by <svg>
 838         ASSERT(target->nodeName() == SVGNames::svgTag);
 839     } else
 840         ASSERT(target->nodeName() == originalElement->nodeName());
 841
 842     SVGElement* element = 0;
 843     if (target->isSVGElement())
 844         element = toSVGElement(target);
 845
 846     ASSERT(!targetInstance->shadowTreeElement());
 847     targetInstance->setShadowTreeElement(element);
 848     element->setCorrespondingElement(originalElement);
 849
 850     Node* node = target->firstChild();
 851     for (SVGElementInstance* instance = targetInstance->firstChild(); node && instance; instance = instance->nextSibling()) {
 852         // Skip any non-svg elements in shadow tree
 853         while (node && !node->isSVGElement())
 854            node = node->nextSibling();
 855
 856         if (!node)
 857             break;
 858
 859         associateInstancesWithShadowTreeElements(node, instance);
 860         node = node->nextSibling();
 861     }
 862 }
 863
 864 SVGElementInstance* SVGUseElement::instanceForShadowTreeElement(Node* element) const
 865 {
 866     if (!m_targetElementInstance) {
 867         ASSERT(!inDocument());
 868         return 0;
 869     }
 870
 871     return instanceForShadowTreeElement(element, m_targetElementInstance.get());
 872 }
 873
 874 SVGElementInstance* SVGUseElement::instanceForShadowTreeElement(Node* element, SVGElementInstance* instance) const
 875 {
 876     ASSERT(element);
 877     ASSERT(instance);
 878
 879     // We're dispatching a mutation event during shadow tree construction
 880     // this instance hasn't yet been associated to a shadowTree element.
 881     if (!instance->shadowTreeElement())
 882         return 0;
 883
 884     if (element == instance->shadowTreeElement())
 885         return instance;
 886
 887     for (SVGElementInstance* current = instance->firstChild(); current; current = current->nextSibling()) {
 888         if (SVGElementInstance* search = instanceForShadowTreeElement(element, current))
 889             return search;
 890     }
 891
 892     return 0;
 893 }
 894
 895 void SVGUseElement::invalidateShadowTree()
 896 {
 897     if (!renderer() || m_needsShadowTreeRecreation)
 898         return;
 899     m_needsShadowTreeRecreation = true;
 900     setNeedsStyleRecalc();
 901     invalidateDependentShadowTrees();
 902 }
 903
 904 void SVGUseElement::invalidateDependentShadowTrees()
 905 {
 906     // Recursively invalidate dependent <use> shadow trees
 907     const HashSet<SVGElementInstance*>& instances = instancesForElement();
 908     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
 909     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
 910         if (SVGUseElement* element = (*it)->correspondingUseElement()) {
 911             ASSERT(element->inDocument());
 912             element->invalidateShadowTree();
 913         }
 914     }
 915 }
 916
 917 void SVGUseElement::transferUseAttributesToReplacedElement(SVGElement* from, SVGElement* to) const
 918 {
 919     ASSERT(from);
 920     ASSERT(to);
 921
 922     to->cloneDataFromElement(*from);
 923
 924     to->removeAttribute(SVGNames::xAttr);
 925     to->removeAttribute(SVGNames::yAttr);
 926     to->removeAttribute(SVGNames::widthAttr);
 927     to->removeAttribute(SVGNames::heightAttr);
 928     to->removeAttribute(XLinkNames::hrefAttr);
 929 }
 930
 931 bool SVGUseElement::selfHasRelativeLengths() const
 932 {
 933     if (x().isRelative()
 934      || y().isRelative()
 935      || width().isRelative()
 936      || height().isRelative())
 937         return true;
 938
 939     if (!m_targetElementInstance)
 940         return false;
 941
 942     SVGElement* element = m_targetElementInstance->correspondingElement();
 943     if (!element)
 944         return false;
 945
 946     return element->hasRelativeLengths();
 947 }
 948
 949 void SVGUseElement::notifyFinished(CachedResource* resource)
 950 {
 951     if (!inDocument())
 952         return;
 953
 954     invalidateShadowTree();
 955     if (resource->errorOccurred())
 956         dispatchEvent(Event::create(eventNames().errorEvent, false, false));
 957     else if (!resource->wasCanceled())
 958         SVGExternalResourcesRequired::dispatchLoadEvent(this);
 959 }
 960
 961 bool SVGUseElement::cachedDocumentIsStillLoading()
 962 {
 963     if (m_cachedDocument && m_cachedDocument->isLoading())
 964         return true;
 965     return false;
 966 }
 967
 968 bool SVGUseElement::instanceTreeIsLoading(SVGElementInstance* targetElementInstance)
 969 {
 970     for (SVGElementInstance* instance = targetElementInstance->firstChild(); instance; instance = instance->nextSibling()) {
 971         if (SVGUseElement* use = instance->correspondingUseElement()) {
 972              if (use->cachedDocumentIsStillLoading())
 973                  return true;
 974         }
 975         if (instance->hasChildNodes())
 976             instanceTreeIsLoading(instance);
 977     }
 978     return false;
 979 }
 980
 981 void SVGUseElement::finishParsingChildren()
 982 {
 983     SVGGraphicsElement::finishParsingChildren();
 984     SVGExternalResourcesRequired::finishParsingChildren();
 985     if (m_wasInsertedByParser) {
 986         buildPendingResource();
 987         m_wasInsertedByParser = false;
 988     }
 989 }
 990
 991 void SVGUseElement::setCachedDocument(CachedResourceHandle<CachedSVGDocument> cachedDocument)
 992 {
 993     if (m_cachedDocument == cachedDocument)
 994         return;
 995
 996     if (m_cachedDocument)
 997         m_cachedDocument->removeClient(this);
 998
 999     m_cachedDocument = cachedDocument;
1000     if (m_cachedDocument)
1001         m_cachedDocument->addClient(this);
1002 }
1003
1004 }
1005
1006 #endif // ENABLE(SVG)