AnimationPolicy setting is applied to SVG animation.

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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 
 #include "core/animation/AnimationClock.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/frame/FrameView.h"
+#include "core/frame/Settings.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/animation/SVGSMILElement.h"
 
 namespace blink {
 
 static const double initialFrameDelay = 0.025;
+static const double animationPolicyOnceDuration = 3.000;
 
 #if !ENABLE(OILPAN)
 // 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;
 };
 #endif
 
 SMILTimeContainer::SMILTimeContainer(SVGSVGElement& owner)
     : m_beginTime(0)
     , m_pauseTime(0)
     , m_resumeTime(0)
     , m_accumulatedActiveTime(0)
     , m_presetStartTime(0)
     , m_frameSchedulingState(Idle)
     , m_documentOrderIndexesDirty(false)
+    , m_animationState(NormalState)
     , m_wakeupTimer(this, &SMILTimeContainer::wakeupTimerFired)
+    , m_animationPolicyOnceTimer(this, &SMILTimeContainer::animationPolicyOnceTimerFired)
     , m_ownerSVGElement(owner)
 #if ENABLE(ASSERT)
     , m_preventScheduledAnimationsChanges(false)
 #endif
 {
 }
 
 SMILTimeContainer::~SMILTimeContainer()
 {
     cancelAnimationFrame();
+    cancelAnimationPolicyTimer();
     ASSERT(!m_wakeupTimer.isActive());
 #if ENABLE(ASSERT)
     ASSERT(!m_preventScheduledAnimationsChanges);
 #endif
 }
 
 void SMILTimeContainer::schedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
 {
     ASSERT(animation->timeContainer() == this);
     ASSERT(target);
@@ skipping 64 matching lines @@
         return 0;
 
     if (isPaused())
         return m_accumulatedActiveTime;
 
     return currentTime() + m_accumulatedActiveTime - lastResumeTime();
 }
 
 bool SMILTimeContainer::isPaused() const
 {
+    if (ImageAnimationPolicyNoAnimation == getAnimationPolicy())

[fs, 2014/12/22 16:23:14]

I'd prefer if we could reuse existing state as much as possible.

Also please don't write "yoda conditions".

[je_julie(Not used), 2014/12/24 03:50:51]

Done.

+        return true;
     return m_pauseTime;
 }
 
+bool SMILTimeContainer::isFrozen() const
+{
+    return m_animationState == FrozenState;
+}
+
 bool SMILTimeContainer::isStarted() const
 {
     return m_beginTime;
 }
 
+ImageAnimationPolicy SMILTimeContainer::getAnimationPolicy() const
+{
+    Settings* settings = document().settings();
+    if (!settings)
+        return ImageAnimationPolicyAllowed;
+
+    ImageAnimationPolicy animationPolicy = settings->imageAnimationPolicy();

[fs, 2014/12/22 16:23:14]

Nit: Return this directly.

[je_julie(Not used), 2014/12/24 03:50:51]

done.

+    return animationPolicy;
+}
+
+void SMILTimeContainer::freezeTimeline()
+{
+    pause(true);

[fs, 2014/12/22 16:23:14]

Could we structure this do a state-transition before/after calling pause() and
not add this parameter to pause()?

[je_julie(Not used), 2014/12/24 03:50:51]

I removed it with improved concept.

+}
+
+void SMILTimeContainer::cancelAnimationPolicyTimer()
+{
+    if (m_animationPolicyOnceTimer.isActive())
+        m_animationPolicyOnceTimer.stop();
+}
+
+void SMILTimeContainer::startAnimationPolicyTimer()
+{
+    m_animationState &= ~FrozenState;
+    m_animationPolicyOnceTimer.startOneShot(animationPolicyOnceDuration, FROM_HERE);
+}
+
 void SMILTimeContainer::begin()
 {
     RELEASE_ASSERT(!m_beginTime);
+
+    ImageAnimationPolicy animationPolicy = getAnimationPolicy();
+    if (animationPolicy == ImageAnimationPolicyNoAnimation)
+        return freezeTimeline();

[fs, 2014/12/22 16:23:15]

This looks like a very complicated way to return doing nothing =)
(freezeTimeline callas pause which returns based on this same conditional.)

[je_julie(Not used), 2014/12/24 03:50:51]

I removed it with improved concept.

+
+    // Repeating behavior is not well-defined for SMIL/SVG animations
+    // We define "once" as "play for animationPolicyOnceDuration seconds" here instead.
+    if (animationPolicy == ImageAnimationPolicyAnimateOnce)
+        startAnimationPolicyTimer();

[fs, 2014/12/22 16:23:14]

Shouldn't this interact with pause in some way? (See m_pauseTime branch below.)

[je_julie(Not used), 2014/12/24 03:50:51]

I updated code with paused condition.

+
     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;
 #if !ENABLE(OILPAN)
     DiscardScope discardScope(m_ownerSVGElement);
 #endif
     SMILTime earliestFireTime = updateAnimations(SMILTime(m_presetStartTime), m_presetStartTime ? true : false);
     m_presetStartTime = 0;
 
     if (m_pauseTime) {
         m_pauseTime = now;
         // 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()) {
             SMILTime delay = earliestFireTime - elapsed();
             scheduleWakeUp(std::max(initialFrameDelay, delay.value()), SynchronizeAnimations);
         }
     }
 }
 
-void SMILTimeContainer::pause()
+void SMILTimeContainer::pause(bool freeze)
 {
-    ASSERT(!isPaused());
+    if (ImageAnimationPolicyNoAnimation == getAnimationPolicy())
+        return;
+
+    ASSERT(!isPaused() || isFrozen());
+
+    if (freeze)
+        m_animationState |= FrozenState;
+    else
+        m_animationState |= PausedState;
     m_pauseTime = currentTime();
 
     if (m_beginTime) {
         m_accumulatedActiveTime += m_pauseTime - lastResumeTime();
         cancelAnimationFrame();
     }
     m_resumeTime = 0;
+
+    // Cancel the animation policy timer.
+    cancelAnimationPolicyTimer();
 }
 
 void SMILTimeContainer::resume()
 {
+    if (ImageAnimationPolicyNoAnimation == getAnimationPolicy())
+        return;
+
     ASSERT(isPaused());
+
+    m_animationState &= ~PausedState;
     m_resumeTime = currentTime();
 
     m_pauseTime = 0;
     scheduleWakeUp(0, SynchronizeAnimations);
+
+    // Start the animation policy timer.
+    startAnimationPolicyTimer();
 }
 
 void SMILTimeContainer::setElapsed(SMILTime time)
 {
+    // If imageAnimationPolicy is 'once' or 'none',
+    // none: setElapsed is not allowed.
+    // once: paused state - setElapsed.
+    //       unpaused state - start animation policy timer and setElapsed.
+    ImageAnimationPolicy animationPolicy = getAnimationPolicy();
+    if (animationPolicy == ImageAnimationPolicyNoAnimation)
+        return;
+    if (animationPolicy == ImageAnimationPolicyAnimateOnce) {
+        if (!(m_animationState & PausedState)) {
+            if (m_animationState & FrozenState)
+                resume();
+            startAnimationPolicyTimer();
+        }
+    }
+
     // 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;
     }
 
     cancelAnimationFrame();
 
     double now = currentTime();
     m_beginTime = now - time.value();
@@ skipping 60 matching lines @@
     if (m_frameSchedulingState == FutureAnimationFrame) {
         ASSERT(isTimelineRunning());
         m_frameSchedulingState = Idle;
         serviceOnNextFrame();
     } else {
         m_frameSchedulingState = Idle;
         updateAnimationsAndScheduleFrameIfNeeded(elapsed());
     }
 }
 
+void SMILTimeContainer::animationPolicyOnceTimerFired(Timer<SMILTimeContainer>*)
+{
+    freezeTimeline();
+}
+
 void SMILTimeContainer::updateDocumentOrderIndexes()
 {
     unsigned timingElementCount = 0;
     for (SVGSMILElement& element : Traversal<SVGSMILElement>::descendantsOf(m_ownerSVGElement))
         element.setDocumentOrderIndex(timingElementCount++);
     m_documentOrderIndexesDirty = false;
 }
 
 struct PriorityCompare {
     PriorityCompare(SMILTime elapsed) : m_elapsed(elapsed) {}
@@ skipping 157 matching lines @@
 }
 
 void SMILTimeContainer::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_scheduledAnimations);
 #endif
 }
 
 }