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_wakeupTimer(this, &SMILTimeContainer::wakeupTimerFired)
+    , m_animationPolicyOnceTimer(this, &SMILTimeContainer::animationPolicyOnceTimerFired)
     , m_ownerSVGElement(owner)
 #if ENABLE(ASSERT)
     , m_preventScheduledAnimationsChanges(false)
 #endif
 {
 }
 
 SMILTimeContainer::~SMILTimeContainer()
 {
     cancelAnimationFrame();
@@ skipping 85 matching lines @@
 }
 
 bool SMILTimeContainer::isStarted() const
 {
     return m_beginTime;
 }
 
 void SMILTimeContainer::begin()
 {
     RELEASE_ASSERT(!m_beginTime);
+
+    if (document().settings()) {
+        ImageAnimationPolicy animationPolicy = document().settings()->imageAnimationPolicy();

[fs, 2014/12/18 16:45:18]

I'd suggest you move these two into a helper function.

[je_julie(Not used), 2014/12/22 15:05:18]

Done.

+        if (animationPolicy == ImageAnimationPolicyNoAnimation)
+            return;

[fs, 2014/12/18 16:45:18]

I'm a bit worried that this will leave us in an inconsistent state. We'll also
need to guard ourselves from these DOM methods:

    void pauseAnimations();
    void unpauseAnimations();

in this case.

Should also test the behavior of the other (three IIRC) methods on SVGSVGElement
(animationsPaused, getCurrentTime, setCurrentTime) to see they work in a
reasonable way/return reasonable values.
).

[je_julie(Not used), 2014/12/22 15:05:18]

I updated new concept with considering DOM APIs.

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

[fs, 2014/12/18 16:45:18]

I suppose this is one way to implement this. It has the downside though, that if
the timeline is paused at this point it might still be possible to seek to 3
seconds. Not a big deal, and my other suggestions might help rectify that.

[je_julie(Not used), 2014/12/22 15:05:18]

Please check my new concept.

+    }
     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;
@@ skipping 38 matching lines @@
 }
 
 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;
     }
 
+    // If imageAnimationPolicy is 'once', animation is stopped at animationPolicyOnceDuration.
+    // setElapsed over animationPolicyOnceDuration is not allowed.
+    if (document().settings()) {
+        ImageAnimationPolicy animationPolicy = document().settings()->imageAnimationPolicy();
+        if (animationPolicy == ImageAnimationPolicyAnimateOnce
+            && time.value() > animationPolicyOnceDuration)
+            time = SMILTime(animationPolicyOnceDuration);

[fs, 2014/12/18 16:45:18]

Should be possible to simply do:

time = std::min(time, SMILTime(animationPolicyOnceDuration));

here.

[je_julie(Not used), 2014/12/22 15:05:18]

Please check my new concept.

+    }
+
     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;
@@ skipping 54 matching lines @@
     if (m_frameSchedulingState == FutureAnimationFrame) {
         ASSERT(isTimelineRunning());
         m_frameSchedulingState = Idle;
         serviceOnNextFrame();
     } else {
         m_frameSchedulingState = Idle;
         updateAnimationsAndScheduleFrameIfNeeded(elapsed());
     }
 }
 
+void SMILTimeContainer::animationPolicyOnceTimerFired(Timer<SMILTimeContainer>*)
+{
+    cancelAnimationFrame();

[fs, 2014/12/18 16:45:18]

I don't think is enough (see above about DOM methods). I'd suggest adding a new
method (freeze() maybe?) that pauses the timeline and then sets a flag to
'freeze' it. This flag would then be checked in appropriate places (and should
probably also be set for the 'none' case.)

BTW, to what degree/when can the policy value change? At any time?

[je_julie(Not used), 2014/12/22 15:05:18]

I added new function for freeze.

+}
+
 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
 }
 
 }