bool KeyframeEffectReadOnly::CanThrottle() const { // Unthrottle if we are not in effect or current. This will be the case when // our owning animation has finished, is idle, or when we are in the delay // phase (but without a backwards fill). In each case the computed progress // value produced on each tick will be the same so we will skip requesting // unnecessary restyles in NotifyAnimationTimingUpdated. Any calls we *do* get // here will be because of a change in state (e.g. we are newly finished or // newly no longer in effect) in which case we shouldn't throttle the sample. if (!IsInEffect() || !IsCurrent()) { return false; } nsIFrame* frame = GetAnimationFrame(); if (!frame) { // There are two possible cases here. // a) No target element // b) The target element has no frame, e.g. because it is in a display:none // subtree. // In either case we can throttle the animation because there is no // need to update on the main thread. return true; } // We can throttle the animation if the animation is paint only and // the target frame is out of view or the document is in background tabs. if (CanIgnoreIfNotVisible()) { nsIPresShell* presShell = GetPresShell(); if ((presShell && !presShell->IsActive()) || frame->IsScrolledOutOfView()) { return true; } } // First we need to check layer generation and transform overflow // prior to the property.mIsRunningOnCompositor check because we should // occasionally unthrottle these animations even if the animations are // already running on compositor. for (const LayerAnimationInfo::Record& record : LayerAnimationInfo::sRecords) { // Skip properties that are overridden by !important rules. // (GetEffectiveAnimationOfProperty, as called by // HasEffectiveAnimationOfProperty, only returns a property which is // neither overridden by !important rules nor overridden by other // animation.) if (!HasEffectiveAnimationOfProperty(record.mProperty)) { continue; } EffectSet* effectSet = EffectSet::GetEffectSet(mTarget->mElement, mTarget->mPseudoType); MOZ_ASSERT(effectSet, "CanThrottle should be called on an effect " "associated with a target element"); layers::Layer* layer = FrameLayerBuilder::GetDedicatedLayer(frame, record.mLayerType); // Unthrottle if the layer needs to be brought up to date if (!layer || effectSet->GetAnimationGeneration() != layer->GetAnimationGeneration()) { return false; } // If this is a transform animation that affects the overflow region, // we should unthrottle the animation periodically. if (record.mProperty == eCSSProperty_transform && !CanThrottleTransformChanges(*frame)) { return false; } } for (const AnimationProperty& property : mProperties) { if (!property.mIsRunningOnCompositor) { return false; } } return true; }
void Animation::ComposeStyle(RefPtr<AnimValuesStyleRule>& aStyleRule, nsCSSPropertySet& aSetProperties, bool& aStyleChanging) { if (!mEffect) { return; } AnimationPlayState playState = PlayState(); if (playState == AnimationPlayState::Running || playState == AnimationPlayState::Pending) { aStyleChanging = true; } if (!IsInEffect()) { return; } // In order to prevent flicker, there are a few cases where we want to use // a different time for rendering that would otherwise be returned by // GetCurrentTime. These are: // // (a) For animations that are pausing but which are still running on the // compositor. In this case we send a layer transaction that removes the // animation but which also contains the animation values calculated on // the main thread. To prevent flicker when this occurs we want to ensure // the timeline time used to calculate the main thread animation values // does not lag far behind the time used on the compositor. Ideally we // would like to use the "animation ready time" calculated at the end of // the layer transaction as the timeline time but it will be too late to // update the style rule at that point so instead we just use the current // wallclock time. // // (b) For animations that are pausing that we have already taken off the // compositor. In this case we record a pending ready time but we don't // apply it until the next tick. However, while waiting for the next tick, // we should still use the pending ready time as the timeline time. If we // use the regular timeline time the animation may appear jump backwards // if the main thread's timeline time lags behind the compositor. // // (c) For animations that are play-pending due to an aborted pause operation // (i.e. a pause operation that was interrupted before we entered the // paused state). When we cancel a pending pause we might momentarily take // the animation off the compositor, only to re-add it moments later. In // that case the compositor might have been ahead of the main thread so we // should use the current wallclock time to ensure the animation doesn't // temporarily jump backwards. // // To address each of these cases we temporarily tweak the hold time // immediately before updating the style rule and then restore it immediately // afterwards. This is purely to prevent visual flicker. Other behavior // such as dispatching events continues to rely on the regular timeline time. bool updatedHoldTime = false; { AutoRestore<Nullable<TimeDuration>> restoreHoldTime(mHoldTime); if (playState == AnimationPlayState::Pending && mHoldTime.IsNull() && !mStartTime.IsNull()) { Nullable<TimeDuration> timeToUse = mPendingReadyTime; if (timeToUse.IsNull() && mTimeline && mTimeline->TracksWallclockTime()) { timeToUse = mTimeline->ToTimelineTime(TimeStamp::Now()); } if (!timeToUse.IsNull()) { mHoldTime.SetValue((timeToUse.Value() - mStartTime.Value()) .MultDouble(mPlaybackRate)); // Push the change down to the effect UpdateEffect(); updatedHoldTime = true; } } mEffect->ComposeStyle(aStyleRule, aSetProperties); } // Now that the hold time has been restored, update the effect if (updatedHoldTime) { UpdateEffect(); } MOZ_ASSERT(playState == PlayState(), "Play state should not change during the course of compositing"); mFinishedAtLastComposeStyle = (playState == AnimationPlayState::Finished); }