static void
UpdateOldAnimationPropertiesWithNew(
CSSAnimation& aOld,
TimingParams& aNewTiming,
nsTArray<Keyframe>& aNewKeyframes,
bool aNewIsStylePaused,
nsStyleContext* aStyleContext)
{
bool animationChanged = false;
// Update the old from the new so we can keep the original object
// identity (and any expando properties attached to it).
if (aOld.GetEffect()) {
AnimationEffectReadOnly* oldEffect = aOld.GetEffect();
animationChanged = oldEffect->SpecifiedTiming() != aNewTiming;
oldEffect->SetSpecifiedTiming(aNewTiming);
KeyframeEffectReadOnly* oldKeyframeEffect = oldEffect->AsKeyframeEffect();
if (oldKeyframeEffect) {
oldKeyframeEffect->SetKeyframes(Move(aNewKeyframes), aStyleContext);
}
}
// Handle changes in play state. If the animation is idle, however,
// changes to animation-play-state should *not* restart it.
if (aOld.PlayState() != AnimationPlayState::Idle) {
// CSSAnimation takes care of override behavior so that,
// for example, if the author has called pause(), that will
// override the animation-play-state.
// (We should check aNew->IsStylePaused() but that requires
// downcasting to CSSAnimation and we happen to know that
// aNew will only ever be paused by calling PauseFromStyle
// making IsPausedOrPausing synonymous in this case.)
if (!aOld.IsStylePaused() && aNewIsStylePaused) {
aOld.PauseFromStyle();
animationChanged = true;
} else if (aOld.IsStylePaused() && !aNewIsStylePaused) {
aOld.PlayFromStyle();
animationChanged = true;
}
}
// Updating the effect timing above might already have caused the
// animation to become irrelevant so only add a changed record if
// the animation is still relevant.
if (animationChanged && aOld.IsRelevant()) {
nsNodeUtils::AnimationChanged(&aOld);
}
}
/* static */ void
nsAnimationManager::UpdateCascadeResults(
nsStyleContext* aStyleContext,
AnimationCollection* aElementAnimations)
{
/*
* Figure out which properties we need to examine.
*/
// size of 2 since we only currently have 2 properties we animate on
// the compositor
nsAutoTArray<nsCSSProperty, 2> propertiesToTrack;
{
nsCSSPropertySet propertiesToTrackAsSet;
for (size_t animIdx = aElementAnimations->mAnimations.Length();
animIdx-- != 0; ) {
const Animation* anim = aElementAnimations->mAnimations[animIdx];
const KeyframeEffectReadOnly* effect = anim->GetEffect();
if (!effect) {
continue;
}
for (size_t propIdx = 0, propEnd = effect->Properties().Length();
propIdx != propEnd; ++propIdx) {
const AnimationProperty& prop = effect->Properties()[propIdx];
// We only bother setting mWinsInCascade for properties that we
// can animate on the compositor.
if (nsCSSProps::PropHasFlags(prop.mProperty,
CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR)) {
if (!propertiesToTrackAsSet.HasProperty(prop.mProperty)) {
propertiesToTrack.AppendElement(prop.mProperty);
propertiesToTrackAsSet.AddProperty(prop.mProperty);
}
}
}
}
}
/*
* Determine whether those properties are set in things that
* override animations.
*/
nsCSSPropertySet propertiesOverridden;
nsRuleNode::ComputePropertiesOverridingAnimation(propertiesToTrack,
aStyleContext,
propertiesOverridden);
/*
* Set mWinsInCascade based both on what is overridden at levels
* higher than animations and based on one animation overriding
* another.
*
* We iterate from the last animation to the first, just like we do
* when calling ComposeStyle from AnimationCollection::EnsureStyleRuleFor.
* Later animations override earlier ones, so we add properties to the set
* of overridden properties as we encounter them, if the animation is
* currently in effect.
*/
bool changed = false;
for (size_t animIdx = aElementAnimations->mAnimations.Length();
animIdx-- != 0; ) {
CSSAnimation* anim =
aElementAnimations->mAnimations[animIdx]->AsCSSAnimation();
KeyframeEffectReadOnly* effect = anim->GetEffect();
anim->mInEffectForCascadeResults = anim->IsInEffect();
if (!effect) {
continue;
}
for (size_t propIdx = 0, propEnd = effect->Properties().Length();
propIdx != propEnd; ++propIdx) {
AnimationProperty& prop = effect->Properties()[propIdx];
// We only bother setting mWinsInCascade for properties that we
// can animate on the compositor.
if (nsCSSProps::PropHasFlags(prop.mProperty,
CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR)) {
bool newWinsInCascade =
!propertiesOverridden.HasProperty(prop.mProperty);
if (newWinsInCascade != prop.mWinsInCascade) {
changed = true;
}
prop.mWinsInCascade = newWinsInCascade;
if (prop.mWinsInCascade && anim->mInEffectForCascadeResults) {
// This animation is in effect right now, so it overrides
// earlier animations. (For animations that aren't in effect,
// we set mWinsInCascade as though they were, but they don't
// suppress animations lower in the cascade.)
propertiesOverridden.AddProperty(prop.mProperty);
}
}
}
}
if (changed) {
nsPresContext* presContext = aElementAnimations->mManager->PresContext();
presContext->RestyleManager()->IncrementAnimationGeneration();
aElementAnimations->UpdateAnimationGeneration(presContext);
aElementAnimations->PostUpdateLayerAnimations();
// Invalidate our style rule.
aElementAnimations->mNeedsRefreshes = true;
aElementAnimations->mStyleRuleRefreshTime = TimeStamp();
}
}