SMILTimeContainer.cpp [plain text]
#include "config.h"
#include "SMILTimeContainer.h"
#include "Document.h"
#include "ElementIterator.h"
#include "Page.h"
#include "SVGSMILElement.h"
#include "SVGSVGElement.h"
#include "ScopedEventQueue.h"
namespace WebCore {
static const Seconds SMILAnimationFrameDelay { 1_s / 60. };
static const Seconds SMILAnimationFrameThrottledDelay { 1_s / 30. };
DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(SMILTimeContainer);
SMILTimeContainer::SMILTimeContainer(SVGSVGElement& owner)
: m_timer(*this, &SMILTimeContainer::timerFired)
, m_ownerSVGElement(owner)
{
}
void SMILTimeContainer::schedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
{
ASSERT(animation->timeContainer() == this);
ASSERT(target);
ASSERT(animation->hasValidAttributeName());
ElementAttributePair key(target, attributeName);
auto& animations = m_scheduledAnimations.add(key, AnimationsVector()).iterator->value;
ASSERT(!animations.contains(animation));
animations.append(animation);
SMILTime nextFireTime = animation->nextProgressTime();
if (nextFireTime.isFinite())
notifyIntervalsChanged();
}
void SMILTimeContainer::unschedule(SVGSMILElement* animation, SVGElement* target, const QualifiedName& attributeName)
{
ASSERT(animation->timeContainer() == this);
ElementAttributePair key(target, attributeName);
auto& animations = m_scheduledAnimations.find(key)->value;
ASSERT(animations.contains(animation));
animations.removeFirst(animation);
}
void SMILTimeContainer::notifyIntervalsChanged()
{
startTimer(elapsed(), 0);
}
Seconds SMILTimeContainer::animationFrameDelay() const
{
auto* page = m_ownerSVGElement.document().page();
if (!page)
return SMILAnimationFrameDelay;
return page->isLowPowerModeEnabled() ? SMILAnimationFrameThrottledDelay : SMILAnimationFrameDelay;
}
SMILTime SMILTimeContainer::elapsed() const
{
if (!m_beginTime)
return 0_s;
if (isPaused())
return m_accumulatedActiveTime;
return MonotonicTime::now() + m_accumulatedActiveTime - m_resumeTime;
}
bool SMILTimeContainer::isActive() const
{
return !!m_beginTime && !isPaused();
}
bool SMILTimeContainer::isPaused() const
{
return !!m_pauseTime;
}
bool SMILTimeContainer::isStarted() const
{
return !!m_beginTime;
}
void SMILTimeContainer::begin()
{
ASSERT(!m_beginTime);
MonotonicTime now = MonotonicTime::now();
m_beginTime = m_resumeTime = now - m_presetStartTime;
updateAnimations(SMILTime(m_presetStartTime), m_presetStartTime ? true : false);
m_presetStartTime = 0_s;
if (m_pauseTime) {
m_pauseTime = now;
m_timer.stop();
}
}
void SMILTimeContainer::pause()
{
ASSERT(!isPaused());
m_pauseTime = MonotonicTime::now();
if (m_beginTime) {
m_accumulatedActiveTime += m_pauseTime - m_resumeTime;
m_timer.stop();
}
}
void SMILTimeContainer::resume()
{
ASSERT(isPaused());
m_resumeTime = MonotonicTime::now();
m_pauseTime = MonotonicTime();
startTimer(elapsed(), 0);
}
void SMILTimeContainer::setElapsed(SMILTime time)
{
if (!m_beginTime) {
m_presetStartTime = Seconds(time.value());
return;
}
if (m_beginTime)
m_timer.stop();
MonotonicTime now = MonotonicTime::now();
m_beginTime = now - Seconds { time.value() };
if (m_pauseTime) {
m_resumeTime = m_pauseTime = now;
m_accumulatedActiveTime = Seconds(time.value());
} else
m_resumeTime = m_beginTime;
processScheduledAnimations([](auto& animation) {
animation.reset();
});
updateAnimations(time, true);
}
void SMILTimeContainer::startTimer(SMILTime elapsed, SMILTime fireTime, SMILTime minimumDelay)
{
if (!m_beginTime || isPaused())
return;
if (!fireTime.isFinite())
return;
SMILTime delay = std::max(fireTime - elapsed, minimumDelay);
m_timer.startOneShot(1_s * delay.value());
}
void SMILTimeContainer::timerFired()
{
ASSERT(!!m_beginTime);
ASSERT(!m_pauseTime);
updateAnimations(elapsed());
}
void SMILTimeContainer::updateDocumentOrderIndexes()
{
unsigned timingElementCount = 0;
for (auto& smilElement : descendantsOfType<SVGSMILElement>(m_ownerSVGElement))
smilElement.setDocumentOrderIndex(timingElementCount++);
m_documentOrderIndexesDirty = false;
}
struct PriorityCompare {
PriorityCompare(SMILTime elapsed) : m_elapsed(elapsed) {}
bool operator()(SVGSMILElement* a, SVGSMILElement* b)
{
SMILTime aBegin = a->intervalBegin();
SMILTime bBegin = b->intervalBegin();
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;
};
void SMILTimeContainer::sortByPriority(AnimationsVector& animations, SMILTime elapsed)
{
if (m_documentOrderIndexesDirty)
updateDocumentOrderIndexes();
std::sort(animations.begin(), animations.end(), PriorityCompare(elapsed));
}
void SMILTimeContainer::processScheduledAnimations(const Function<void(SVGSMILElement&)>& callback)
{
for (auto& animations : copyToVector(m_scheduledAnimations.values())) {
for (auto* animation : animations)
callback(*animation);
}
}
void SMILTimeContainer::updateAnimations(SMILTime elapsed, bool seekToTime)
{
EventQueueScope scope;
processScheduledAnimations([](auto& animation) {
if (!animation.hasConditionsConnected())
animation.connectConditions();
});
AnimationsVector animationsToApply;
SMILTime earliestFireTime = SMILTime::unresolved();
for (auto& animations : copyToVector(m_scheduledAnimations.values())) {
sortByPriority(animations, elapsed);
RefPtr<SVGSMILElement> firstAnimation;
for (auto* animation : animations) {
ASSERT(animation->timeContainer() == this);
ASSERT(animation->targetElement());
ASSERT(animation->hasValidAttributeName());
if (!firstAnimation) {
if (!animation->hasValidAttributeType())
return;
firstAnimation = animation;
}
if (!animation->progress(elapsed, *firstAnimation, seekToTime) && firstAnimation == animation)
firstAnimation = nullptr;
SMILTime nextFireTime = animation->nextProgressTime();
if (nextFireTime.isFinite())
earliestFireTime = std::min(nextFireTime, earliestFireTime);
}
if (firstAnimation)
animationsToApply.append(firstAnimation.get());
}
for (auto& animation : animationsToApply)
animation->applyResultsToTarget();
startTimer(elapsed, earliestFireTime, animationFrameDelay());
}
}