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);
std::unique_ptr<AnimationsVector>& scheduled = m_scheduledAnimations.add(key, nullptr).iterator->value;
if (!scheduled)
scheduled = makeUnique<AnimationsVector>();
ASSERT(!scheduled->contains(animation));
scheduled->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);
AnimationsVector* scheduled = m_scheduledAnimations.get(key);
ASSERT(scheduled);
bool removed = scheduled->removeFirst(animation);
ASSERT_UNUSED(removed, removed);
}
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::processAnimations(const AnimationsVector& animations, Function<void(SVGSMILElement*)>&& callback)
{
auto animationsCopy = animations;
for (auto* animation : animations)
callback(animation);
}
void SMILTimeContainer::processScheduledAnimations(Function<void(SVGSMILElement*)>&& callback)
{
for (auto& it : m_scheduledAnimations)
processAnimations(*it.value, WTFMove(callback));
}
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& it : m_scheduledAnimations) {
sortByPriority(*it.value, elapsed);
RefPtr<SVGSMILElement> firstAnimation;
processAnimations(*it.value, [&](auto* animation) {
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());
}
}