third_party/WebKit/Source/core/svg/SVGDocumentExtensions.cpp

   1 /*
   2  * Copyright (C) 2006 Apple Inc. All rights reserved.
   3  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
   4  * Copyright (C) 2007 Rob Buis <buis@kde.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "config.h"
  23 #include "core/svg/SVGDocumentExtensions.h"
  24
  25 #include "core/dom/Document.h"
  26 #include "core/inspector/ConsoleMessage.h"
  27 #include "core/layout/svg/SVGResourcesCache.h"
  28 #include "core/svg/SVGSVGElement.h"
  29 #include "core/svg/animation/SMILTimeContainer.h"
  30 #include "wtf/TemporaryChange.h"
  31 #include "wtf/text/AtomicString.h"
  32
  33 namespace blink {
  34
  35 SVGDocumentExtensions::SVGDocumentExtensions(Document* document)
  36     : m_document(document)
  37 #if ENABLE(ASSERT)
  38     , m_inRelativeLengthSVGRootsInvalidation(false)
  39 #endif
  40 {
  41 }
  42
  43 SVGDocumentExtensions::~SVGDocumentExtensions()
  44 {
  45 }
  46
  47 void SVGDocumentExtensions::addTimeContainer(SVGSVGElement* element)
  48 {
  49     m_timeContainers.add(element);
  50 }
  51
  52 void SVGDocumentExtensions::removeTimeContainer(SVGSVGElement* element)
  53 {
  54     m_timeContainers.remove(element);
  55 }
  56
  57 void SVGDocumentExtensions::addResource(const AtomicString& id, LayoutSVGResourceContainer* resource)
  58 {
  59     ASSERT(resource);
  60
  61     if (id.isEmpty())
  62         return;
  63
  64     // Replaces resource if already present, to handle potential id changes
  65     m_resources.set(id, resource);
  66 }
  67
  68 void SVGDocumentExtensions::removeResource(const AtomicString& id)
  69 {
  70     if (id.isEmpty())
  71         return;
  72
  73     m_resources.remove(id);
  74 }
  75
  76 LayoutSVGResourceContainer* SVGDocumentExtensions::resourceById(const AtomicString& id) const
  77 {
  78     if (id.isEmpty())
  79         return nullptr;
  80
  81     return m_resources.get(id);
  82 }
  83
  84 void SVGDocumentExtensions::serviceOnAnimationFrame(Document& document, double monotonicAnimationStartTime)
  85 {
  86     if (!document.svgExtensions() || !RuntimeEnabledFeatures::smilEnabled())
  87         return;
  88     document.accessSVGExtensions().serviceAnimations(monotonicAnimationStartTime);
  89 }
  90
  91 void SVGDocumentExtensions::serviceAnimations(double monotonicAnimationStartTime)
  92 {
  93     WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
  94     copyToVector(m_timeContainers, timeContainers);
  95     for (const auto& container : timeContainers)
  96         container->timeContainer()->serviceAnimations(monotonicAnimationStartTime);
  97 }
  98
  99 void SVGDocumentExtensions::startAnimations()
 100 {
 101     // FIXME: Eventually every "Time Container" will need a way to latch on to some global timer
 102     // starting animations for a document will do this "latching"
 103     // FIXME: We hold a ref pointers to prevent a shadow tree from getting removed out from underneath us.
 104     // In the future we should refactor the use-element to avoid this. See https://webkit.org/b/53704
 105     WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
 106     copyToVector(m_timeContainers, timeContainers);
 107     for (const auto& container : timeContainers) {
 108         SMILTimeContainer* timeContainer = container->timeContainer();
 109         if (!timeContainer->isStarted())
 110             timeContainer->begin();
 111     }
 112 }
 113
 114 void SVGDocumentExtensions::pauseAnimations()
 115 {
 116     for (SVGSVGElement* element : m_timeContainers)
 117         element->pauseAnimations();
 118 }
 119
 120 void SVGDocumentExtensions::dispatchSVGLoadEventToOutermostSVGElements()
 121 {
 122     WillBeHeapVector<RefPtrWillBeMember<SVGSVGElement>> timeContainers;
 123     copyToVector(m_timeContainers, timeContainers);
 124     for (const auto& container : timeContainers) {
 125         SVGSVGElement* outerSVG = container.get();
 126         if (!outerSVG->isOutermostSVGSVGElement())
 127             continue;
 128
 129         // don't dispatch the load event document is not wellformed (for XML/standalone svg)
 130         if (outerSVG->document().wellFormed() || !outerSVG->document().isSVGDocument())
 131             outerSVG->sendSVGLoadEventIfPossible();
 132     }
 133 }
 134
 135 static void reportMessage(Document* document, MessageLevel level, const String& message)
 136 {
 137     if (document->frame())
 138         document->addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, level, message));
 139 }
 140
 141 void SVGDocumentExtensions::reportWarning(const String& message)
 142 {
 143     reportMessage(m_document, WarningMessageLevel, "Warning: " + message);
 144 }
 145
 146 void SVGDocumentExtensions::reportError(const String& message)
 147 {
 148     reportMessage(m_document, ErrorMessageLevel, "Error: " + message);
 149 }
 150
 151 void SVGDocumentExtensions::addPendingResource(const AtomicString& id, Element* element)
 152 {
 153     ASSERT(element);
 154     ASSERT(element->inDocument());
 155
 156     if (id.isEmpty())
 157         return;
 158
 159     WillBeHeapHashMap<AtomicString, OwnPtrWillBeMember<SVGPendingElements>>::AddResult result = m_pendingResources.add(id, nullptr);
 160     if (result.isNewEntry)
 161         result.storedValue->value = adoptPtrWillBeNoop(new SVGPendingElements);
 162     result.storedValue->value->add(element);
 163
 164     element->setHasPendingResources();
 165 }
 166
 167 bool SVGDocumentExtensions::hasPendingResource(const AtomicString& id) const
 168 {
 169     if (id.isEmpty())
 170         return false;
 171
 172     return m_pendingResources.contains(id);
 173 }
 174
 175 bool SVGDocumentExtensions::isElementPendingResources(Element* element) const
 176 {
 177     // This algorithm takes time proportional to the number of pending resources and need not.
 178     // If performance becomes an issue we can keep a counted set of elements and answer the question efficiently.
 179
 180     ASSERT(element);
 181
 182     for (const auto& entry : m_pendingResources) {
 183         SVGPendingElements* elements = entry.value.get();
 184         ASSERT(elements);
 185
 186         if (elements->contains(element))
 187             return true;
 188     }
 189     return false;
 190 }
 191
 192 bool SVGDocumentExtensions::isElementPendingResource(Element* element, const AtomicString& id) const
 193 {
 194     ASSERT(element);
 195
 196     if (!hasPendingResource(id))
 197         return false;
 198
 199     return m_pendingResources.get(id)->contains(element);
 200 }
 201
 202 void SVGDocumentExtensions::clearHasPendingResourcesIfPossible(Element* element)
 203 {
 204     if (!isElementPendingResources(element))
 205         element->clearHasPendingResources();
 206 }
 207
 208 void SVGDocumentExtensions::removeElementFromPendingResources(Element* element)
 209 {
 210     ASSERT(element);
 211
 212     // Remove the element from pending resources.
 213     if (!m_pendingResources.isEmpty() && element->hasPendingResources()) {
 214         Vector<AtomicString> toBeRemoved;
 215         for (const auto& entry : m_pendingResources) {
 216             SVGPendingElements* elements = entry.value.get();
 217             ASSERT(elements);
 218             ASSERT(!elements->isEmpty());
 219
 220             elements->remove(element);
 221             if (elements->isEmpty())
 222                 toBeRemoved.append(entry.key);
 223         }
 224
 225         clearHasPendingResourcesIfPossible(element);
 226
 227         // We use the removePendingResource function here because it deals with set lifetime correctly.
 228         for (const AtomicString& id : toBeRemoved)
 229             removePendingResource(id);
 230     }
 231
 232     // Remove the element from pending resources that were scheduled for removal.
 233     if (!m_pendingResourcesForRemoval.isEmpty()) {
 234         Vector<AtomicString> toBeRemoved;
 235         for (const auto& entry : m_pendingResourcesForRemoval) {
 236             SVGPendingElements* elements = entry.value.get();
 237             ASSERT(elements);
 238             ASSERT(!elements->isEmpty());
 239
 240             elements->remove(element);
 241             if (elements->isEmpty())
 242                 toBeRemoved.append(entry.key);
 243         }
 244
 245         // We use the removePendingResourceForRemoval function here because it deals with set lifetime correctly.
 246         for (const AtomicString& id : toBeRemoved)
 247             removePendingResourceForRemoval(id);
 248     }
 249 }
 250
 251 PassOwnPtrWillBeRawPtr<SVGDocumentExtensions::SVGPendingElements> SVGDocumentExtensions::removePendingResource(const AtomicString& id)
 252 {
 253     ASSERT(m_pendingResources.contains(id));
 254     return m_pendingResources.take(id);
 255 }
 256
 257 PassOwnPtrWillBeRawPtr<SVGDocumentExtensions::SVGPendingElements> SVGDocumentExtensions::removePendingResourceForRemoval(const AtomicString& id)
 258 {
 259     ASSERT(m_pendingResourcesForRemoval.contains(id));
 260     return m_pendingResourcesForRemoval.take(id);
 261 }
 262
 263 void SVGDocumentExtensions::markPendingResourcesForRemoval(const AtomicString& id)
 264 {
 265     if (id.isEmpty())
 266         return;
 267
 268     ASSERT(!m_pendingResourcesForRemoval.contains(id));
 269
 270     OwnPtrWillBeMember<SVGPendingElements> existing = m_pendingResources.take(id);
 271     if (existing && !existing->isEmpty())
 272         m_pendingResourcesForRemoval.add(id, existing.release());
 273 }
 274
 275 Element* SVGDocumentExtensions::removeElementFromPendingResourcesForRemoval(const AtomicString& id)
 276 {
 277     if (id.isEmpty())
 278         return nullptr;
 279
 280     SVGPendingElements* resourceSet = m_pendingResourcesForRemoval.get(id);
 281     if (!resourceSet || resourceSet->isEmpty())
 282         return nullptr;
 283
 284     SVGPendingElements::iterator firstElement = resourceSet->begin();
 285     Element* element = *firstElement;
 286
 287     resourceSet->remove(firstElement);
 288
 289     if (resourceSet->isEmpty())
 290         removePendingResourceForRemoval(id);
 291
 292     return element;
 293 }
 294
 295 void SVGDocumentExtensions::addSVGRootWithRelativeLengthDescendents(SVGSVGElement* svgRoot)
 296 {
 297     ASSERT(!m_inRelativeLengthSVGRootsInvalidation);
 298     m_relativeLengthSVGRoots.add(svgRoot);
 299 }
 300
 301 void SVGDocumentExtensions::removeSVGRootWithRelativeLengthDescendents(SVGSVGElement* svgRoot)
 302 {
 303     ASSERT(!m_inRelativeLengthSVGRootsInvalidation);
 304     m_relativeLengthSVGRoots.remove(svgRoot);
 305 }
 306
 307 bool SVGDocumentExtensions::isSVGRootWithRelativeLengthDescendents(SVGSVGElement* svgRoot) const
 308 {
 309     return m_relativeLengthSVGRoots.contains(svgRoot);
 310 }
 311
 312 void SVGDocumentExtensions::invalidateSVGRootsWithRelativeLengthDescendents(SubtreeLayoutScope* scope)
 313 {
 314     ASSERT(!m_inRelativeLengthSVGRootsInvalidation);
 315 #if ENABLE(ASSERT)
 316     TemporaryChange<bool> inRelativeLengthSVGRootsChange(m_inRelativeLengthSVGRootsInvalidation, true);
 317 #endif
 318
 319     for (SVGSVGElement* element : m_relativeLengthSVGRoots)
 320         element->invalidateRelativeLengthClients(scope);
 321 }
 322
 323 bool SVGDocumentExtensions::zoomAndPanEnabled() const
 324 {
 325     if (SVGSVGElement* svg = rootElement(*m_document))
 326         return svg->zoomAndPanEnabled();
 327     return false;
 328 }
 329
 330 void SVGDocumentExtensions::startPan(const FloatPoint& start)
 331 {
 332     if (SVGSVGElement* svg = rootElement(*m_document))
 333         m_translate = FloatPoint(start.x() - svg->currentTranslate().x(), start.y() - svg->currentTranslate().y());
 334 }
 335
 336 void SVGDocumentExtensions::updatePan(const FloatPoint& pos) const
 337 {
 338     if (SVGSVGElement* svg = rootElement(*m_document))
 339         svg->setCurrentTranslate(FloatPoint(pos.x() - m_translate.x(), pos.y() - m_translate.y()));
 340 }
 341
 342 SVGSVGElement* SVGDocumentExtensions::rootElement(const Document& document)
 343 {
 344     Element* elem = document.documentElement();
 345     return isSVGSVGElement(elem) ? toSVGSVGElement(elem) : 0;
 346 }
 347
 348 SVGSVGElement* SVGDocumentExtensions::rootElement() const
 349 {
 350     ASSERT(m_document);
 351     return rootElement(*m_document);
 352 }
 353
 354 DEFINE_TRACE(SVGDocumentExtensions)
 355 {
 356 #if ENABLE(OILPAN)
 357     visitor->trace(m_document);
 358     visitor->trace(m_timeContainers);
 359     visitor->trace(m_relativeLengthSVGRoots);
 360     visitor->trace(m_pendingResources);
 361     visitor->trace(m_pendingResourcesForRemoval);
 362 #endif
 363 }
 364
 365 }