void
nsAnimationReceiver::RecordAnimationMutation(Animation* aAnimation,
AnimationMutation aMutationType)
{
KeyframeEffectReadonly* effect = aAnimation->GetEffect();
if (!effect) {
return;
}
Element* animationTarget = effect->GetTarget();
if (!animationTarget) {
return;
}
if (!Animations() || !(Subtree() || animationTarget == Target()) ||
animationTarget->ChromeOnlyAccess()) {
return;
}
if (nsAutoAnimationMutationBatch::IsBatching()) {
if (nsAutoAnimationMutationBatch::GetBatchTarget() != animationTarget) {
return;
}
switch (aMutationType) {
case eAnimationMutation_Added:
nsAutoAnimationMutationBatch::AnimationAdded(aAnimation);
break;
case eAnimationMutation_Changed:
nsAutoAnimationMutationBatch::AnimationChanged(aAnimation);
break;
case eAnimationMutation_Removed:
nsAutoAnimationMutationBatch::AnimationRemoved(aAnimation);
break;
}
nsAutoAnimationMutationBatch::AddObserver(Observer());
return;
}
nsDOMMutationRecord* m =
Observer()->CurrentRecord(nsGkAtoms::animations);
NS_ASSERTION(!m->mTarget, "Wrong target!");
m->mTarget = animationTarget;
switch (aMutationType) {
case eAnimationMutation_Added:
m->mAddedAnimations.AppendElement(aAnimation);
break;
case eAnimationMutation_Changed:
m->mChangedAnimations.AppendElement(aAnimation);
break;
case eAnimationMutation_Removed:
m->mRemovedAnimations.AppendElement(aAnimation);
break;
}
}
static inline Element*
GetTarget(AnimationPlayer* aPlayer)
{
KeyframeEffectReadonly* effect = aPlayer->GetEffect();
if (!effect) {
return nullptr;
}
Element* target;
nsCSSPseudoElements::Type pseudoType;
effect->GetTarget(target, pseudoType);
// If the animation targets a pseudo-element, we don't dispatch
// notifications for it. (In the future we will have PseudoElement
// objects we can use as the target of the notifications.)
if (pseudoType != nsCSSPseudoElements::ePseudo_NotPseudoElement) {
return nullptr;
}
return effect->GetTarget();
}
/* 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();
}
}
nsIStyleRule*
nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext,
mozilla::dom::Element* aElement)
{
if (!mPresContext->IsDynamic()) {
// For print or print preview, ignore animations.
return nullptr;
}
// Everything that causes our animation data to change triggers a
// style change, which in turn triggers a non-animation restyle.
// Likewise, when we initially construct frames, we're not in a
// style change, but also not in an animation restyle.
const nsStyleDisplay* disp = aStyleContext->StyleDisplay();
AnimationCollection* collection =
GetAnimations(aElement, aStyleContext->GetPseudoType(), false);
if (!collection &&
disp->mAnimationNameCount == 1 &&
disp->mAnimations[0].GetName().IsEmpty()) {
return nullptr;
}
nsAutoAnimationMutationBatch mb(aElement);
// build the animations list
dom::DocumentTimeline* timeline = aElement->OwnerDoc()->Timeline();
AnimationPtrArray newAnimations;
if (!aStyleContext->IsInDisplayNoneSubtree()) {
BuildAnimations(aStyleContext, aElement, timeline, newAnimations);
}
if (newAnimations.IsEmpty()) {
if (collection) {
// There might be transitions that run now that animations don't
// override them.
mPresContext->TransitionManager()->
UpdateCascadeResultsWithAnimationsToBeDestroyed(collection);
collection->Destroy();
}
return nullptr;
}
if (collection) {
collection->mStyleRule = nullptr;
collection->mStyleRuleRefreshTime = TimeStamp();
collection->UpdateAnimationGeneration(mPresContext);
// Copy over the start times and (if still paused) pause starts
// for each animation (matching on name only) that was also in the
// old list of animations.
// This means that we honor dynamic changes, which isn't what the
// spec says to do, but WebKit seems to honor at least some of
// them. See
// http://lists.w3.org/Archives/Public/www-style/2011Apr/0079.html
// In order to honor what the spec said, we'd copy more data over
// (or potentially optimize BuildAnimations to avoid rebuilding it
// in the first place).
if (!collection->mAnimations.IsEmpty()) {
for (size_t newIdx = newAnimations.Length(); newIdx-- != 0;) {
Animation* newAnim = newAnimations[newIdx];
// Find the matching animation with this name in the old list
// of animations. We iterate through both lists in a backwards
// direction which means that if there are more animations in
// the new list of animations with a given name than in the old
// list, it will be the animations towards the of the beginning of
// the list that do not match and are treated as new animations.
nsRefPtr<CSSAnimation> oldAnim;
size_t oldIdx = collection->mAnimations.Length();
while (oldIdx-- != 0) {
CSSAnimation* a = collection->mAnimations[oldIdx]->AsCSSAnimation();
MOZ_ASSERT(a, "All animations in the CSS Animation collection should"
" be CSSAnimation objects");
if (a->Name() == newAnim->Name()) {
oldAnim = a;
break;
}
}
if (!oldAnim) {
continue;
}
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 (oldAnim->GetEffect() && newAnim->GetEffect()) {
KeyframeEffectReadonly* oldEffect = oldAnim->GetEffect();
KeyframeEffectReadonly* newEffect = newAnim->GetEffect();
animationChanged =
oldEffect->Timing() != newEffect->Timing() ||
oldEffect->Properties() != newEffect->Properties();
oldEffect->Timing() = newEffect->Timing();
oldEffect->Properties() = newEffect->Properties();
}
// Reset compositor state so animation will be re-synchronized.
oldAnim->ClearIsRunningOnCompositor();
// Handle changes in play state.
// 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 newAnim->IsStylePaused() but that requires
// downcasting to CSSAnimation and we happen to know that
// newAnim will only ever be paused by calling PauseFromStyle
// making IsPausedOrPausing synonymous in this case.)
if (!oldAnim->IsStylePaused() && newAnim->IsPausedOrPausing()) {
oldAnim->PauseFromStyle();
animationChanged = true;
} else if (oldAnim->IsStylePaused() &&
!newAnim->IsPausedOrPausing()) {
oldAnim->PlayFromStyle();
animationChanged = true;
}
if (animationChanged) {
nsNodeUtils::AnimationChanged(oldAnim);
}
// Replace new animation with the (updated) old one and remove the
// old one from the array so we don't try to match it any more.
//
// Although we're doing this while iterating this is safe because
// we're not changing the length of newAnimations and we've finished
// iterating over the list of old iterations.
newAnim->Cancel();
newAnim = nullptr;
newAnimations.ReplaceElementAt(newIdx, oldAnim);
collection->mAnimations.RemoveElementAt(oldIdx);
// We've touched the old animation's timing properties, so this
// could update the old animation's relevance.
oldAnim->UpdateRelevance();
}
}
} else {
collection =
GetAnimations(aElement, aStyleContext->GetPseudoType(), true);
}
collection->mAnimations.SwapElements(newAnimations);
collection->mNeedsRefreshes = true;
collection->Tick();
// Cancel removed animations
for (size_t newAnimIdx = newAnimations.Length(); newAnimIdx-- != 0; ) {
newAnimations[newAnimIdx]->Cancel();
}
UpdateCascadeResults(aStyleContext, collection);
TimeStamp refreshTime = mPresContext->RefreshDriver()->MostRecentRefresh();
UpdateStyleAndEvents(collection, refreshTime,
EnsureStyleRule_IsNotThrottled);
// We don't actually dispatch the mPendingEvents now. We'll either
// dispatch them the next time we get a refresh driver notification
// or the next time somebody calls
// nsPresShell::FlushPendingNotifications.
if (!mPendingEvents.IsEmpty()) {
mPresContext->Document()->SetNeedStyleFlush();
}
return GetAnimationRule(aElement, aStyleContext->GetPseudoType());
}
