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::animationPolicyTimerFired)
     , 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
 {
-    return m_pauseTime;
+    // If animation policy is "none", it is always paused.
+    return m_pauseTime || animationPolicy() == ImageAnimationPolicyNoAnimation;
 }
 
 bool SMILTimeContainer::isStarted() const
 {
     return m_beginTime;
 }
 
 void SMILTimeContainer::begin()
 {
     RELEASE_ASSERT(!m_beginTime);
+
+    if (!handleAnimationPolicy(RestartOnceTimerIfNotPaused))
+        return;
+
     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 11 matching lines @@
         // the wake-up mechanism.
         if (earliestFireTime.isFinite()) {
             SMILTime delay = earliestFireTime - elapsed();
             scheduleWakeUp(std::max(initialFrameDelay, delay.value()), SynchronizeAnimations);
         }
     }
 }
 
 void SMILTimeContainer::pause()
 {
+    if (!handleAnimationPolicy(CancelOnceTimer))
+        return;
+
     ASSERT(!isPaused());
     m_pauseTime = currentTime();
 
     if (m_beginTime) {
         m_accumulatedActiveTime += m_pauseTime - lastResumeTime();
         cancelAnimationFrame();
     }
     m_resumeTime = 0;
 }
 
 void SMILTimeContainer::resume()
 {
+    if (!handleAnimationPolicy(RestartOnceTimer))
+        return;
+
     ASSERT(isPaused());
     m_resumeTime = currentTime();
 
     m_pauseTime = 0;
     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;
     }
 
+    if (!handleAnimationPolicy(RestartOnceTimerIfNotPaused))
+        return;
+
     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::scheduleAnimationPolicyTimer()
+{
+    m_animationPolicyOnceTimer.startOneShot(animationPolicyOnceDuration, FROM_HERE);
+}
+
+void SMILTimeContainer::cancelAnimationPolicyTimer()
+{
+    if (m_animationPolicyOnceTimer.isActive())
+        m_animationPolicyOnceTimer.stop();
+}
+
+void SMILTimeContainer::animationPolicyTimerFired(Timer<SMILTimeContainer>*)
+{
+    pause();
+}
+
+ImageAnimationPolicy SMILTimeContainer::animationPolicy() const
+{
+    Settings* settings = document().settings();
+    if (!settings)
+        return ImageAnimationPolicyAllowed;
+
+    return settings->imageAnimationPolicy();
+}
+
+bool SMILTimeContainer::handleAnimationPolicy(AnimationPolicyOnceAction onceAction)
+{
+    ImageAnimationPolicy policy = animationPolicy();
+    // If the animation policy is "none", control is not allowed.
+    // returns false to exit flow.
+    if (policy == ImageAnimationPolicyNoAnimation)
+        return false;
+    // If the animation policy is "once",
+    if (policy == ImageAnimationPolicyAnimateOnce) {
+        switch (onceAction) {
+        case RestartOnceTimerIfNotPaused:
+            if (isPaused())
+                break;
+            /* fall through */
+        case RestartOnceTimer:
+            scheduleAnimationPolicyTimer();
+            break;
+        case CancelOnceTimer:
+            cancelAnimationPolicyTimer();
+            break;
+        default:

[fs, 2014/12/27 15:36:35]

Shouldn't need this (all values are handled.)

[je_julie(Not used), 2014/12/28 05:50:26]

Done.

+            break;
+        }
+    }
+    return true;
+}
+
 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
 }
 
 }