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

Source/WebCore/svg/animation/SVGSMILElement.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 122 matching lines @@
     , m_cachedRepeatCount(invalidCachedTime)
     , m_cachedMin(invalidCachedTime)
     , m_cachedMax(invalidCachedTime)
 {
     resolveFirstInterval();
 }
 
 SVGSMILElement::~SVGSMILElement()
 {
     disconnectConditions();
-    if (m_timeContainer)
-        m_timeContainer->unschedule(this);
+    if (m_timeContainer && m_targetElement && hasValidAttributeName())
+        m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
     if (m_targetElement)
         document()->accessSVGExtensions()->removeAnimationElementFromTarget(this, m_targetElement);
 }
 
 static inline QualifiedName constructQualifiedName(const SVGElement* svgElement, const String& attributeName)
 {
     ASSERT(svgElement);
     if (attributeName.isEmpty())
         return anyQName();
     if (!attributeName.contains(':'))
@@ skipping 38 matching lines @@
 
 Node::InsertionNotificationRequest SVGSMILElement::insertedInto(ContainerNode* rootParent)
 {
     SVGElement::insertedInto(rootParent);
     if (!rootParent->inDocument())
         return InsertionDone;
 
     // Verify we are not in <use> instance tree.
     ASSERT(!isInShadowTree());
 
-    m_attributeName = constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr));
+    setAttributeName(constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr)));
     SVGSVGElement* owner = ownerSVGElement();
     if (!owner)
         return InsertionDone;
+
     m_timeContainer = owner->timeContainer();
     ASSERT(m_timeContainer);
     m_timeContainer->setDocumentOrderIndexesDirty();
 
     // "If no attribute is present, the default begin value (an offset-value of 0) must be evaluated."
     if (!fastHasAttribute(SVGNames::beginAttr))
         m_beginTimes.append(SMILTimeWithOrigin());
 
     if (m_isWaitingForFirstInterval)
         resolveFirstInterval();
 
-    reschedule();
+    // Force resolution of target element
+    if (!m_targetElement)
+        targetElement();
+    if (m_timeContainer)
+        m_timeContainer->notifyIntervalsChanged();
 
     return InsertionDone;
 }
 
 void SVGSMILElement::removedFrom(ContainerNode* rootParent)
 {
     if (rootParent->inDocument()) {
         if (m_timeContainer) {
-            m_timeContainer->unschedule(this);
+            if (m_targetElement && hasValidAttributeName())
+                m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
             m_timeContainer = 0;
         }
         // Calling disconnectConditions() may kill us if there are syncbase conditions.
         // OK, but we don't want to die inside the call.
         RefPtr<SVGSMILElement> keepAlive(this);
         disconnectConditions();
 
         // Clear target now, because disconnectConditions calls targetElement() which will recreate the target if we removed it sooner. 
         if (m_targetElement)
-            resetTargetElement();
+            resetTargetElement(DoNotResolveNewTarget);
 
-        m_attributeName = anyQName();
+        setAttributeName(anyQName());
     }
 
     SVGElement::removedFrom(rootParent);
 }
-   
+
+bool SVGSMILElement::hasValidAttributeName()
+{
+    return attributeName() != anyQName();
+}
+
 SMILTime SVGSMILElement::parseOffsetValue(const String& data)
 {
     bool ok;
     double result = 0;
     String parse = data.stripWhiteSpace();
     if (parse.endsWith('h'))
         result = parse.left(parse.length() - 1).toDouble(&ok) * 60 * 60;
     else if (parse.endsWith("min"))
         result = parse.left(parse.length() - 3).toDouble(&ok) * 60;
     else if (parse.endsWith("ms"))
@@ skipping 203 matching lines @@
     else if (attrName == SVGNames::minAttr)
         m_cachedMin = invalidCachedTime;
     else if (attrName == SVGNames::maxAttr)
         m_cachedMax = invalidCachedTime;
     else if (inDocument()) {
         if (attrName == SVGNames::beginAttr)
             beginListChanged(elapsed());
         else if (attrName == SVGNames::endAttr)
             endListChanged(elapsed());
         else if (attrName == SVGNames::attributeNameAttr) {
-            m_attributeName = constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr));
+            setAttributeName(constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr)));
             if (m_targetElement) {
                 resetTargetElement();
                 return;
             }
         } else if (attrName.matches(XLinkNames::hrefAttr)) {
+            // targetElement is resolved lazily but targetElement() will handle calling targetElementWillChange().
             if (SVGElement* targetElement = this->targetElement())
                 document()->accessSVGExtensions()->removeAllAnimationElementsFromTarget(targetElement);
         }
     }
 
     animationAttributeChanged();
 }
 
 inline Element* SVGSMILElement::eventBaseFor(const Condition& condition)
 {
@@ skipping 52 matching lines @@
         } else if (condition.m_type == Condition::Syncbase) {
             if (condition.m_syncbase) {
                 ASSERT(isSMILElement(condition.m_syncbase.get()));
                 static_cast<SVGSMILElement*>(condition.m_syncbase.get())->removeTimeDependent(this);
             }
         }
         condition.m_syncbase = 0;
     }
 }
 
-void SVGSMILElement::reschedule()
+void SVGSMILElement::setAttributeName(const QualifiedName& attributeName)
 {
-    if (m_timeContainer)
-        m_timeContainer->schedule(this);
+    if (m_timeContainer && m_targetElement && m_attributeName != attributeName) {
+        if (hasValidAttributeName())
+            m_timeContainer->unschedule(this, m_targetElement, m_attributeName);
+        m_attributeName = attributeName;
+        if (hasValidAttributeName())
+            m_timeContainer->schedule(this, m_targetElement, m_attributeName);
+    } else
+        m_attributeName = attributeName;
 }
 
 SVGElement* SVGSMILElement::targetElement()
 {
     if (m_targetElement)
         return m_targetElement;
 
     if (!inDocument())
         return 0;
 
     String href = getAttribute(XLinkNames::hrefAttr);
     ContainerNode* target = href.isEmpty() ? parentNode() : SVGURIReference::targetElementFromIRIString(href, document());
     if (!target || !target->isSVGElement())
         return 0;
 
     SVGElement* targetElement = static_cast<SVGElement*>(target);
     targetElementWillChange(m_targetElement, targetElement);
     m_targetElement = targetElement;
     document()->accessSVGExtensions()->addAnimationElementToTarget(this, m_targetElement);
     return m_targetElement;
 }
 
-void SVGSMILElement::targetElementWillChange(SVGElement* currentTarget, SVGElement*)
+void SVGSMILElement::targetElementWillChange(SVGElement* currentTarget, SVGElement* newTarget)
 {
+    if (m_timeContainer && hasValidAttributeName()) {
+        if (currentTarget)
+            m_timeContainer->unschedule(this, currentTarget, m_attributeName);
+        if (newTarget)
+            m_timeContainer->schedule(this, newTarget, m_attributeName);
+    }
+
     // Only clear the animated type, if we had a target before.
     if (currentTarget)
         clearAnimatedType(currentTarget);
 
     // If the animation state is not Inactive, always reset to a clear state before leaving the old target element.
     if (m_activeState != Inactive)
         endedActiveInterval();
 }
 
-void SVGSMILElement::resetTargetElement()
+void SVGSMILElement::resetTargetElement(ResolveTarget resolveTarget)
 {
     document()->accessSVGExtensions()->removeAnimationElementFromTarget(this, m_targetElement);
     targetElementWillChange(m_targetElement, 0);
     m_targetElement = 0;
+
+    // Immediately resolve the new targetElement (and call targetElementWillChange if needed) instead of doing it lazily.
+    if (resolveTarget == ResolveNewTarget)
+        targetElement();
+
     animationAttributeChanged();
 }
 
 SMILTime SVGSMILElement::elapsed() const
 {
     return m_timeContainer ? m_timeContainer->elapsed() : 0;
 }
 
 bool SVGSMILElement::isInactive() const
 {
@@ skipping 218 matching lines @@
     SMILTime end;
     resolveInterval(true, begin, end);
     ASSERT(!begin.isIndefinite());
 
     if (!begin.isUnresolved() && (begin != m_intervalBegin || end != m_intervalEnd)) {   
         bool wasUnresolved = m_intervalBegin.isUnresolved();
         m_intervalBegin = begin;
         m_intervalEnd = end;
         notifyDependentsIntervalChanged(wasUnresolved ? NewInterval : ExistingInterval);
         m_nextProgressTime = min(m_nextProgressTime, m_intervalBegin);
-        reschedule();
+
+        if (m_timeContainer)
+            m_timeContainer->notifyIntervalsChanged();
     }
 }
 
 void SVGSMILElement::resolveNextInterval(bool notifyDependents)
 {
     SMILTime begin;
     SMILTime end;
     resolveInterval(false, begin, end);
     ASSERT(!begin.isIndefinite());
     
@@ skipping 27 matching lines @@
                 if (m_activeState == Active && m_intervalBegin > eventTime) {
                     m_activeState = determineActiveState(eventTime);
                     if (m_activeState != Active)
                         endedActiveInterval();
                 }
                 notifyDependentsIntervalChanged(ExistingInterval);
             }
         }
     }
     m_nextProgressTime = elapsed();
-    reschedule();
+
+    if (m_timeContainer)
+        m_timeContainer->notifyIntervalsChanged();
 }
 
 void SVGSMILElement::endListChanged(SMILTime)
 {
     SMILTime elapsed = this->elapsed();
     if (m_isWaitingForFirstInterval)
         resolveFirstInterval();
     else if (elapsed < m_intervalEnd && m_intervalBegin.isFinite()) {
         SMILTime newEnd = findInstanceTime(End, m_intervalBegin, false);
         if (newEnd < m_intervalEnd) {
             newEnd = resolveActiveEnd(m_intervalBegin, newEnd);
             if (newEnd != m_intervalEnd) {
                 m_intervalEnd = newEnd;
                 notifyDependentsIntervalChanged(ExistingInterval);
             }
         }
     }
     m_nextProgressTime = elapsed;
-    reschedule();
+
+    if (m_timeContainer)
+        m_timeContainer->notifyIntervalsChanged();
 }
 
 void SVGSMILElement::checkRestart(SMILTime elapsed)
 {
     ASSERT(!m_isWaitingForFirstInterval);
     ASSERT(elapsed >= m_intervalBegin);
 
     Restart restart = this->restart();
     if (restart == RestartNever)
         return;
@@ skipping 107 matching lines @@
 { 
     // Animation does not contribute during the active time if it is past its repeating duration and has fill=remove.
     return (m_activeState == Active && (fill() == FillFreeze || elapsed <= m_intervalBegin + repeatingDuration())) || m_activeState == Frozen;
 }
     
 bool SVGSMILElement::progress(SMILTime elapsed, SVGSMILElement* resultElement, bool seekToTime)
 {
     ASSERT(resultElement);
     ASSERT(m_timeContainer);
     ASSERT(m_isWaitingForFirstInterval || m_intervalBegin.isFinite());
-    
+
     if (!m_conditionsConnected)
         connectConditions();
-    
+
     if (!m_intervalBegin.isFinite()) {
         ASSERT(m_activeState == Inactive);
         m_nextProgressTime = SMILTime::unresolved();
         return false;
     }
 
     if (elapsed < m_intervalBegin) {
         ASSERT(m_activeState != Active);
         if (m_activeState == Frozen)
             updateAnimation(m_lastPercent, m_lastRepeat, resultElement);
         m_nextProgressTime = m_intervalBegin;
         return false;
     }
-    
+
     m_previousIntervalBegin = m_intervalBegin;
 
     if (m_isWaitingForFirstInterval) {
         m_isWaitingForFirstInterval = false;
         resolveFirstInterval();
     }
 
     // This call may obtain a new interval -- never call calculateAnimationPercentAndRepeat() before!
     if (seekToTime) {
         seekToIntervalCorrespondingToTime(elapsed);
@@ skipping 104 matching lines @@
 
 void SVGSMILElement::endedActiveInterval()
 {
     clearTimesWithDynamicOrigins(m_beginTimes);
     clearTimesWithDynamicOrigins(m_endTimes);
 }
 
 }
 
 #endif