CSSAnimationController.cpp [plain text]
#include "config.h"
#include "CSSAnimationController.h"
#include "AnimationBase.h"
#include "AnimationEvent.h"
#include "CSSAnimationControllerPrivate.h"
#include "CSSPropertyAnimation.h"
#include "CSSPropertyParser.h"
#include "CompositeAnimation.h"
#include "EventNames.h"
#include "Frame.h"
#include "FrameView.h"
#include "Logging.h"
#include "PseudoElement.h"
#include "RenderView.h"
#include "TransitionEvent.h"
#include "WebKitAnimationEvent.h"
#include "WebKitTransitionEvent.h"
#include <wtf/CurrentTime.h>
namespace WebCore {
static const Seconds animationTimerDelay { 15_ms };
static const Seconds animationTimerThrottledDelay { 30_ms };
class AnimationPrivateUpdateBlock {
public:
AnimationPrivateUpdateBlock(CSSAnimationControllerPrivate& animationController)
: m_animationController(animationController)
{
m_animationController.beginAnimationUpdate();
}
~AnimationPrivateUpdateBlock()
{
m_animationController.endAnimationUpdate();
}
CSSAnimationControllerPrivate& m_animationController;
};
CSSAnimationControllerPrivate::CSSAnimationControllerPrivate(Frame& frame)
: m_animationTimer(*this, &CSSAnimationControllerPrivate::animationTimerFired)
, m_updateStyleIfNeededDispatcher(*this, &CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
, m_frame(frame)
, m_beginAnimationUpdateCount(0)
, m_waitingForAsyncStartNotification(false)
, m_allowsNewAnimationsWhileSuspended(false)
{
}
CSSAnimationControllerPrivate::~CSSAnimationControllerPrivate() = default;
CompositeAnimation& CSSAnimationControllerPrivate::ensureCompositeAnimation(Element& element)
{
element.setHasCSSAnimation();
auto result = m_compositeAnimations.ensure(&element, [&] {
return CompositeAnimation::create(*this);
});
if (animationsAreSuspendedForDocument(&element.document()))
result.iterator->value->suspendAnimations();
return *result.iterator->value;
}
bool CSSAnimationControllerPrivate::clear(Element& element)
{
ASSERT(element.hasCSSAnimation() == m_compositeAnimations.contains(&element));
if (!element.hasCSSAnimation())
return false;
element.clearHasCSSAnimation();
auto it = m_compositeAnimations.find(&element);
if (it == m_compositeAnimations.end())
return false;
LOG(Animations, "CSSAnimationControllerPrivate %p clear: %p", this, &element);
m_eventsToDispatch.removeAllMatching([&] (const EventToDispatch& info) {
return info.element.ptr() == &element;
});
m_elementChangesToDispatch.removeAllMatching([&](auto& currentElement) {
return currentElement.ptr() == &element;
});
auto& animation = *it->value;
bool result = animation.isSuspended();
animation.clearElement();
m_compositeAnimations.remove(it);
return result;
}
std::optional<Seconds> CSSAnimationControllerPrivate::updateAnimations(SetChanged callSetChanged)
{
AnimationPrivateUpdateBlock updateBlock(*this);
std::optional<Seconds> timeToNextService;
bool calledSetChanged = false;
for (auto& compositeAnimation : m_compositeAnimations) {
CompositeAnimation& animation = *compositeAnimation.value;
if (!animation.isSuspended() && animation.hasAnimations()) {
std::optional<Seconds> t = animation.timeToNextService();
if (t && (!timeToNextService || t.value() < timeToNextService.value()))
timeToNextService = t.value();
if (timeToNextService && timeToNextService.value() == 0_s) {
if (callSetChanged != CallSetChanged)
break;
Element& element = *compositeAnimation.key;
ASSERT(element.document().pageCacheState() == Document::NotInPageCache);
element.invalidateStyleAndLayerComposition();
calledSetChanged = true;
}
}
}
if (calledSetChanged)
m_frame.document()->updateStyleIfNeeded();
return timeToNextService;
}
void CSSAnimationControllerPrivate::updateAnimationTimerForElement(Element& element)
{
std::optional<Seconds> timeToNextService;
const CompositeAnimation* compositeAnimation = m_compositeAnimations.get(&element);
if (!compositeAnimation->isSuspended() && compositeAnimation->hasAnimations())
timeToNextService = compositeAnimation->timeToNextService();
if (!timeToNextService)
return;
if (m_animationTimer.isActive() && (m_animationTimer.repeatInterval() || m_animationTimer.nextFireInterval() <= timeToNextService.value()))
return;
m_animationTimer.startOneShot(timeToNextService.value());
}
void CSSAnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged)
{
std::optional<Seconds> timeToNextService = updateAnimations(callSetChanged);
LOG(Animations, "updateAnimationTimer: timeToNextService is %.2f", timeToNextService.value_or(Seconds { -1 }).value());
if (!timeToNextService) {
if (m_animationTimer.isActive())
m_animationTimer.stop();
return;
}
if (!timeToNextService.value()) {
auto* page = m_frame.page();
bool shouldThrottle = page && page->isLowPowerModeEnabled();
Seconds delay = shouldThrottle ? animationTimerThrottledDelay : animationTimerDelay;
if (!m_animationTimer.isActive() || m_animationTimer.repeatInterval() != delay)
m_animationTimer.startRepeating(delay);
return;
}
m_animationTimer.startOneShot(timeToNextService.value());
}
void CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired()
{
fireEventsAndUpdateStyle();
}
void CSSAnimationControllerPrivate::fireEventsAndUpdateStyle()
{
Ref<Frame> protector(m_frame);
bool updateStyle = !m_eventsToDispatch.isEmpty() || !m_elementChangesToDispatch.isEmpty();
Vector<EventToDispatch> eventsToDispatch = WTFMove(m_eventsToDispatch);
for (auto& event : eventsToDispatch) {
Element& element = event.element;
if (event.eventType == eventNames().transitionendEvent)
element.dispatchEvent(TransitionEvent::create(event.eventType, event.name, event.elapsedTime, PseudoElement::pseudoElementNameForEvents(element.pseudoId())));
else
element.dispatchEvent(AnimationEvent::create(event.eventType, event.name, event.elapsedTime));
}
for (auto& change : m_elementChangesToDispatch)
change->invalidateStyleAndLayerComposition();
m_elementChangesToDispatch.clear();
if (updateStyle)
m_frame.document()->updateStyleIfNeeded();
}
void CSSAnimationControllerPrivate::startUpdateStyleIfNeededDispatcher()
{
if (!m_updateStyleIfNeededDispatcher.isActive())
m_updateStyleIfNeededDispatcher.startOneShot(0_s);
}
void CSSAnimationControllerPrivate::addEventToDispatch(Element& element, const AtomicString& eventType, const String& name, double elapsedTime)
{
m_eventsToDispatch.append({ element, eventType, name, elapsedTime });
startUpdateStyleIfNeededDispatcher();
}
void CSSAnimationControllerPrivate::addElementChangeToDispatch(Element& element)
{
m_elementChangesToDispatch.append(element);
ASSERT(m_elementChangesToDispatch.last()->document().pageCacheState() == Document::NotInPageCache);
startUpdateStyleIfNeededDispatcher();
}
void CSSAnimationControllerPrivate::animationFrameCallbackFired()
{
std::optional<Seconds> timeToNextService = updateAnimations(CallSetChanged);
if (timeToNextService)
m_frame.document()->view()->scheduleAnimation();
}
void CSSAnimationControllerPrivate::animationTimerFired()
{
Ref<Frame> protector(m_frame);
if (m_requiresLayout) {
if (auto* frameView = m_frame.document()->view()) {
if (frameView->needsLayout())
frameView->forceLayout();
}
m_requiresLayout = false;
}
AnimationPrivateUpdateBlock updateBlock(*this);
updateAnimationTimer(CallSetChanged);
fireEventsAndUpdateStyle();
}
bool CSSAnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
{
if (!renderer.element())
return false;
auto* animation = m_compositeAnimations.get(renderer.element());
if (!animation)
return false;
return animation->isAnimatingProperty(property, false, runningState);
}
bool CSSAnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
{
if (!renderer.element())
return false;
auto* animation = m_compositeAnimations.get(renderer.element());
if (!animation)
return false;
return animation->isAnimatingProperty(property, true, runningState);
}
void CSSAnimationControllerPrivate::updateThrottlingState()
{
updateAnimationTimer();
for (auto* childFrame = m_frame.tree().firstChild(); childFrame; childFrame = childFrame->tree().nextSibling())
childFrame->animation().updateThrottlingState();
}
Seconds CSSAnimationControllerPrivate::animationInterval() const
{
if (!m_animationTimer.isActive())
return Seconds { INFINITY };
return Seconds { m_animationTimer.repeatInterval() };
}
void CSSAnimationControllerPrivate::suspendAnimations()
{
if (isSuspended())
return;
suspendAnimationsForDocument(m_frame.document());
for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
child->animation().suspendAnimations();
m_isSuspended = true;
}
void CSSAnimationControllerPrivate::resumeAnimations()
{
if (!isSuspended())
return;
resumeAnimationsForDocument(m_frame.document());
for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
child->animation().resumeAnimations();
m_isSuspended = false;
}
bool CSSAnimationControllerPrivate::animationsAreSuspendedForDocument(Document* document)
{
return isSuspended() || m_suspendedDocuments.contains(document);
}
void CSSAnimationControllerPrivate::detachFromDocument(Document* document)
{
m_suspendedDocuments.remove(document);
}
void CSSAnimationControllerPrivate::suspendAnimationsForDocument(Document* document)
{
if (animationsAreSuspendedForDocument(document))
return;
m_suspendedDocuments.add(document);
AnimationPrivateUpdateBlock updateBlock(*this);
for (auto& animation : m_compositeAnimations) {
if (&animation.key->document() == document)
animation.value->suspendAnimations();
}
updateAnimationTimer();
}
void CSSAnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
{
if (!animationsAreSuspendedForDocument(document))
return;
detachFromDocument(document);
AnimationPrivateUpdateBlock updateBlock(*this);
for (auto& animation : m_compositeAnimations) {
if (&animation.key->document() == document)
animation.value->resumeAnimations();
}
updateAnimationTimer();
}
void CSSAnimationControllerPrivate::startAnimationsIfNotSuspended(Document* document)
{
if (!animationsAreSuspendedForDocument(document) || allowsNewAnimationsWhileSuspended())
resumeAnimationsForDocument(document);
}
void CSSAnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended(bool allowed)
{
m_allowsNewAnimationsWhileSuspended = allowed;
}
bool CSSAnimationControllerPrivate::pauseAnimationAtTime(Element& element, const AtomicString& name, double t)
{
CompositeAnimation& compositeAnimation = ensureCompositeAnimation(element);
if (compositeAnimation.pauseAnimationAtTime(name, t)) {
element.invalidateStyleAndLayerComposition();
startUpdateStyleIfNeededDispatcher();
return true;
}
return false;
}
bool CSSAnimationControllerPrivate::pauseTransitionAtTime(Element& element, const String& property, double t)
{
CompositeAnimation& compositeAnimation = ensureCompositeAnimation(element);
if (compositeAnimation.pauseTransitionAtTime(cssPropertyID(property), t)) {
element.invalidateStyleAndLayerComposition();
startUpdateStyleIfNeededDispatcher();
return true;
}
return false;
}
double CSSAnimationControllerPrivate::beginAnimationUpdateTime()
{
ASSERT(m_beginAnimationUpdateCount);
if (!m_beginAnimationUpdateTime)
m_beginAnimationUpdateTime = monotonicallyIncreasingTime();
return m_beginAnimationUpdateTime.value();
}
void CSSAnimationControllerPrivate::beginAnimationUpdate()
{
if (!m_beginAnimationUpdateCount)
m_beginAnimationUpdateTime = std::nullopt;
++m_beginAnimationUpdateCount;
}
void CSSAnimationControllerPrivate::endAnimationUpdate()
{
ASSERT(m_beginAnimationUpdateCount > 0);
if (m_beginAnimationUpdateCount == 1) {
styleAvailable();
if (!m_waitingForAsyncStartNotification)
startTimeResponse(beginAnimationUpdateTime());
}
--m_beginAnimationUpdateCount;
}
void CSSAnimationControllerPrivate::receivedStartTimeResponse(double time)
{
LOG(Animations, "CSSAnimationControllerPrivate %p receivedStartTimeResponse %f", this, time);
m_waitingForAsyncStartNotification = false;
startTimeResponse(time);
}
std::unique_ptr<RenderStyle> CSSAnimationControllerPrivate::animatedStyleForElement(Element& element)
{
auto* animation = m_compositeAnimations.get(&element);
if (!animation)
return nullptr;
AnimationPrivateUpdateBlock animationUpdateBlock(*this);
auto animatingStyle = animation->getAnimatedStyle();
if (!animatingStyle)
return nullptr;
return animatingStyle;
}
bool CSSAnimationControllerPrivate::computeExtentOfAnimation(Element& element, LayoutRect& bounds) const
{
auto* animation = m_compositeAnimations.get(&element);
if (!animation)
return true;
if (!animation->isAnimatingProperty(CSSPropertyTransform, false, AnimationBase::Running | AnimationBase::Paused))
return true;
return animation->computeExtentOfTransformAnimation(bounds);
}
unsigned CSSAnimationControllerPrivate::numberOfActiveAnimations(Document* document) const
{
unsigned count = 0;
for (auto& animation : m_compositeAnimations) {
if (&animation.key->document() == document)
count += animation.value->numberOfActiveAnimations();
}
return count;
}
void CSSAnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation)
{
m_animationsWaitingForStartTimeResponse.remove(animation);
m_animationsWaitingForStyle.add(animation);
}
void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove)
{
m_animationsWaitingForStyle.remove(animationToRemove);
}
void CSSAnimationControllerPrivate::styleAvailable()
{
for (const auto& waitingAnimation : m_animationsWaitingForStyle)
waitingAnimation->styleAvailable();
m_animationsWaitingForStyle.clear();
}
void CSSAnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse)
{
if (willGetResponse)
m_waitingForAsyncStartNotification = true;
m_animationsWaitingForStartTimeResponse.add(animation);
}
void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove)
{
m_animationsWaitingForStartTimeResponse.remove(animationToRemove);
if (m_animationsWaitingForStartTimeResponse.isEmpty())
m_waitingForAsyncStartNotification = false;
}
void CSSAnimationControllerPrivate::startTimeResponse(double time)
{
for (const auto& animation : m_animationsWaitingForStartTimeResponse)
animation->onAnimationStartResponse(time);
m_animationsWaitingForStartTimeResponse.clear();
m_waitingForAsyncStartNotification = false;
}
void CSSAnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation)
{
LOG(Animations, "CSSAnimationControllerPrivate %p animationWillBeRemoved: %p", this, animation);
removeFromAnimationsWaitingForStyle(animation);
removeFromAnimationsWaitingForStartTimeResponse(animation);
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
removeFromAnimationsDependentOnScroll(animation);
#endif
bool anyAnimationsWaitingForAsyncStart = false;
for (auto& animation : m_animationsWaitingForStartTimeResponse) {
if (animation->waitingForStartTime() && animation->isAccelerated()) {
anyAnimationsWaitingForAsyncStart = true;
break;
}
}
if (!anyAnimationsWaitingForAsyncStart)
m_waitingForAsyncStartNotification = false;
}
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
void CSSAnimationControllerPrivate::addToAnimationsDependentOnScroll(AnimationBase* animation)
{
m_animationsDependentOnScroll.add(animation);
}
void CSSAnimationControllerPrivate::removeFromAnimationsDependentOnScroll(AnimationBase* animation)
{
m_animationsDependentOnScroll.remove(animation);
}
void CSSAnimationControllerPrivate::scrollWasUpdated()
{
auto* view = m_frame.view();
if (!view || !wantsScrollUpdates())
return;
m_scrollPosition = view->scrollPositionForFixedPosition().y().toFloat();
updateAnimations(CallSetChanged);
}
#endif
CSSAnimationController::CSSAnimationController(Frame& frame)
: m_data(std::make_unique<CSSAnimationControllerPrivate>(frame))
{
}
CSSAnimationController::~CSSAnimationController() = default;
void CSSAnimationController::cancelAnimations(Element& element)
{
if (!m_data->clear(element))
return;
if (element.document().renderTreeBeingDestroyed())
return;
ASSERT(element.document().pageCacheState() == Document::NotInPageCache);
element.invalidateStyleAndLayerComposition();
}
AnimationUpdate CSSAnimationController::updateAnimations(Element& element, const RenderStyle& newStyle, const RenderStyle* oldStyle)
{
bool hasOrHadAnimations = (oldStyle && oldStyle->hasAnimationsOrTransitions()) || newStyle.hasAnimationsOrTransitions();
if (!hasOrHadAnimations)
return { };
if (element.document().pageCacheState() != Document::NotInPageCache)
return { };
if (element.document().renderView()->printing())
return { };
CompositeAnimation& compositeAnimation = m_data->ensureCompositeAnimation(element);
auto update = compositeAnimation.animate(element, oldStyle, newStyle);
auto* renderer = element.renderer();
if ((renderer && renderer->parent()) || newStyle.animations() || (oldStyle && oldStyle->animations())) {
auto& frameView = *element.document().view();
if (compositeAnimation.hasAnimationThatDependsOnLayout())
m_data->setRequiresLayout();
m_data->updateAnimationTimerForElement(element);
frameView.scheduleAnimation();
}
return update;
}
std::unique_ptr<RenderStyle> CSSAnimationController::animatedStyleForRenderer(RenderElement& renderer)
{
std::unique_ptr<RenderStyle> result;
if (renderer.style().hasAnimationsOrTransitions() && renderer.element())
result = m_data->animatedStyleForElement(*renderer.element());
if (!result)
result = RenderStyle::clonePtr(renderer.style());
return result;
}
bool CSSAnimationController::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const
{
if (!renderer.element())
return true;
if (!renderer.style().hasAnimationsOrTransitions())
return true;
return m_data->computeExtentOfAnimation(*renderer.element(), bounds);
}
void CSSAnimationController::notifyAnimationStarted(RenderElement& renderer, double startTime)
{
LOG(Animations, "CSSAnimationController %p notifyAnimationStarted on renderer %p, time=%f", this, &renderer, startTime);
UNUSED_PARAM(renderer);
AnimationUpdateBlock animationUpdateBlock(this);
m_data->receivedStartTimeResponse(startTime);
}
bool CSSAnimationController::pauseAnimationAtTime(Element& element, const AtomicString& name, double t)
{
AnimationUpdateBlock animationUpdateBlock(this);
return m_data->pauseAnimationAtTime(element, name, t);
}
unsigned CSSAnimationController::numberOfActiveAnimations(Document* document) const
{
return m_data->numberOfActiveAnimations(document);
}
bool CSSAnimationController::pauseTransitionAtTime(Element& element, const String& property, double t)
{
AnimationUpdateBlock animationUpdateBlock(this);
return m_data->pauseTransitionAtTime(element, property, t);
}
bool CSSAnimationController::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
{
if (!renderer.style().hasAnimationsOrTransitions())
return false;
return m_data->isRunningAnimationOnRenderer(renderer, property, runningState);
}
bool CSSAnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
{
if (!renderer.style().hasAnimationsOrTransitions())
return false;
return m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, runningState);
}
bool CSSAnimationController::isSuspended() const
{
return m_data->isSuspended();
}
void CSSAnimationController::suspendAnimations()
{
LOG(Animations, "controller is suspending animations");
m_data->suspendAnimations();
}
void CSSAnimationController::resumeAnimations()
{
LOG(Animations, "controller is resuming animations");
m_data->resumeAnimations();
}
bool CSSAnimationController::allowsNewAnimationsWhileSuspended() const
{
return m_data->allowsNewAnimationsWhileSuspended();
}
void CSSAnimationController::setAllowsNewAnimationsWhileSuspended(bool allowed)
{
m_data->setAllowsNewAnimationsWhileSuspended(allowed);
}
void CSSAnimationController::serviceAnimations()
{
m_data->animationFrameCallbackFired();
}
void CSSAnimationController::updateThrottlingState()
{
m_data->updateThrottlingState();
}
Seconds CSSAnimationController::animationInterval() const
{
return m_data->animationInterval();
}
bool CSSAnimationController::animationsAreSuspendedForDocument(Document* document)
{
return m_data->animationsAreSuspendedForDocument(document);
}
void CSSAnimationController::detachFromDocument(Document* document)
{
return m_data->detachFromDocument(document);
}
void CSSAnimationController::suspendAnimationsForDocument(Document* document)
{
LOG(Animations, "suspending animations for document %p", document);
m_data->suspendAnimationsForDocument(document);
}
void CSSAnimationController::resumeAnimationsForDocument(Document* document)
{
LOG(Animations, "resuming animations for document %p", document);
AnimationUpdateBlock animationUpdateBlock(this);
m_data->resumeAnimationsForDocument(document);
}
void CSSAnimationController::startAnimationsIfNotSuspended(Document* document)
{
LOG(Animations, "animations may start for document %p", document);
AnimationUpdateBlock animationUpdateBlock(this);
m_data->startAnimationsIfNotSuspended(document);
}
void CSSAnimationController::beginAnimationUpdate()
{
m_data->beginAnimationUpdate();
}
void CSSAnimationController::endAnimationUpdate()
{
m_data->endAnimationUpdate();
}
bool CSSAnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
{
return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property);
}
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
bool CSSAnimationController::wantsScrollUpdates() const
{
return m_data->wantsScrollUpdates();
}
void CSSAnimationController::scrollWasUpdated()
{
m_data->scrollWasUpdated();
}
#endif
bool CSSAnimationController::hasAnimations() const
{
return m_data->hasAnimations();
}
}