Improve separation between "SMIL times" and timestamps

third_party/WebKit/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 964 matching lines @@
       }
     }
   }
   m_nextProgressTime = elapsed;
 
   if (m_timeContainer)
     m_timeContainer->notifyIntervalsChanged();
 }
 
 SVGSMILElement::RestartedInterval SVGSMILElement::maybeRestartInterval(
-    SMILTime elapsed) {
-  ASSERT(!m_isWaitingForFirstInterval);
-  ASSERT(elapsed >= m_interval.begin);
+    double elapsed) {
+  DCHECK(!m_isWaitingForFirstInterval);
+  DCHECK(elapsed >= m_interval.begin);
 
   Restart restart = this->getRestart();
   if (restart == RestartNever)
     return DidNotRestartInterval;
 
   if (elapsed < m_interval.end) {
     if (restart != RestartAlways)
       return DidNotRestartInterval;
     SMILTime nextBegin = findInstanceTime(Begin, m_interval.begin, false);
     if (nextBegin < m_interval.end) {
       m_interval.end = nextBegin;
       notifyDependentsIntervalChanged();
     }
   }
 
   if (elapsed >= m_interval.end) {
     if (resolveNextInterval() && elapsed >= m_interval.begin)
       return DidRestartInterval;
   }
   return DidNotRestartInterval;
 }
 
-void SVGSMILElement::seekToIntervalCorrespondingToTime(SMILTime elapsed) {
-  ASSERT(!m_isWaitingForFirstInterval);
-  ASSERT(elapsed >= m_interval.begin);
+void SVGSMILElement::seekToIntervalCorrespondingToTime(double elapsed) {
+  DCHECK(!m_isWaitingForFirstInterval);
+  DCHECK(elapsed >= m_interval.begin);
 
   // Manually seek from interval to interval, just as if the animation would run
   // regulary.
   while (true) {
     // Figure out the next value in the begin time list after the current
     // interval begin.
     SMILTime nextBegin = findInstanceTime(Begin, m_interval.begin, false);
 
     // If the 'nextBegin' time is unresolved (eg. just one defined interval),
     // we're done seeking.
@@ skipping 18 matching lines @@
       if (!resolveNextInterval())
         break;
       continue;
     }
 
     return;
   }
 }
 
 float SVGSMILElement::calculateAnimationPercentAndRepeat(
-    SMILTime elapsed,
+    double elapsed,
     unsigned& repeat) const {
   SMILTime simpleDuration = this->simpleDuration();
   repeat = 0;
   if (simpleDuration.isIndefinite()) {
     repeat = 0;
     return 0.f;
   }
   if (!simpleDuration) {
     repeat = 0;
     return 1.f;
   }
-  ASSERT(m_interval.begin.isFinite());
-  ASSERT(simpleDuration.isFinite());
-  SMILTime activeTime = elapsed - m_interval.begin;
+  DCHECK(m_interval.begin.isFinite());
+  DCHECK(simpleDuration.isFinite());
+  double activeTime = elapsed - m_interval.begin.value();
   SMILTime repeatingDuration = this->repeatingDuration();
   if (elapsed >= m_interval.end || activeTime > repeatingDuration) {
     repeat = static_cast<unsigned>(repeatingDuration.value() /
                                    simpleDuration.value());
     if (!fmod(repeatingDuration.value(), simpleDuration.value()))
       repeat--;
 
     double percent = (m_interval.end.value() - m_interval.begin.value()) /
                      simpleDuration.value();
     percent = percent - floor(percent);
     if (percent < std::numeric_limits<float>::epsilon() ||
         1 - percent < std::numeric_limits<float>::epsilon())
       return 1.0f;
     return clampTo<float>(percent);
   }
-  repeat = static_cast<unsigned>(activeTime.value() / simpleDuration.value());
-  SMILTime simpleTime = fmod(activeTime.value(), simpleDuration.value());
-  return clampTo<float>(simpleTime.value() / simpleDuration.value());
+  repeat = static_cast<unsigned>(activeTime / simpleDuration.value());
+  double simpleTime = fmod(activeTime, simpleDuration.value());
+  return clampTo<float>(simpleTime / simpleDuration.value());
 }
 
-SMILTime SVGSMILElement::calculateNextProgressTime(SMILTime elapsed) const {
+SMILTime SVGSMILElement::calculateNextProgressTime(double elapsed) const {
   if (m_activeState == Active) {
     // If duration is indefinite the value does not actually change over time.
     // Same is true for <set>.
     SMILTime simpleDuration = this->simpleDuration();
     if (simpleDuration.isIndefinite() || isSVGSetElement(*this)) {
       SMILTime repeatingDurationEnd = m_interval.begin + repeatingDuration();
       // We are supposed to do freeze semantics when repeating ends, even if the
       // element is still active.
       // Take care that we get a timer callback at that point.
       if (elapsed < repeatingDurationEnd &&
           repeatingDurationEnd < m_interval.end &&
           repeatingDurationEnd.isFinite())
         return repeatingDurationEnd;
       return m_interval.end;
     }
     return elapsed + 0.025;
   }
   return m_interval.begin >= elapsed ? m_interval.begin
                                      : SMILTime::unresolved();
 }
 
 SVGSMILElement::ActiveState SVGSMILElement::determineActiveState(
     SMILTime elapsed) const {
   if (elapsed >= m_interval.begin && elapsed < m_interval.end)
     return Active;
 
   return fill() == FillFreeze ? Frozen : Inactive;
 }
 
-bool SVGSMILElement::isContributing(SMILTime elapsed) const {
+bool SVGSMILElement::isContributing(double elapsed) const {
   // 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_interval.begin + repeatingDuration())) ||
          m_activeState == Frozen;
 }
 
-bool SVGSMILElement::progress(SMILTime elapsed, bool seekToTime) {
+bool SVGSMILElement::progress(double elapsed, bool seekToTime) {
   ASSERT(m_timeContainer);
   ASSERT(m_isWaitingForFirstInterval || m_interval.begin.isFinite());
 
   if (!m_syncBaseConditionsConnected)
     connectSyncBaseConditions();
 
   if (!m_interval.begin.isFinite()) {
     ASSERT(m_activeState == Inactive);
     m_nextProgressTime = SMILTime::unresolved();
     return false;
@@ skipping 216 matching lines @@
 DEFINE_TRACE(SVGSMILElement) {
   visitor->trace(m_targetElement);
   visitor->trace(m_timeContainer);
   visitor->trace(m_conditions);
   visitor->trace(m_syncBaseDependents);
   SVGElement::trace(visitor);
   SVGTests::trace(visitor);
 }
 
 }  // namespace blink