Tweaks and fixes to the SMILTimeContainer frame scheduling logic

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 19 matching lines @@
 #include "core/animation/DocumentTimeline.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/frame/FrameView.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/animation/SVGSMILElement.h"
 
 using namespace std;
 
 namespace WebCore {
 
+static const double initialFrameDelay = 0.025;
+
 // Every entry-point that calls updateAnimations() should instantiate a
 // DiscardScope to prevent deletion of the ownerElement (and hence itself.)
 class DiscardScope {
 public:
     explicit DiscardScope(SVGSVGElement& timeContainerOwner) : m_discardScopeElement(&timeContainerOwner) { }
 
 private:
     RefPtr<SVGSVGElement> m_discardScopeElement;
 };
 
@@ skipping 59 matching lines @@
     size_t idx = scheduled->find(animation);
     ASSERT(idx != kNotFound);
     scheduled->remove(idx);
 }
 
 bool SMILTimeContainer::hasAnimations() const
 {
     return !m_scheduledAnimations.isEmpty();
 }
 
+bool SMILTimeContainer::hasPendingSynchronization() const
+{
+    return m_frameSchedulingState == SynchronizeAnimations && m_wakeupTimer.isActive() && !m_wakeupTimer.nextFireInterval();
+}
+
 void SMILTimeContainer::notifyIntervalsChanged()
 {
     if (!isStarted())
         return;
     // Schedule updateAnimations() to be called asynchronously so multiple intervals
     // can change with updateAnimations() only called once at the end.
-    if (m_frameSchedulingState == SynchronizeAnimations && m_wakeupTimer.isActive() && !m_wakeupTimer.nextFireInterval())
+    if (hasPendingSynchronization())
         return;
     cancelAnimationFrame();
     scheduleWakeUp(0, SynchronizeAnimations);
 }
 
 SMILTime SMILTimeContainer::elapsed() const
 {
     if (!m_beginTime)
         return 0;
 
@@ skipping 20 matching lines @@
 
     // If 'm_presetStartTime' is set, the timeline was modified via setElapsed() before the document began.
     // In this case pass on 'seekToTime=true' to updateAnimations().
     m_beginTime = now - m_presetStartTime;
     DiscardScope discardScope(m_ownerSVGElement);
     SMILTime earliestFireTime = updateAnimations(SMILTime(m_presetStartTime), m_presetStartTime ? true : false);
     m_presetStartTime = 0;
 
     if (m_pauseTime) {
         m_pauseTime = now;
-        cancelAnimationFrame();
-    } else {
+        // If updateAnimations() caused new syncbase instance to be generated,
+        // we don't want to cancel those. Excepting that, no frame should've
+        // been scheduled at this point.
+        ASSERT(m_frameSchedulingState == Idle || m_frameSchedulingState == SynchronizeAnimations);
+    } else if (!hasPendingSynchronization()) {
         ASSERT(isTimelineRunning());
         // If the timeline is running, and there's pending animation updates,
         // always perform the first update after the timeline was started using
         // the wake-up mechanism.
         if (earliestFireTime.isFinite()) {
-            scheduleWakeUp(DocumentTimeline::s_minimumDelay, SynchronizeAnimations);
+            SMILTime delay = earliestFireTime - elapsed();
+            scheduleWakeUp(std::max(initialFrameDelay, delay.value()), SynchronizeAnimations);
         }
     }
 }
 
 void SMILTimeContainer::pause()
 {
     ASSERT(!isPaused());
     m_pauseTime = currentTime();
 
     if (m_beginTime) {
         m_accumulatedActiveTime += m_pauseTime - lastResumeTime();
         cancelAnimationFrame();
     }
     m_resumeTime = 0;
 }
 
 void SMILTimeContainer::resume()
 {
     ASSERT(isPaused());
     m_resumeTime = currentTime();
 
     m_pauseTime = 0;
-    serviceOnNextFrame();
+    scheduleWakeUp(0, SynchronizeAnimations);
 }
 
 void SMILTimeContainer::setElapsed(SMILTime time)
 {
     // If the documment didn't begin yet, record a new start time, we'll seek to once its possible.
     if (!m_beginTime) {
         m_presetStartTime = time.value();
         return;
     }
 
@@ skipping 28 matching lines @@
 }
 
 bool SMILTimeContainer::isTimelineRunning() const
 {
     return m_beginTime && !isPaused();
 }
 
 void SMILTimeContainer::scheduleAnimationFrame(SMILTime fireTime)
 {
     ASSERT(isTimelineRunning() && fireTime.isFinite());
+    ASSERT(!m_wakeupTimer.isActive());
 
     SMILTime delay = fireTime - elapsed();
     if (delay.value() < DocumentTimeline::s_minimumDelay) {
         serviceOnNextFrame();
     } else {
-        scheduleWakeUp(delay.value() - DocumentTimeline::s_minimumDelay, AnimationFrame);
+        scheduleWakeUp(delay.value() - DocumentTimeline::s_minimumDelay, FutureAnimationFrame);
     }
 }
 
 void SMILTimeContainer::cancelAnimationFrame()
 {
     m_frameSchedulingState = Idle;
     m_wakeupTimer.stop();
 }
 
 void SMILTimeContainer::scheduleWakeUp(double delayTime, FrameSchedulingState frameSchedulingState)
 {
-    ASSERT(frameSchedulingState != Idle);
+    ASSERT(frameSchedulingState == SynchronizeAnimations || frameSchedulingState == FutureAnimationFrame);
     m_wakeupTimer.startOneShot(delayTime, FROM_HERE);
     m_frameSchedulingState = frameSchedulingState;
 }
 
 void SMILTimeContainer::wakeupTimerFired(Timer<SMILTimeContainer>*)
 {
-    if (m_frameSchedulingState == AnimationFrame) {
+    ASSERT(m_frameSchedulingState == SynchronizeAnimations || m_frameSchedulingState == FutureAnimationFrame);
+    if (m_frameSchedulingState == FutureAnimationFrame) {
         ASSERT(isTimelineRunning());
         m_frameSchedulingState = Idle;
         serviceOnNextFrame();
     } else {
-        ASSERT(m_frameSchedulingState == SynchronizeAnimations);
         m_frameSchedulingState = Idle;
         DiscardScope discardScope(m_ownerSVGElement);
         updateAnimationsAndScheduleFrameIfNeeded(elapsed());
     }
 }
 
 void SMILTimeContainer::updateDocumentOrderIndexes()
 {
     unsigned timingElementCount = 0;
     for (SVGSMILElement* element = Traversal<SVGSMILElement>::firstWithin(m_ownerSVGElement); element; element = Traversal<SVGSMILElement>::next(*element, &m_ownerSVGElement))
@@ skipping 50 matching lines @@
     m_frameSchedulingState = Idle;
     animationClock().updateTime(monotonicAnimationStartTime);
     DiscardScope discardScope(m_ownerSVGElement);
     updateAnimationsAndScheduleFrameIfNeeded(elapsed());
     animationClock().unfreeze();
 }
 
 void SMILTimeContainer::updateAnimationsAndScheduleFrameIfNeeded(SMILTime elapsed, bool seekToTime)
 {
     SMILTime earliestFireTime = updateAnimations(elapsed, seekToTime);
+    // If updateAnimations() ended up triggering a synchronization (most likely
+    // via syncbases), then give that priority.
+    if (hasPendingSynchronization())
+        return;
+
     if (!isTimelineRunning())
         return;
 
     if (!earliestFireTime.isFinite())
         return;
 
     scheduleAnimationFrame(earliestFireTime);
 }
 
 SMILTime SMILTimeContainer::updateAnimations(SMILTime elapsed, bool seekToTime)
@@ skipping 79 matching lines @@
             if (animDiscard->inDocument()) {
                 animDiscard->remove(IGNORE_EXCEPTION);
                 ASSERT(!animDiscard->inDocument());
             }
         }
     }
     return earliestFireTime;
 }
 
 }