Merge 129670 - Refactor SMILTimeContainer to maintain animation information instead of recalculatin…

Source/WebCore/svg/animation/SMILTimeContainer.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 18 matching lines @@
 #if ENABLE(SVG)
 #include "Document.h"
 #include "SVGNames.h"
 #include "SVGSMILElement.h"
 #include "SVGSVGElement.h"
 #include <wtf/CurrentTime.h>
 
 using namespace std;
 
 namespace WebCore {
-    
+
 static const double animationFrameDelay = 0.025;
 
 SMILTimeContainer::SMILTimeContainer(SVGSVGElement* owner) 
     : m_beginTime(0)
     , m_pauseTime(0)
     , m_accumulatedPauseTime(0)
     , m_presetStartTime(0)
     , m_documentOrderIndexesDirty(false)
     , m_timer(this, &SMILTimeContainer::timerFired)
     , m_ownerSVGElement(owner)
+#ifndef NDEBUG
+    , m_preventScheduledAnimationsChanges(false)
+#endif
 {
 }
 
-void SMILTimeContainer::schedule(SVGSMILElement* animation)
+SMILTimeContainer::~SMILTimeContainer()
+{
+#ifndef NDEBUG
+    ASSERT(!m_preventScheduledAnimationsChanges);
+#endif
+    deleteAllValues(m_scheduledAnimations);
+}
+
+void SMILTimeContainer::schedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
 {
     ASSERT(animation->timeContainer() == this);
+    ASSERT(target);
+    ASSERT(animation->hasValidAttributeName());
+
+#ifndef NDEBUG
+    ASSERT(!m_preventScheduledAnimationsChanges);
+#endif
+
+    ElementAttributePair key(target, attributeName);
+    AnimationsVector* scheduled = m_scheduledAnimations.get(key);
+    if (!scheduled) {
+        scheduled = new AnimationsVector();
+        m_scheduledAnimations.set(key, scheduled);
+    }
+    ASSERT(!scheduled->contains(animation));
+    scheduled->append(animation);
+
     SMILTime nextFireTime = animation->nextProgressTime();
-    if (!nextFireTime.isFinite())
-        return;
-    m_scheduledAnimations.add(animation);
-    startTimer(0);
+    if (nextFireTime.isFinite())
+        notifyIntervalsChanged();
 }
-    
-void SMILTimeContainer::unschedule(SVGSMILElement* animation)
+
+void SMILTimeContainer::unschedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
 {
     ASSERT(animation->timeContainer() == this);
 
-    m_scheduledAnimations.remove(animation);
+#ifndef NDEBUG
+    ASSERT(!m_preventScheduledAnimationsChanges);
+#endif
+
+    ElementAttributePair key(target, attributeName);
+    AnimationsVector* scheduled = m_scheduledAnimations.get(key);
+    ASSERT(scheduled);
+    size_t idx = scheduled->find(animation);
+    ASSERT(idx != notFound);
+    scheduled->remove(idx);
+}
+
+void SMILTimeContainer::notifyIntervalsChanged()
+{
+    // Schedule updateAnimations() to be called asynchronously so multiple intervals
+    // can change with updateAnimations() only called once at the end.
+    startTimer(0);
 }
 
 SMILTime SMILTimeContainer::elapsed() const
 {
     if (!m_beginTime)
         return 0;
     return currentTime() - m_beginTime - m_accumulatedPauseTime;
 }
-    
+
 bool SMILTimeContainer::isActive() const
 {
     return m_beginTime && !isPaused();
 }
-    
+
 bool SMILTimeContainer::isPaused() const
 {
     return m_pauseTime;
 }
 
 bool SMILTimeContainer::isStarted() const
 {
     return m_beginTime;
 }
 
@@ skipping 45 matching lines @@
     if (m_beginTime)
         m_timer.stop();
 
     double now = currentTime();
     m_beginTime = now - time.value();
 
     m_accumulatedPauseTime = 0;
     if (m_pauseTime)
         m_pauseTime = now;
 
-    Vector<SVGSMILElement*> toReset;
-    copyToVector(m_scheduledAnimations, toReset);
-    for (unsigned n = 0; n < toReset.size(); ++n)
-        toReset[n]->reset();
+#ifndef NDEBUG
+    m_preventScheduledAnimationsChanges = true;
+#endif
+    GroupedAnimationsMap::iterator end = m_scheduledAnimations.end();
+    for (GroupedAnimationsMap::iterator it = m_scheduledAnimations.begin(); it != end; ++it) {
+        AnimationsVector* scheduled = it->second;
+        unsigned size = scheduled->size();
+        for (unsigned n = 0; n < size; n++)
+            scheduled->at(n)->reset();
+    }
+#ifndef NDEBUG
+    m_preventScheduledAnimationsChanges = false;
+#endif
 
     updateAnimations(time, true);
 }
 
 void SMILTimeContainer::startTimer(SMILTime fireTime, SMILTime minimumDelay)
 {
     if (!m_beginTime || isPaused())
         return;
-    
+
     if (!fireTime.isFinite())
         return;
-    
+
     SMILTime delay = max(fireTime - elapsed(), minimumDelay);
     m_timer.startOneShot(delay.value());
 }
 
 void SMILTimeContainer::timerFired(Timer<SMILTimeContainer>*)
 {
     ASSERT(m_beginTime);
     ASSERT(!m_pauseTime);
     updateAnimations(elapsed());
 }
@@ skipping 27 matching lines @@
 
 void SMILTimeContainer::sortByPriority(Vector<SVGSMILElement*>& smilElements, SMILTime elapsed)
 {
     if (m_documentOrderIndexesDirty)
         updateDocumentOrderIndexes();
     std::sort(smilElements.begin(), smilElements.end(), PriorityCompare(elapsed));
 }
 
 void SMILTimeContainer::updateAnimations(SMILTime elapsed, bool seekToTime)
 {
-    SMILTime earliersFireTime = SMILTime::unresolved();
+    SMILTime earliestFireTime = SMILTime::unresolved();
 
-    Vector<SVGSMILElement*> toAnimate;
-    copyToVector(m_scheduledAnimations, toAnimate);
+#ifndef NDEBUG
+    // This boolean will catch any attempts to schedule/unschedule scheduledAnimations during this critical section.
+    // Similarly, any elements removed will unschedule themselves, so this will catch modification of animationsToApply.
+    m_preventScheduledAnimationsChanges = true;
+#endif
 
-    // Sort according to priority. Elements with later begin time have higher priority.
-    // In case of a tie, document order decides. 
-    // FIXME: This should also consider timing relationships between the elements. Dependents
-    // have higher priority.
-    sortByPriority(toAnimate, elapsed);
+    AnimationsVector animationsToApply;
+    GroupedAnimationsMap::iterator end = m_scheduledAnimations.end();
+    for (GroupedAnimationsMap::iterator it = m_scheduledAnimations.begin(); it != end; ++it) {
+        AnimationsVector* scheduled = it->second;
 
-    // Calculate animation contributions.
-    typedef pair<SVGElement*, QualifiedName> ElementAttributePair;
-    typedef HashMap<ElementAttributePair, SVGSMILElement*> ResultElementMap;
-    ResultElementMap resultsElements;
-    for (unsigned n = 0; n < toAnimate.size(); ++n) {
-        SVGSMILElement* animation = toAnimate[n];
-        ASSERT(animation->timeContainer() == this);
+        // Sort according to priority. Elements with later begin time have higher priority.
+        // In case of a tie, document order decides. 
+        // FIXME: This should also consider timing relationships between the elements. Dependents
+        // have higher priority.
+        sortByPriority(*scheduled, elapsed);
 
-        SVGElement* targetElement = animation->targetElement();
-        if (!targetElement)
-            continue;
+        SVGSMILElement* resultElement = 0;
+        unsigned size = scheduled->size();
+        for (unsigned n = 0; n < size; n++) {
+            SVGSMILElement* animation = scheduled->at(n);
+            ASSERT(animation->timeContainer() == this);
+            ASSERT(animation->targetElement());
+            ASSERT(animation->hasValidAttributeName());
 
-        QualifiedName attributeName = animation->attributeName();
-        if (attributeName == anyQName()) {
-            if (animation->hasTagName(SVGNames::animateMotionTag))
-                attributeName = SVGNames::animateMotionTag;
-            else
-                continue;
+            // Results are accumulated to the first animation that animates and contributes to a particular element/attribute pair.
+            if (!resultElement) {
+                if (!animation->hasValidAttributeType())
+                    continue;
+                resultElement = animation;
+            }
+
+            // This will calculate the contribution from the animation and add it to the resultsElement.
+            if (!animation->progress(elapsed, resultElement, seekToTime) && resultElement == animation)
+                resultElement = 0;
+
+            SMILTime nextFireTime = animation->nextProgressTime();
+            if (nextFireTime.isFinite())
+                earliestFireTime = min(nextFireTime, earliestFireTime);
         }
 
-        // Results are accumulated to the first animation that animates and contributes to a particular element/attribute pair.
-        ElementAttributePair key(targetElement, attributeName); 
-        SVGSMILElement* resultElement = resultsElements.get(key);
-        if (!resultElement) {
-            if (!animation->hasValidAttributeType())
-                continue;
-            resultElement = animation;
-        } else
-            ASSERT(resultElement != animation);
-
-        // This will calculate the contribution from the animation and add it to the resultsElement.
-        if (animation->progress(elapsed, resultElement, seekToTime) && resultElement == animation)
-            resultsElements.add(key, resultElement);
-
-        SMILTime nextFireTime = animation->nextProgressTime();
-        if (nextFireTime.isFinite())
-            earliersFireTime = min(nextFireTime, earliersFireTime);
+        if (resultElement)
+            animationsToApply.append(resultElement);
     }
 
-    unsigned resultsToApplySize = resultsElements.size();
-    if (!resultsToApplySize) {
-        startTimer(earliersFireTime, animationFrameDelay);
+    unsigned animationsToApplySize = animationsToApply.size();
+    if (!animationsToApplySize) {
+#ifndef NDEBUG
+        m_preventScheduledAnimationsChanges = false;
+#endif
+        startTimer(earliestFireTime, animationFrameDelay);
         return;
     }
 
     // Apply results to target elements.
-    ResultElementMap::iterator end = resultsElements.end();
-    for (ResultElementMap::iterator it = resultsElements.begin(); it != end; ++it)
-        it->second->applyResultsToTarget();
+    for (unsigned i = 0; i < animationsToApplySize; ++i)
+        animationsToApply[i]->applyResultsToTarget();
 
-    startTimer(earliersFireTime, animationFrameDelay);
+#ifndef NDEBUG
+    m_preventScheduledAnimationsChanges = false;
+#endif
+
+    startTimer(earliestFireTime, animationFrameDelay);
     Document::updateStyleForAllDocuments();
 }
 
 }
 
 #endif // ENABLE(SVG)