Use NaN/Inf to represent unresolved/indefinite SMILTimes

Source/core/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 473 matching lines @@
 
     return true;
 }
 
 void SVGSMILElement::parseBeginOrEnd(const String& parseString, BeginOrEnd beginOrEnd)
 {
     Vector<SMILTimeWithOrigin>& timeList = beginOrEnd == Begin ? m_beginTimes : m_endTimes;
     if (beginOrEnd == End)
         m_hasEndEventConditions = false;
     HashSet<double> existing;
-    for (unsigned n = 0; n < timeList.size(); ++n)
-        existing.add(timeList[n].time().value());
+    for (unsigned n = 0; n < timeList.size(); ++n) {
+        if (!timeList[n].time().isUnresolved())
+            existing.add(timeList[n].time().value());
+    }
     Vector<String> splitString;
     parseString.split(';', splitString);
     for (unsigned n = 0; n < splitString.size(); ++n) {
         SMILTime value = parseClockValue(splitString[n]);
         if (value.isUnresolved())
             parseCondition(splitString[n], beginOrEnd);
-        else if (!existing.contains(value.value()))
+        else if (value.isFinite() && !existing.contains(value.value()))
             timeList.append(SMILTimeWithOrigin(value, SMILTimeWithOrigin::ParserOrigin));
     }
     sortTimeList(timeList);
 }
 
 bool SVGSMILElement::isSupportedAttribute(const QualifiedName& attrName)
 {
     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
     if (supportedAttributes.isEmpty()) {
         SVGTests::addSupportedAttributes(supportedAttributes);
@@ skipping 286 matching lines @@
     return m_cachedMin = (result.isUnresolved() || result < 0) ? 0 : result;
 }
 
 SMILTime SVGSMILElement::simpleDuration() const
 {
     return std::min(dur(), SMILTime::indefinite());
 }
 
 void SVGSMILElement::addBeginTime(SMILTime eventTime, SMILTime beginTime, SMILTimeWithOrigin::Origin origin)
 {
-    ASSERT(!std::isnan(beginTime.value()));
+    ASSERT(!beginTime.isUnresolved());
     m_beginTimes.append(SMILTimeWithOrigin(beginTime, origin));
     sortTimeList(m_beginTimes);
     beginListChanged(eventTime);
 }
 
 void SVGSMILElement::addEndTime(SMILTime eventTime, SMILTime endTime, SMILTimeWithOrigin::Origin origin)
 {
-    ASSERT(!std::isnan(endTime.value()));
+    ASSERT(!endTime.isUnresolved());
     m_endTimes.append(SMILTimeWithOrigin(endTime, origin));
     sortTimeList(m_endTimes);
     endListChanged(eventTime);
 }
 
 inline bool compareTimes(const SMILTimeWithOrigin& left, const SMILTimeWithOrigin& right)
 {
     return left.time() < right.time();
 }
 
@@ skipping 37 matching lines @@
 
 SMILTime SVGSMILElement::repeatingDuration() const
 {
     // Computing the active duration
     // http://www.w3.org/TR/SMIL2/smil-timing.html#Timing-ComputingActiveDur
     SMILTime repeatCount = this->repeatCount();
     SMILTime repeatDur = this->repeatDur();
     SMILTime simpleDuration = this->simpleDuration();
     if (!simpleDuration || (repeatDur.isUnresolved() && repeatCount.isUnresolved()))
         return simpleDuration;
+    repeatDur = std::min(repeatDur, SMILTime::indefinite());
     SMILTime repeatCountDuration = simpleDuration * repeatCount;
-    return std::min(repeatCountDuration, std::min(repeatDur, SMILTime::indefinite()));
+    if (!repeatCountDuration.isUnresolved())
+        return std::min(repeatDur, repeatCountDuration);
+    return repeatDur;
 }
 
 SMILTime SVGSMILElement::resolveActiveEnd(SMILTime resolvedBegin, SMILTime resolvedEnd) const
 {
     // Computing the active duration
     // http://www.w3.org/TR/SMIL2/smil-timing.html#Timing-ComputingActiveDur
     SMILTime preliminaryActiveDuration;
     if (!resolvedEnd.isUnresolved() && dur().isUnresolved() && repeatDur().isUnresolved() && repeatCount().isUnresolved())
         preliminaryActiveDuration = resolvedEnd - resolvedBegin;
     else if (!resolvedEnd.isFinite())
         preliminaryActiveDuration = repeatingDuration();
     else
         preliminaryActiveDuration = std::min(repeatingDuration(), resolvedEnd - resolvedBegin);
 
+    if (preliminaryActiveDuration.isUnresolved())
+        return SMILTime::unresolved();

[fs, 2014/08/21 15:30:39]

Actually,

min(maxValue, max(minValue, pAD)); pAD=unresolved => maxValue

(max(minValue, unresolved) => unresolved, min(maxValue, unresolved) => maxValue)

so the result should either be resolvedBegin + maxValue (if specified and valid)
or 'indefinite'.

I also think that it should "just work(TM)" with the fully defined SMILTime
operators. If not, I suggest just setting pAD to 'indefinite' (if 'unresolved').

+
     SMILTime minValue = this->minValue();
     SMILTime maxValue = this->maxValue();
     if (minValue > maxValue) {
         // Ignore both.
         // http://www.w3.org/TR/2001/REC-smil-animation-20010904/#MinMax
         minValue = 0;
         maxValue = SMILTime::indefinite();
     }
     return resolvedBegin + std::min(maxValue, std::max(minValue, preliminaryActiveDuration));
 }
@@ skipping 32 matching lines @@
 }
 
 void SVGSMILElement::resolveFirstInterval()
 {
     SMILInterval firstInterval = resolveInterval(FirstInterval);
     ASSERT(!firstInterval.begin.isIndefinite());
 
     if (!firstInterval.begin.isUnresolved() && firstInterval != m_interval) {
         m_interval = firstInterval;
         notifyDependentsIntervalChanged();
-        m_nextProgressTime = std::min(m_nextProgressTime, m_interval.begin);
+        m_nextProgressTime = m_nextProgressTime.isUnresolved() ? m_interval.begin : std::min(m_nextProgressTime, m_interval.begin);
 
         if (m_timeContainer)
             m_timeContainer->notifyIntervalsChanged();
     }
 }
 
 bool SVGSMILElement::resolveNextInterval()
 {
     SMILInterval nextInterval = resolveInterval(NextInterval);
     ASSERT(!nextInterval.begin.isIndefinite());
 
     if (!nextInterval.begin.isUnresolved() && nextInterval.begin != m_interval.begin) {
         m_interval = nextInterval;
         notifyDependentsIntervalChanged();
-        m_nextProgressTime = std::min(m_nextProgressTime, m_interval.begin);
+        m_nextProgressTime = m_nextProgressTime.isUnresolved() ? m_interval.begin : std::min(m_nextProgressTime, m_interval.begin);
         return true;
     }
 
     return false;
 }
 
 SMILTime SVGSMILElement::nextProgressTime() const
 {
     return m_nextProgressTime;
 }
@@ skipping 298 matching lines @@
         if (condition->type() == Condition::Syncbase && condition->syncBase() == syncBase) {
             ASSERT(condition->name() == "begin" || condition->name() == "end");
             // No nested time containers in SVG, no need for crazy time space conversions. Phew!
             SMILTime time = 0;
             if (condition->name() == "begin")
                 time = syncBase->m_interval.begin + condition->offset();
             else
                 time = syncBase->m_interval.end + condition->offset();
             if (!time.isFinite())
                 continue;
+            SMILTime elapsed = this->elapsed();
+            if (elapsed.isUnresolved())
+                return;

[fs, 2014/08/21 15:30:39]

return => continue

[reni, 2014/08/21 20:52:31]

Done.

             if (condition->beginOrEnd() == Begin)
-                addBeginTime(elapsed(), time);
+                addBeginTime(elapsed, time);
             else
-                addEndTime(elapsed(), time);
+                addEndTime(elapsed, time);
         }
     }
 }
 
 void SVGSMILElement::addSyncBaseDependent(SVGSMILElement* animation)
 {
     m_syncBaseDependents.add(animation);
     if (m_interval.begin.isFinite())
         animation->createInstanceTimesFromSyncbase(this);
 }
 
 void SVGSMILElement::removeSyncBaseDependent(SVGSMILElement* animation)
 {
     m_syncBaseDependents.remove(animation);
 }
 
 void SVGSMILElement::handleConditionEvent(Event* event, Condition* condition)
 {
     if (event->type() == "repeatn" && toRepeatEvent(event)->repeat() != condition->repeat())
         return;
 
     SMILTime elapsed = this->elapsed();
+    if (elapsed.isUnresolved())
+        return;
     if (condition->beginOrEnd() == Begin)
         addBeginTime(elapsed, elapsed + condition->offset());
     else
         addEndTime(elapsed, elapsed + condition->offset());
 }
 
 void SVGSMILElement::beginByLinkActivation()
 {
     SMILTime elapsed = this->elapsed();
+    if (elapsed.isUnresolved())
+        return;
     addBeginTime(elapsed, elapsed);
 }
 
 void SVGSMILElement::endedActiveInterval()
 {
     clearTimesWithDynamicOrigins(m_beginTimes);
     clearTimesWithDynamicOrigins(m_endTimes);
 }
 
 void SVGSMILElement::dispatchRepeatEvents(unsigned count)
@@ skipping 30 matching lines @@
 #if ENABLE(OILPAN)
     visitor->trace(m_targetElement);
     visitor->trace(m_timeContainer);
     visitor->trace(m_conditions);
     visitor->trace(m_syncBaseDependents);
 #endif
     SVGElement::trace(visitor);
 }
 
 }