src/third_party/WebKit/Source/core/rendering/svg/SVGResourcesCache.cpp

   1 /*
   2  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "config.h"
  21 #include "core/rendering/svg/SVGResourcesCache.h"
  22
  23 #include "HTMLNames.h"
  24 #include "core/rendering/svg/RenderSVGResourceContainer.h"
  25 #include "core/rendering/svg/SVGResources.h"
  26 #include "core/rendering/svg/SVGResourcesCycleSolver.h"
  27 #include "core/svg/SVGDocumentExtensions.h"
  28
  29 namespace WebCore {
  30
  31 SVGResourcesCache::SVGResourcesCache()
  32 {
  33 }
  34
  35 SVGResourcesCache::~SVGResourcesCache()
  36 {
  37 }
  38
  39 void SVGResourcesCache::addResourcesFromRenderObject(RenderObject* object, const RenderStyle* style)
  40 {
  41     ASSERT(object);
  42     ASSERT(style);
  43     ASSERT(!m_cache.contains(object));
  44
  45     const SVGRenderStyle* svgStyle = style->svgStyle();
  46     ASSERT(svgStyle);
  47
  48     // Build a list of all resources associated with the passed RenderObject
  49     OwnPtr<SVGResources> newResources = SVGResources::buildResources(object, svgStyle);
  50     if (!newResources)
  51         return;
  52
  53     // Put object in cache.
  54     SVGResources* resources = m_cache.set(object, newResources.release()).storedValue->value.get();
  55
  56     // Run cycle-detection _afterwards_, so self-references can be caught as well.
  57     SVGResourcesCycleSolver solver(object, resources);
  58     solver.resolveCycles();
  59
  60     // Walk resources and register the render object at each resources.
  61     HashSet<RenderSVGResourceContainer*> resourceSet;
  62     resources->buildSetOfResources(resourceSet);
  63
  64     HashSet<RenderSVGResourceContainer*>::iterator end = resourceSet.end();
  65     for (HashSet<RenderSVGResourceContainer*>::iterator it = resourceSet.begin(); it != end; ++it)
  66         (*it)->addClient(object);
  67 }
  68
  69 void SVGResourcesCache::removeResourcesFromRenderObject(RenderObject* object)
  70 {
  71     OwnPtr<SVGResources> resources = m_cache.take(object);
  72     if (!resources)
  73         return;
  74
  75     // Walk resources and register the render object at each resources.
  76     HashSet<RenderSVGResourceContainer*> resourceSet;
  77     resources->buildSetOfResources(resourceSet);
  78
  79     HashSet<RenderSVGResourceContainer*>::iterator end = resourceSet.end();
  80     for (HashSet<RenderSVGResourceContainer*>::iterator it = resourceSet.begin(); it != end; ++it)
  81         (*it)->removeClient(object);
  82 }
  83
  84 static inline SVGResourcesCache* resourcesCacheFromRenderObject(const RenderObject* renderer)
  85 {
  86     Document& document = renderer->document();
  87
  88     SVGDocumentExtensions& extensions = document.accessSVGExtensions();
  89     SVGResourcesCache* cache = extensions.resourcesCache();
  90     ASSERT(cache);
  91
  92     return cache;
  93 }
  94
  95 SVGResources* SVGResourcesCache::cachedResourcesForRenderObject(const RenderObject* renderer)
  96 {
  97     ASSERT(renderer);
  98     return resourcesCacheFromRenderObject(renderer)->m_cache.get(renderer);
  99 }
 100
 101 void SVGResourcesCache::clientLayoutChanged(RenderObject* object)
 102 {
 103     SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object);
 104     if (!resources)
 105         return;
 106
 107     // Invalidate the resources if either the RenderObject itself changed,
 108     // or we have filter resources, which could depend on the layout of children.
 109     if (object->selfNeedsLayout() || resources->filter())
 110         resources->removeClientFromCache(object);
 111 }
 112
 113 static inline bool rendererCanHaveResources(RenderObject* renderer)
 114 {
 115     ASSERT(renderer);
 116     return renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGInlineText();
 117 }
 118
 119 void SVGResourcesCache::clientStyleChanged(RenderObject* renderer, StyleDifference diff, const RenderStyle* newStyle)
 120 {
 121     ASSERT(renderer);
 122     ASSERT(renderer->node());
 123     ASSERT(renderer->node()->isSVGElement());
 124
 125     if (diff.hasNoChange() || !renderer->parent())
 126         return;
 127
 128     // In this case the proper SVGFE*Element will decide whether the modified CSS properties require a relayout or repaint.
 129     if (renderer->isSVGResourceFilterPrimitive() && !diff.needsLayout())
 130         return;
 131
 132     // Dynamic changes of CSS properties like 'clip-path' may require us to recompute the associated resources for a renderer.
 133     // FIXME: Avoid passing in a useless StyleDifference, but instead compare oldStyle/newStyle to see which resources changed
 134     // to be able to selectively rebuild individual resources, instead of all of them.
 135     if (rendererCanHaveResources(renderer)) {
 136         SVGResourcesCache* cache = resourcesCacheFromRenderObject(renderer);
 137         cache->removeResourcesFromRenderObject(renderer);
 138         cache->addResourcesFromRenderObject(renderer, newStyle);
 139     }
 140
 141     RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer, false);
 142 }
 143
 144 void SVGResourcesCache::clientWasAddedToTree(RenderObject* renderer, const RenderStyle* newStyle)
 145 {
 146     if (!renderer->node())
 147         return;
 148     RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer, false);
 149
 150     if (!rendererCanHaveResources(renderer))
 151         return;
 152     SVGResourcesCache* cache = resourcesCacheFromRenderObject(renderer);
 153     cache->addResourcesFromRenderObject(renderer, newStyle);
 154 }
 155
 156 void SVGResourcesCache::clientWillBeRemovedFromTree(RenderObject* renderer)
 157 {
 158     if (!renderer->node())
 159         return;
 160     RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer, false);
 161
 162     if (!rendererCanHaveResources(renderer))
 163         return;
 164     SVGResourcesCache* cache = resourcesCacheFromRenderObject(renderer);
 165     cache->removeResourcesFromRenderObject(renderer);
 166 }
 167
 168 void SVGResourcesCache::clientDestroyed(RenderObject* renderer)
 169 {
 170     ASSERT(renderer);
 171
 172     SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(renderer);
 173     if (resources)
 174         resources->removeClientFromCache(renderer);
 175
 176     SVGResourcesCache* cache = resourcesCacheFromRenderObject(renderer);
 177     cache->removeResourcesFromRenderObject(renderer);
 178 }
 179
 180 void SVGResourcesCache::resourceDestroyed(RenderSVGResourceContainer* resource)
 181 {
 182     ASSERT(resource);
 183     SVGResourcesCache* cache = resourcesCacheFromRenderObject(resource);
 184
 185     // The resource itself may have clients, that need to be notified.
 186     cache->removeResourcesFromRenderObject(resource);
 187
 188         CacheMap::iterator end = cache->m_cache.end();
 189         for (CacheMap::iterator it = cache->m_cache.begin(); it != end; ++it) {
 190         it->value->resourceDestroyed(resource);
 191
 192         // Mark users of destroyed resources as pending resolution based on the id of the old resource.
 193         Element* resourceElement = resource->element();
 194         Element* clientElement = toElement(it->key->node());
 195         SVGDocumentExtensions& extensions = clientElement->document().accessSVGExtensions();
 196
 197         extensions.addPendingResource(resourceElement->fastGetAttribute(HTMLNames::idAttr), clientElement);
 198     }
 199 }
 200
 201 }