Replace SMILTime with double for elapsed time in SMILTimeContainer

third_party/WebKit/Source/core/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 14 matching lines @@
 
 #include "core/svg/animation/SMILTimeContainer.h"
 
 #include "core/animation/AnimationClock.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/svg/SVGSVGElement.h"
+#include "core/svg/animation/SMILTime.h"
 #include "core/svg/animation/SVGSMILElement.h"
 #include <algorithm>
 
 namespace blink {
 
 static const double initialFrameDelay = 0.025;
 static const double animationPolicyOnceDuration = 3.000;
 
 SMILTimeContainer::SMILTimeContainer(SVGSVGElement& owner)
     : m_presentationTime(0)
@@ skipping 81 matching lines @@
     if (!isStarted())
         return;
     // Schedule updateAnimations() to be called asynchronously so multiple intervals
     // can change with updateAnimations() only called once at the end.
     if (hasPendingSynchronization())
         return;
     cancelAnimationFrame();
     scheduleWakeUp(0, SynchronizeAnimations);
 }
 
-SMILTime SMILTimeContainer::elapsed() const
+double SMILTimeContainer::elapsed() const
 {
     if (!isStarted())
         return 0;
 
     if (isPaused())
         return m_presentationTime;
 
     return m_presentationTime + (document().timeline().currentTimeInternal() - m_referenceTime);
 }
 
@@ skipping 28 matching lines @@
     if (!handleAnimationPolicy(RestartOnceTimerIfNotPaused))
         return;
 
     // Sample the document timeline to get a time reference for the "presentation time".
     synchronizeToDocumentTimeline();
     m_started = true;
 
     // If the "presentation time" is non-zero, the timeline was modified via
     // setElapsed() before the document began.
     // In this case pass on 'seekToTime=true' to updateAnimations() to issue a seek.
-    SMILTime earliestFireTime = updateAnimations(SMILTime(m_presentationTime), m_presentationTime ? true : false);
+    SMILTime earliestFireTime = updateAnimations(m_presentationTime, m_presentationTime ? true : false);
     if (!canScheduleFrame(earliestFireTime))
         return;
     // If the timeline is running, and there are pending animation updates,
     // always perform the first update after the timeline was started using
     // the wake-up mechanism.
-    SMILTime delay = earliestFireTime - m_presentationTime;
-    scheduleWakeUp(std::max(initialFrameDelay, delay.value()), SynchronizeAnimations);
+    double delayTime = earliestFireTime.value() - m_presentationTime;
+    scheduleWakeUp(std::max(initialFrameDelay, delayTime), SynchronizeAnimations);
 }
 
 void SMILTimeContainer::pause()
 {
     if (!handleAnimationPolicy(CancelOnceTimer))
         return;
     DCHECK(!isPaused());
 
     if (isStarted()) {
-        m_presentationTime = elapsed().value();
+        m_presentationTime = elapsed();
         cancelAnimationFrame();
     }
     // Update the flag after sampling elapsed().
     m_paused = true;
 }
 
 void SMILTimeContainer::resume()
 {
     if (!handleAnimationPolicy(RestartOnceTimer))
         return;
     DCHECK(isPaused());
 
     m_paused = false;
 
     if (isStarted())
         synchronizeToDocumentTimeline();
 
     scheduleWakeUp(0, SynchronizeAnimations);
 }
 
-void SMILTimeContainer::setElapsed(SMILTime time)
+void SMILTimeContainer::setElapsed(double elapsed)
 {
-    m_presentationTime = time.value();
+    m_presentationTime = elapsed;
 
     // If the document hasn't finished loading, |m_presentationTime| will be
     // used as the start time to seek to once it's possible.
     if (!isStarted())
         return;
 
     if (!handleAnimationPolicy(RestartOnceTimerIfNotPaused))
         return;
 
     cancelAnimationFrame();
 
     if (!isPaused())
         synchronizeToDocumentTimeline();
 
 #if ENABLE(ASSERT)
     m_preventScheduledAnimationsChanges = true;
 #endif
     for (const auto& entry : m_scheduledAnimations) {
         if (!entry.key.first)
             continue;
 
         AnimationsLinkedHashSet* scheduled = entry.value.get();
         for (SVGSMILElement* element : *scheduled)
             element->reset();
     }
 #if ENABLE(ASSERT)
     m_preventScheduledAnimationsChanges = false;
 #endif
 
-    updateAnimationsAndScheduleFrameIfNeeded(time, true);
+    updateAnimationsAndScheduleFrameIfNeeded(elapsed, true);
 }
 
 void SMILTimeContainer::scheduleAnimationFrame(double delayTime)
 {
     DCHECK(std::isfinite(delayTime));
     DCHECK(isTimelineRunning());
     DCHECK(!m_wakeupTimer.isActive());
 
     if (delayTime < AnimationTimeline::s_minimumDelay) {
         serviceOnNextFrame();
@@ skipping 88 matching lines @@
 
 void SMILTimeContainer::updateDocumentOrderIndexes()
 {
     unsigned timingElementCount = 0;
     for (SVGSMILElement& element : Traversal<SVGSMILElement>::descendantsOf(ownerSVGElement()))
         element.setDocumentOrderIndex(timingElementCount++);
     m_documentOrderIndexesDirty = false;
 }
 
 struct PriorityCompare {
-    PriorityCompare(SMILTime elapsed) : m_elapsed(elapsed) {}
+    PriorityCompare(double elapsed) : m_elapsed(elapsed) {}
     bool operator()(const Member<SVGSMILElement>& a, const Member<SVGSMILElement>& b)
     {
         // FIXME: This should also consider possible timing relations between the elements.
         SMILTime aBegin = a->intervalBegin();
         SMILTime bBegin = b->intervalBegin();
         // Frozen elements need to be prioritized based on their previous interval.
         aBegin = a->isFrozen() && m_elapsed < aBegin ? a->previousIntervalBegin() : aBegin;
         bBegin = b->isFrozen() && m_elapsed < bBegin ? b->previousIntervalBegin() : bBegin;
         if (aBegin == bBegin)
             return a->documentOrderIndex() < b->documentOrderIndex();
         return aBegin < bBegin;
     }
-    SMILTime m_elapsed;
+    double m_elapsed;
 };
 
 SVGSVGElement& SMILTimeContainer::ownerSVGElement() const
 {
     return *m_ownerSVGElement;
 }
 
 Document& SMILTimeContainer::document() const
 {
     return ownerSVGElement().document();
@@ skipping 20 matching lines @@
 {
     // If there's synchronization pending (most likely due to syncbases), then
     // let that complete first before attempting to schedule a frame.
     if (hasPendingSynchronization())
         return false;
     if (!isTimelineRunning())
         return false;
     return earliestFireTime.isFinite();
 }
 
-void SMILTimeContainer::updateAnimationsAndScheduleFrameIfNeeded(SMILTime elapsed, bool seekToTime)
+void SMILTimeContainer::updateAnimationsAndScheduleFrameIfNeeded(double elapsed, bool seekToTime)
 {
     if (!document().isActive())
         return;
 
     SMILTime earliestFireTime = updateAnimations(elapsed, seekToTime);
     if (!canScheduleFrame(earliestFireTime))
         return;
-    SMILTime delay = earliestFireTime - elapsed;
-    scheduleAnimationFrame(delay.value());
+    double delayTime = earliestFireTime.value() - elapsed;
+    scheduleAnimationFrame(delayTime);
 }
 
-SMILTime SMILTimeContainer::updateAnimations(SMILTime elapsed, bool seekToTime)
+SMILTime SMILTimeContainer::updateAnimations(double elapsed, bool seekToTime)
 {
     ASSERT(document().isActive());
     SMILTime earliestFireTime = SMILTime::unresolved();
 
 #if ENABLE(ASSERT)
     // 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
 
@@ skipping 83 matching lines @@
                 animDiscard->remove(IGNORE_EXCEPTION);
                 ASSERT(!animDiscard->isConnected());
             }
         }
     }
     return earliestFireTime;
 }
 
 void SMILTimeContainer::advanceFrameForTesting()
 {
-    setElapsed(elapsed().value() + initialFrameDelay);
+    setElapsed(elapsed() + initialFrameDelay);
 }
 
 DEFINE_TRACE(SMILTimeContainer)
 {
     visitor->trace(m_scheduledAnimations);
     visitor->trace(m_ownerSVGElement);
 }
 
 } // namespace blink