Drive SVG Animations via requestAnimationFrame

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 
 #include "core/dom/ElementTraversal.h"
+#include "core/frame/FrameView.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/animation/SVGSMILElement.h"
 #include "wtf/CurrentTime.h"
 
 using namespace std;
 
 namespace WebCore {
 
-static const double animationFrameDelay = 0.025;
+// Blatantly copied from core/animation/DocumentTimeline.cpp.
+static const double minimumDelay = 0.04;

[pdr., 2014/03/03 17:47:33]

Can you use DocumentTimeline::s_minimumDelay directly instead of copying it?

[dstockwell, 2014/03/04 01:19:04]

I'm OK with this duplication for now, but this logic (schedule-frame-after-time)
should likely be pushed up to PageAnimator at some point.

[fs, 2014/03/04 10:28:19]

I suppose we can trade this two line hack for a one-line hack
(friend-declaration in DocumentTimeline). I do hope we'll be able to consolidate
and converge reasonably quickly here though. Unifying this sounds reasonable.

 
 SMILTimeContainer::SMILTimeContainer(SVGSVGElement* owner)
     : m_beginTime(0)
     , m_pauseTime(0)
     , m_resumeTime(0)
     , m_accumulatedActiveTime(0)
     , m_presetStartTime(0)
     , m_documentOrderIndexesDirty(false)
-    , m_timer(this, &SMILTimeContainer::timerFired)
+    , m_framePending(false)
+    , m_clockFrozen(false)

[pdr., 2014/03/03 17:47:33]

I'm wary of adding more clock-related state to this already complex state
machine. Unfortunately I tried to combine m_clockFrozen into another variable
and I don't see an easy way to do it.

Can you think of a way to simplify this? I'm happy if we need it but I'd like to
avoid more state if possible.

[fs, 2014/03/04 10:28:19]

I will try to formalize this somewhat - probably by migrating to AnimationClock,
and either extend it or inherit from it (preferably the former). I'd really like
to come up with a long-term solution for this though...

+    , m_wakeupTimer(this, &SMILTimeContainer::wakeupTimerFired)
     , m_ownerSVGElement(owner)
 #ifndef NDEBUG
     , m_preventScheduledAnimationsChanges(false)
 #endif
 {
 }
 
 SMILTimeContainer::~SMILTimeContainer()
 {
     cancelAnimationFrame();
-    ASSERT(!m_timer.isActive());
+    ASSERT(!m_wakeupTimer.isActive());
 #ifndef NDEBUG
     ASSERT(!m_preventScheduledAnimationsChanges);
 #endif
 }
 
 void SMILTimeContainer::schedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
 {
     ASSERT(animation->timeContainer() == this);
     ASSERT(target);
     ASSERT(animation->hasValidAttributeName());
@@ skipping 23 matching lines @@
 #endif
 
     ElementAttributePair key(target, attributeName);
     AnimationsVector* scheduled = m_scheduledAnimations.get(key);
     ASSERT(scheduled);
     size_t idx = scheduled->find(animation);
     ASSERT(idx != kNotFound);
     scheduled->remove(idx);
 }
 
+bool SMILTimeContainer::hasAnimations() const
+{
+    return !m_scheduledAnimations.isEmpty();
+}
+
 void SMILTimeContainer::notifyIntervalsChanged()
 {
     // Schedule updateAnimations() to be called asynchronously so multiple intervals
     // can change with updateAnimations() only called once at the end.
     scheduleAnimationFrame();
 }
 
 SMILTime SMILTimeContainer::elapsed() const
 {
-    if (!m_beginTime)
+    if (!m_beginTime || m_clockFrozen)
         return 0;
 
     if (isPaused())
         return m_accumulatedActiveTime;
 
     return currentTime() + m_accumulatedActiveTime - lastResumeTime();
 }
 
 bool SMILTimeContainer::isPaused() const
 {
     return m_pauseTime;
 }
 
 bool SMILTimeContainer::isStarted() const
 {
     return m_beginTime;
 }
 
 void SMILTimeContainer::begin()
 {
     ASSERT(!m_beginTime);
     double now = currentTime();
 
     // 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;
-    updateAnimations(SMILTime(m_presetStartTime), m_presetStartTime ? true : false);
+    bool hadPresetStartTime = m_presetStartTime ? true : false;
+    updateAnimations(SMILTime(m_presetStartTime), hadPresetStartTime);
     m_presetStartTime = 0;
 
     if (m_pauseTime) {
         m_pauseTime = now;
         cancelAnimationFrame();
+    } else {
+        m_clockFrozen = !hadPresetStartTime;
     }
 }
 
 void SMILTimeContainer::pause()
 {
     ASSERT(!isPaused());
     m_pauseTime = currentTime();
 
     if (m_beginTime) {
         m_accumulatedActiveTime += m_pauseTime - lastResumeTime();
         cancelAnimationFrame();
     }
     m_resumeTime = 0;
+    m_clockFrozen = false;
 }
 
 void SMILTimeContainer::resume()
 {
     ASSERT(isPaused());
     m_resumeTime = currentTime();
 
     m_pauseTime = 0;
     scheduleAnimationFrame();
+    m_clockFrozen = false;
 }
 
 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;
     }
 
+    m_clockFrozen = false;
+
     if (m_beginTime)

[pdr., 2014/03/03 17:47:33]

How did this if statement get here? :P

[fs, 2014/03/04 10:28:19]

Magic? =P

Maybe it should've been some other condition... I'll just drop it for now.

         cancelAnimationFrame();
 
     double now = currentTime();
     m_beginTime = now - time.value();
     m_resumeTime = 0;
     if (m_pauseTime) {
         m_pauseTime = now;
         m_accumulatedActiveTime = time.value();
     } else {
         m_accumulatedActiveTime = 0;
     }
 
 #ifndef NDEBUG
     m_preventScheduledAnimationsChanges = true;
 #endif
     GroupedAnimationsMap::iterator end = m_scheduledAnimations.end();
     for (GroupedAnimationsMap::iterator it = m_scheduledAnimations.begin(); it != end; ++it) {
         AnimationsVector* scheduled = it->value.get();
         unsigned size = scheduled->size();
         for (unsigned n = 0; n < size; n++)
             scheduled->at(n)->reset();
     }
 #ifndef NDEBUG
     m_preventScheduledAnimationsChanges = false;
 #endif
 
     updateAnimations(time, true);
 }
 
 bool SMILTimeContainer::isTimelineRunning() const

[pdr., 2014/03/03 17:47:33]

Should this have m_clockFrozen too?

[fs, 2014/03/04 10:28:19]

I don't think so. The clock being frozen does not imply that the timeline isn't
running.

 {
     return m_beginTime && !isPaused();
 }
 
 void SMILTimeContainer::scheduleAnimationFrame(SMILTime fireTime)
 {
     if (!isTimelineRunning())
         return;
 
     if (!fireTime.isFinite())
         return;
 
-    SMILTime delay = max(fireTime - elapsed(), SMILTime(animationFrameDelay));
-    m_timer.startOneShot(delay.value());
+    SMILTime delay = fireTime - elapsed();
+    if (delay.value() < minimumDelay)
+        serviceOnNextFrame();
+    else
+        m_wakeupTimer.startOneShot(delay.value() - minimumDelay);
 }
 
 void SMILTimeContainer::scheduleAnimationFrame()
 {
     if (!isTimelineRunning())
         return;
 
-    m_timer.startOneShot(0);
+    // Could also schedule a wakeup at +0 seconds, but that could still
+    // potentially race with the servicing of the next frame.
+    serviceOnNextFrame();
 }
 
 void SMILTimeContainer::cancelAnimationFrame()
 {
-    m_timer.stop();
+    m_framePending = false;
+    m_wakeupTimer.stop();
 }
 
-void SMILTimeContainer::timerFired(Timer<SMILTimeContainer>*)
+void SMILTimeContainer::wakeupTimerFired(Timer<SMILTimeContainer>*)
 {
     ASSERT(isTimelineRunning());
-    updateAnimations(elapsed());
+    serviceOnNextFrame();
 }
 
 void SMILTimeContainer::updateDocumentOrderIndexes()
 {
     unsigned timingElementCount = 0;
     for (Element* element = m_ownerSVGElement; element; element = ElementTraversal::next(*element, m_ownerSVGElement)) {
         if (isSVGSMILElement(*element))
             toSVGSMILElement(element)->setDocumentOrderIndex(timingElementCount++);
     }
     m_documentOrderIndexesDirty = false;
 }
 
 struct PriorityCompare {
     PriorityCompare(SMILTime elapsed) : m_elapsed(elapsed) {}
     bool operator()(const RefPtr<SVGSMILElement>& a, const RefPtr<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;
 };
 
+Document& SMILTimeContainer::document() const
+{
+    ASSERT(m_ownerSVGElement);
+    return m_ownerSVGElement->document();
+}
+
+void SMILTimeContainer::serviceOnNextFrame()
+{
+    if (document().view()) {
+        document().view()->scheduleAnimation();
+        m_framePending = true;
+    }
+}
+
+void SMILTimeContainer::serviceAnimations(double monotonicAnimationStartTime)

[dstockwell, 2014/03/04 01:19:04]

This patch just moves updates to be driven by the frame callback, but does not
use the frame times yet? Is that planned?

[fs, 2014/03/04 10:28:19]

Yes, I plan to that in follow up CLs. Had originally thought that I might be
able to make use of it here directly (in this CL), but figured it might just be
"too much" at the same time. If it ends up being unused I'll de-plumb it and
move it to a/the later CL.

+{
+    if (!m_framePending)
+        return;
+
+    m_framePending = false;
+    updateAnimations(elapsed());
+    m_clockFrozen = false;
+}
+
 void SMILTimeContainer::updateAnimations(SMILTime elapsed, bool seekToTime)
 {
     SMILTime earliestFireTime = SMILTime::unresolved();
 
 #ifndef NDEBUG
     // 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 72 matching lines @@
 
             if (animDiscard->inDocument()) {
                 animDiscard->remove(IGNORE_EXCEPTION);
                 ASSERT(!animDiscard->inDocument());
             }
         }
     }
 }
 
 }