| OLD | NEW |
|---|
| (Empty) |
| 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/RenderSVGResourceContainer.h" | |
| 22 | |
| 23 #include "core/layout/Layer.h" | |
| 24 #include "core/layout/svg/SVGResources.h" | |
| 25 #include "core/layout/svg/SVGResourcesCache.h" | |
| 26 #include "core/rendering/svg/RenderSVGResourceClipper.h" | |
| 27 #include "core/rendering/svg/RenderSVGResourceFilter.h" | |
| 28 #include "core/rendering/svg/RenderSVGResourceMasker.h" | |
| 29 | |
| 30 #include "wtf/TemporaryChange.h" | |
| 31 | |
| 32 namespace blink { | |
| 33 | |
| 34 static inline SVGDocumentExtensions& svgExtensionsFromElement(SVGElement* elemen
t) | |
| 35 { | |
| 36 ASSERT(element); | |
| 37 return element->document().accessSVGExtensions(); | |
| 38 } | |
| 39 | |
| 40 RenderSVGResourceContainer::RenderSVGResourceContainer(SVGElement* node) | |
| 41 : RenderSVGHiddenContainer(node) | |
| 42 , m_isInLayout(false) | |
| 43 , m_id(node->getIdAttribute()) | |
| 44 , m_invalidationMask(0) | |
| 45 , m_registered(false) | |
| 46 , m_isInvalidating(false) | |
| 47 { | |
| 48 } | |
| 49 | |
| 50 RenderSVGResourceContainer::~RenderSVGResourceContainer() | |
| 51 { | |
| 52 } | |
| 53 | |
| 54 void RenderSVGResourceContainer::layout() | |
| 55 { | |
| 56 // FIXME: Investigate a way to detect and break resource layout dependency c
ycles early. | |
| 57 // Then we can remove this method altogether, and fall back onto RenderSVGHi
ddenContainer::layout(). | |
| 58 ASSERT(needsLayout()); | |
| 59 if (m_isInLayout) | |
| 60 return; | |
| 61 | |
| 62 TemporaryChange<bool> inLayoutChange(m_isInLayout, true); | |
| 63 | |
| 64 RenderSVGHiddenContainer::layout(); | |
| 65 | |
| 66 clearInvalidationMask(); | |
| 67 } | |
| 68 | |
| 69 void RenderSVGResourceContainer::willBeDestroyed() | |
| 70 { | |
| 71 SVGResourcesCache::resourceDestroyed(this); | |
| 72 RenderSVGHiddenContainer::willBeDestroyed(); | |
| 73 if (m_registered) | |
| 74 svgExtensionsFromElement(element()).removeResource(m_id); | |
| 75 } | |
| 76 | |
| 77 void RenderSVGResourceContainer::styleDidChange(StyleDifference diff, const Layo
utStyle* oldStyle) | |
| 78 { | |
| 79 RenderSVGHiddenContainer::styleDidChange(diff, oldStyle); | |
| 80 | |
| 81 if (!m_registered) { | |
| 82 m_registered = true; | |
| 83 registerResource(); | |
| 84 } | |
| 85 } | |
| 86 | |
| 87 void RenderSVGResourceContainer::idChanged() | |
| 88 { | |
| 89 // Invalidate all our current clients. | |
| 90 removeAllClientsFromCache(); | |
| 91 | |
| 92 // Remove old id, that is guaranteed to be present in cache. | |
| 93 SVGDocumentExtensions& extensions = svgExtensionsFromElement(element()); | |
| 94 extensions.removeResource(m_id); | |
| 95 m_id = element()->getIdAttribute(); | |
| 96 | |
| 97 registerResource(); | |
| 98 } | |
| 99 | |
| 100 void RenderSVGResourceContainer::markAllClientsForInvalidation(InvalidationMode
mode) | |
| 101 { | |
| 102 if ((m_clients.isEmpty() && m_clientLayers.isEmpty()) || m_isInvalidating) | |
| 103 return; | |
| 104 | |
| 105 if (m_invalidationMask & mode) | |
| 106 return; | |
| 107 | |
| 108 m_invalidationMask |= mode; | |
| 109 m_isInvalidating = true; | |
| 110 bool needsLayout = mode == LayoutAndBoundariesInvalidation; | |
| 111 bool markForInvalidation = mode != ParentOnlyInvalidation; | |
| 112 | |
| 113 HashSet<LayoutObject*>::iterator end = m_clients.end(); | |
| 114 for (HashSet<LayoutObject*>::iterator it = m_clients.begin(); it != end; ++i
t) { | |
| 115 LayoutObject* client = *it; | |
| 116 if (client->isSVGResourceContainer()) { | |
| 117 toRenderSVGResourceContainer(client)->removeAllClientsFromCache(mark
ForInvalidation); | |
| 118 continue; | |
| 119 } | |
| 120 | |
| 121 if (markForInvalidation) | |
| 122 markClientForInvalidation(client, mode); | |
| 123 | |
| 124 RenderSVGResourceContainer::markForLayoutAndParentResourceInvalidation(c
lient, needsLayout); | |
| 125 } | |
| 126 | |
| 127 markAllClientLayersForInvalidation(); | |
| 128 | |
| 129 m_isInvalidating = false; | |
| 130 } | |
| 131 | |
| 132 void RenderSVGResourceContainer::markAllClientLayersForInvalidation() | |
| 133 { | |
| 134 HashSet<Layer*>::iterator layerEnd = m_clientLayers.end(); | |
| 135 for (HashSet<Layer*>::iterator it = m_clientLayers.begin(); it != layerEnd;
++it) | |
| 136 (*it)->filterNeedsPaintInvalidation(); | |
| 137 } | |
| 138 | |
| 139 void RenderSVGResourceContainer::markClientForInvalidation(LayoutObject* client,
InvalidationMode mode) | |
| 140 { | |
| 141 ASSERT(client); | |
| 142 ASSERT(!m_clients.isEmpty()); | |
| 143 | |
| 144 switch (mode) { | |
| 145 case LayoutAndBoundariesInvalidation: | |
| 146 case BoundariesInvalidation: | |
| 147 client->setNeedsBoundariesUpdate(); | |
| 148 break; | |
| 149 case PaintInvalidation: | |
| 150 client->setShouldDoFullPaintInvalidation(); | |
| 151 break; | |
| 152 case ParentOnlyInvalidation: | |
| 153 break; | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 void RenderSVGResourceContainer::addClient(LayoutObject* client) | |
| 158 { | |
| 159 ASSERT(client); | |
| 160 m_clients.add(client); | |
| 161 clearInvalidationMask(); | |
| 162 } | |
| 163 | |
| 164 void RenderSVGResourceContainer::removeClient(LayoutObject* client) | |
| 165 { | |
| 166 ASSERT(client); | |
| 167 removeClientFromCache(client, false); | |
| 168 m_clients.remove(client); | |
| 169 } | |
| 170 | |
| 171 void RenderSVGResourceContainer::addClientLayer(Node* node) | |
| 172 { | |
| 173 ASSERT(node); | |
| 174 if (!node->renderer() || !node->renderer()->hasLayer()) | |
| 175 return; | |
| 176 m_clientLayers.add(toLayoutLayerModelObject(node->renderer())->layer()); | |
| 177 clearInvalidationMask(); | |
| 178 } | |
| 179 | |
| 180 void RenderSVGResourceContainer::addClientLayer(Layer* client) | |
| 181 { | |
| 182 ASSERT(client); | |
| 183 m_clientLayers.add(client); | |
| 184 clearInvalidationMask(); | |
| 185 } | |
| 186 | |
| 187 void RenderSVGResourceContainer::removeClientLayer(Layer* client) | |
| 188 { | |
| 189 ASSERT(client); | |
| 190 m_clientLayers.remove(client); | |
| 191 } | |
| 192 | |
| 193 void RenderSVGResourceContainer::invalidateCacheAndMarkForLayout(SubtreeLayoutSc
ope* layoutScope) | |
| 194 { | |
| 195 if (selfNeedsLayout()) | |
| 196 return; | |
| 197 | |
| 198 setNeedsLayoutAndFullPaintInvalidation(MarkContainingBlockChain, layoutScope
); | |
| 199 | |
| 200 if (everHadLayout()) | |
| 201 removeAllClientsFromCache(); | |
| 202 } | |
| 203 | |
| 204 void RenderSVGResourceContainer::registerResource() | |
| 205 { | |
| 206 SVGDocumentExtensions& extensions = svgExtensionsFromElement(element()); | |
| 207 if (!extensions.hasPendingResource(m_id)) { | |
| 208 extensions.addResource(m_id, this); | |
| 209 return; | |
| 210 } | |
| 211 | |
| 212 OwnPtrWillBeRawPtr<SVGDocumentExtensions::SVGPendingElements> clients(extens
ions.removePendingResource(m_id)); | |
| 213 | |
| 214 // Cache us with the new id. | |
| 215 extensions.addResource(m_id, this); | |
| 216 | |
| 217 // Update cached resources of pending clients. | |
| 218 const SVGDocumentExtensions::SVGPendingElements::const_iterator end = client
s->end(); | |
| 219 for (SVGDocumentExtensions::SVGPendingElements::const_iterator it = clients-
>begin(); it != end; ++it) { | |
| 220 ASSERT((*it)->hasPendingResources()); | |
| 221 extensions.clearHasPendingResourcesIfPossible(*it); | |
| 222 LayoutObject* renderer = (*it)->renderer(); | |
| 223 if (!renderer) | |
| 224 continue; | |
| 225 | |
| 226 StyleDifference diff; | |
| 227 diff.setNeedsFullLayout(); | |
| 228 SVGResourcesCache::clientStyleChanged(renderer, diff, renderer->styleRef
()); | |
| 229 renderer->setNeedsLayoutAndFullPaintInvalidation(); | |
| 230 } | |
| 231 } | |
| 232 | |
| 233 static inline void removeFromCacheAndInvalidateDependencies(LayoutObject* object
, bool needsLayout) | |
| 234 { | |
| 235 ASSERT(object); | |
| 236 if (SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObj
ect(object)) { | |
| 237 if (RenderSVGResourceFilter* filter = resources->filter()) | |
| 238 filter->removeClientFromCache(object); | |
| 239 | |
| 240 if (RenderSVGResourceMasker* masker = resources->masker()) | |
| 241 masker->removeClientFromCache(object); | |
| 242 | |
| 243 if (RenderSVGResourceClipper* clipper = resources->clipper()) | |
| 244 clipper->removeClientFromCache(object); | |
| 245 } | |
| 246 | |
| 247 if (!object->node() || !object->node()->isSVGElement()) | |
| 248 return; | |
| 249 SVGElementSet* dependencies = toSVGElement(object->node())->setOfIncomingRef
erences(); | |
| 250 if (!dependencies) | |
| 251 return; | |
| 252 | |
| 253 // We allow cycles in SVGDocumentExtensions reference sets in order to avoid
expensive | |
| 254 // reference graph adjustments on changes, so we need to break possible cycl
es here. | |
| 255 // This strong reference is safe, as it is guaranteed that this set will be
emptied | |
| 256 // at the end of recursion. | |
| 257 typedef WillBeHeapHashSet<RawPtrWillBeMember<SVGElement> > SVGElementSet; | |
| 258 DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<SVGElementSet>, invalidatingDepen
dencies, (adoptPtrWillBeNoop(new SVGElementSet))); | |
| 259 | |
| 260 SVGElementSet::iterator end = dependencies->end(); | |
| 261 for (SVGElementSet::iterator it = dependencies->begin(); it != end; ++it) { | |
| 262 if (LayoutObject* renderer = (*it)->renderer()) { | |
| 263 if (UNLIKELY(!invalidatingDependencies->add(*it).isNewEntry)) { | |
| 264 // Reference cycle: we are in process of invalidating this depen
dant. | |
| 265 continue; | |
| 266 } | |
| 267 | |
| 268 RenderSVGResourceContainer::markForLayoutAndParentResourceInvalidati
on(renderer, needsLayout); | |
| 269 invalidatingDependencies->remove(*it); | |
| 270 } | |
| 271 } | |
| 272 } | |
| 273 | |
| 274 void RenderSVGResourceContainer::markForLayoutAndParentResourceInvalidation(Layo
utObject* object, bool needsLayout) | |
| 275 { | |
| 276 ASSERT(object); | |
| 277 ASSERT(object->node()); | |
| 278 | |
| 279 if (needsLayout && !object->documentBeingDestroyed()) | |
| 280 object->setNeedsLayoutAndFullPaintInvalidation(); | |
| 281 | |
| 282 removeFromCacheAndInvalidateDependencies(object, needsLayout); | |
| 283 | |
| 284 // Invalidate resources in ancestor chain, if needed. | |
| 285 LayoutObject* current = object->parent(); | |
| 286 while (current) { | |
| 287 removeFromCacheAndInvalidateDependencies(current, needsLayout); | |
| 288 | |
| 289 if (current->isSVGResourceContainer()) { | |
| 290 // This will process the rest of the ancestors. | |
| 291 toRenderSVGResourceContainer(current)->removeAllClientsFromCache(); | |
| 292 break; | |
| 293 } | |
| 294 | |
| 295 current = current->parent(); | |
| 296 } | |
| 297 } | |
| 298 | |
| 299 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 908243002:
Move rendering/svg/RenderSVGResource* to layout/svg. (Closed)
Base URL: svn://svn.chromium.org/blink/trunk