diff options
Diffstat (limited to 'dom/animation/KeyframeEffect.cpp')
| -rw-r--r-- | dom/animation/KeyframeEffect.cpp | 2016 |
1 files changed, 2016 insertions, 0 deletions
diff --git a/dom/animation/KeyframeEffect.cpp b/dom/animation/KeyframeEffect.cpp new file mode 100644 index 0000000000..f85415b834 --- /dev/null +++ b/dom/animation/KeyframeEffect.cpp @@ -0,0 +1,2016 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/KeyframeEffect.h" + +#include "mozilla/dom/Animation.h" +#include "mozilla/dom/DocumentInlines.h" +#include "mozilla/dom/KeyframeAnimationOptionsBinding.h" +// For UnrestrictedDoubleOrKeyframeAnimationOptions; +#include "mozilla/dom/KeyframeEffectBinding.h" +#include "mozilla/dom/MutationObservers.h" +#include "mozilla/layers/AnimationInfo.h" +#include "mozilla/AnimationUtils.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/ComputedStyleInlines.h" +#include "mozilla/EffectSet.h" +#include "mozilla/FloatingPoint.h" // For IsFinite +#include "mozilla/LayerAnimationInfo.h" +#include "mozilla/LookAndFeel.h" // For LookAndFeel::GetInt +#include "mozilla/KeyframeUtils.h" +#include "mozilla/PresShell.h" +#include "mozilla/PresShellInlines.h" +#include "mozilla/ServoBindings.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/StaticPrefs_layers.h" +#include "nsCSSPropertyID.h" +#include "nsComputedDOMStyle.h" // nsComputedDOMStyle::GetComputedStyle +#include "nsContentUtils.h" +#include "nsCSSPropertyIDSet.h" +#include "nsCSSProps.h" // For nsCSSProps::PropHasFlags +#include "nsCSSPseudoElements.h" // For PseudoStyleType +#include "nsDOMMutationObserver.h" // For nsAutoAnimationMutationBatch +#include "nsIFrame.h" +#include "nsIFrameInlines.h" +#include "nsIScrollableFrame.h" +#include "nsPresContextInlines.h" +#include "nsRefreshDriver.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty +#include "WindowRenderer.h" + +namespace mozilla { + +void AnimationProperty::SetPerformanceWarning( + const AnimationPerformanceWarning& aWarning, const dom::Element* aElement) { + if (mPerformanceWarning && *mPerformanceWarning == aWarning) { + return; + } + + mPerformanceWarning = Some(aWarning); + + nsAutoString localizedString; + if (StaticPrefs::layers_offmainthreadcomposition_log_animations() && + mPerformanceWarning->ToLocalizedString(localizedString)) { + nsAutoCString logMessage = NS_ConvertUTF16toUTF8(localizedString); + AnimationUtils::LogAsyncAnimationFailure(logMessage, aElement); + } +} + +bool PropertyValuePair::operator==(const PropertyValuePair& aOther) const { + if (mProperty != aOther.mProperty) { + return false; + } + if (mServoDeclarationBlock == aOther.mServoDeclarationBlock) { + return true; + } + if (!mServoDeclarationBlock || !aOther.mServoDeclarationBlock) { + return false; + } + return Servo_DeclarationBlock_Equals(mServoDeclarationBlock, + aOther.mServoDeclarationBlock); +} + +namespace dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(KeyframeEffect, AnimationEffect, + mTarget.mElement) + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(KeyframeEffect, AnimationEffect) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(KeyframeEffect) +NS_INTERFACE_MAP_END_INHERITING(AnimationEffect) + +NS_IMPL_ADDREF_INHERITED(KeyframeEffect, AnimationEffect) +NS_IMPL_RELEASE_INHERITED(KeyframeEffect, AnimationEffect) + +KeyframeEffect::KeyframeEffect(Document* aDocument, + OwningAnimationTarget&& aTarget, + TimingParams&& aTiming, + const KeyframeEffectParams& aOptions) + : AnimationEffect(aDocument, std::move(aTiming)), + mTarget(std::move(aTarget)), + mEffectOptions(aOptions) {} + +KeyframeEffect::KeyframeEffect(Document* aDocument, + OwningAnimationTarget&& aTarget, + const KeyframeEffect& aOther) + : AnimationEffect(aDocument, TimingParams{aOther.SpecifiedTiming()}), + mTarget(std::move(aTarget)), + mEffectOptions{aOther.IterationComposite(), aOther.Composite(), + mTarget.mPseudoType}, + mKeyframes(aOther.mKeyframes.Clone()), + mProperties(aOther.mProperties.Clone()), + mBaseValues(aOther.mBaseValues.Clone()) {} + +JSObject* KeyframeEffect::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return KeyframeEffect_Binding::Wrap(aCx, this, aGivenProto); +} + +IterationCompositeOperation KeyframeEffect::IterationComposite() const { + return mEffectOptions.mIterationComposite; +} + +void KeyframeEffect::SetIterationComposite( + const IterationCompositeOperation& aIterationComposite) { + if (mEffectOptions.mIterationComposite == aIterationComposite) { + return; + } + + if (mAnimation && mAnimation->IsRelevant()) { + MutationObservers::NotifyAnimationChanged(mAnimation); + } + + mEffectOptions.mIterationComposite = aIterationComposite; + RequestRestyle(EffectCompositor::RestyleType::Layer); +} + +CompositeOperation KeyframeEffect::Composite() const { + return mEffectOptions.mComposite; +} + +void KeyframeEffect::SetComposite(const CompositeOperation& aComposite) { + if (mEffectOptions.mComposite == aComposite) { + return; + } + + mEffectOptions.mComposite = aComposite; + + if (mAnimation && mAnimation->IsRelevant()) { + MutationObservers::NotifyAnimationChanged(mAnimation); + } + + if (mTarget) { + RefPtr<const ComputedStyle> computedStyle = + GetTargetComputedStyle(Flush::None); + if (computedStyle) { + UpdateProperties(computedStyle); + } + } +} + +void KeyframeEffect::NotifySpecifiedTimingUpdated() { + // Use the same document for a pseudo element and its parent element. + // Use nullptr if we don't have mTarget, so disable the mutation batch. + nsAutoAnimationMutationBatch mb(mTarget ? mTarget.mElement->OwnerDoc() + : nullptr); + + if (mAnimation) { + mAnimation->NotifyEffectTimingUpdated(); + + if (mAnimation->IsRelevant()) { + MutationObservers::NotifyAnimationChanged(mAnimation); + } + + RequestRestyle(EffectCompositor::RestyleType::Layer); + } +} + +void KeyframeEffect::NotifyAnimationTimingUpdated( + PostRestyleMode aPostRestyle) { + UpdateTargetRegistration(); + + // If the effect is not relevant it will be removed from the target + // element's effect set. However, effects not in the effect set + // will not be included in the set of candidate effects for running on + // the compositor and hence they won't have their compositor status + // updated. As a result, we need to make sure we clear their compositor + // status here. + bool isRelevant = mAnimation && mAnimation->IsRelevant(); + if (!isRelevant) { + ResetIsRunningOnCompositor(); + } + + // Request restyle if necessary. + if (aPostRestyle == PostRestyleMode::IfNeeded && mAnimation && + !mProperties.IsEmpty() && HasComputedTimingChanged()) { + EffectCompositor::RestyleType restyleType = + CanThrottle() ? EffectCompositor::RestyleType::Throttled + : EffectCompositor::RestyleType::Standard; + RequestRestyle(restyleType); + } + + // Detect changes to "in effect" status since we need to recalculate the + // animation cascade for this element whenever that changes. + // Note that updating mInEffectOnLastAnimationTimingUpdate has to be done + // after above CanThrottle() call since the function uses the flag inside it. + bool inEffect = IsInEffect(); + if (inEffect != mInEffectOnLastAnimationTimingUpdate) { + MarkCascadeNeedsUpdate(); + mInEffectOnLastAnimationTimingUpdate = inEffect; + } + + // If we're no longer "in effect", our ComposeStyle method will never be + // called and we will never have a chance to update mProgressOnLastCompose + // and mCurrentIterationOnLastCompose. + // We clear them here to ensure that if we later become "in effect" we will + // request a restyle (above). + if (!inEffect) { + mProgressOnLastCompose.SetNull(); + mCurrentIterationOnLastCompose = 0; + } +} + +static bool KeyframesEqualIgnoringComputedOffsets( + const nsTArray<Keyframe>& aLhs, const nsTArray<Keyframe>& aRhs) { + if (aLhs.Length() != aRhs.Length()) { + return false; + } + + for (size_t i = 0, len = aLhs.Length(); i < len; ++i) { + const Keyframe& a = aLhs[i]; + const Keyframe& b = aRhs[i]; + if (a.mOffset != b.mOffset || a.mTimingFunction != b.mTimingFunction || + a.mPropertyValues != b.mPropertyValues) { + return false; + } + } + return true; +} + +// https://drafts.csswg.org/web-animations/#dom-keyframeeffect-setkeyframes +void KeyframeEffect::SetKeyframes(JSContext* aContext, + JS::Handle<JSObject*> aKeyframes, + ErrorResult& aRv) { + nsTArray<Keyframe> keyframes = KeyframeUtils::GetKeyframesFromObject( + aContext, mDocument, aKeyframes, "KeyframeEffect.setKeyframes", aRv); + if (aRv.Failed()) { + return; + } + + RefPtr<const ComputedStyle> style = GetTargetComputedStyle(Flush::None); + SetKeyframes(std::move(keyframes), style, nullptr /* AnimationTimeline */); +} + +void KeyframeEffect::SetKeyframes(nsTArray<Keyframe>&& aKeyframes, + const ComputedStyle* aStyle, + const AnimationTimeline* aTimeline) { + if (KeyframesEqualIgnoringComputedOffsets(aKeyframes, mKeyframes)) { + return; + } + + mKeyframes = std::move(aKeyframes); + KeyframeUtils::DistributeKeyframes(mKeyframes); + + if (mAnimation && mAnimation->IsRelevant()) { + MutationObservers::NotifyAnimationChanged(mAnimation); + } + + // We need to call UpdateProperties() unless the target element doesn't have + // style (e.g. the target element is not associated with any document). + if (aStyle) { + UpdateProperties(aStyle, aTimeline); + } +} + +void KeyframeEffect::ReplaceTransitionStartValue(AnimationValue&& aStartValue) { + if (!aStartValue.mServo) { + return; + } + + // A typical transition should have a single property and a single segment. + // + // (And for atypical transitions, that is, those updated by script, we don't + // apply the replacing behavior.) + if (mProperties.Length() != 1 || mProperties[0].mSegments.Length() != 1) { + return; + } + + // Likewise, check that the keyframes are of the expected shape. + if (mKeyframes.Length() != 2 || mKeyframes[0].mPropertyValues.Length() != 1) { + return; + } + + // Check that the value we are about to substitute in is actually for the + // same property. + AnimatedPropertyID property(eCSSProperty_UNKNOWN); + Servo_AnimationValue_GetPropertyId(aStartValue.mServo, &property); + if (property != mProperties[0].mProperty) { + return; + } + + mKeyframes[0].mPropertyValues[0].mServoDeclarationBlock = + Servo_AnimationValue_Uncompute(aStartValue.mServo).Consume(); + mProperties[0].mSegments[0].mFromValue = std::move(aStartValue); +} + +static bool IsEffectiveProperty(const EffectSet& aEffects, + const AnimatedPropertyID& aProperty) { + return !aEffects.PropertiesWithImportantRules().HasProperty(aProperty) || + !aEffects.PropertiesForAnimationsLevel().HasProperty(aProperty); +} + +const AnimationProperty* KeyframeEffect::GetEffectiveAnimationOfProperty( + const AnimatedPropertyID& aProperty, const EffectSet& aEffects) const { + MOZ_ASSERT(mTarget && &aEffects == EffectSet::Get(mTarget.mElement, + mTarget.mPseudoType)); + + for (const AnimationProperty& property : mProperties) { + if (aProperty != property.mProperty) { + continue; + } + + // Only include the property if it is not overridden by !important rules in + // the transitions level. + return IsEffectiveProperty(aEffects, property.mProperty) ? &property + : nullptr; + } + return nullptr; +} + +bool KeyframeEffect::HasEffectiveAnimationOfPropertySet( + const nsCSSPropertyIDSet& aPropertySet, const EffectSet& aEffectSet) const { + for (const AnimationProperty& property : mProperties) { + if (aPropertySet.HasProperty(property.mProperty) && + IsEffectiveProperty(aEffectSet, property.mProperty)) { + return true; + } + } + return false; +} + +nsCSSPropertyIDSet KeyframeEffect::GetPropertiesForCompositor( + EffectSet& aEffects, const nsIFrame* aFrame) const { + MOZ_ASSERT(&aEffects == + EffectSet::Get(mTarget.mElement, mTarget.mPseudoType)); + + nsCSSPropertyIDSet properties; + + if (!mAnimation || !mAnimation->IsRelevant()) { + return properties; + } + + static constexpr nsCSSPropertyIDSet compositorAnimatables = + nsCSSPropertyIDSet::CompositorAnimatables(); + static constexpr nsCSSPropertyIDSet transformLikeProperties = + nsCSSPropertyIDSet::TransformLikeProperties(); + + nsCSSPropertyIDSet transformSet; + AnimationPerformanceWarning::Type dummyWarning; + + for (const AnimationProperty& property : mProperties) { + if (!compositorAnimatables.HasProperty(property.mProperty)) { + continue; + } + + // Transform-like properties are combined together on the compositor so we + // need to evaluate them as a group. We build up a separate set here then + // evaluate it as a separate step below. + if (transformLikeProperties.HasProperty(property.mProperty)) { + transformSet.AddProperty(property.mProperty.mID); + continue; + } + + KeyframeEffect::MatchForCompositor matchResult = + IsMatchForCompositor(nsCSSPropertyIDSet{property.mProperty.mID}, aFrame, + aEffects, dummyWarning); + if (matchResult == + KeyframeEffect::MatchForCompositor::NoAndBlockThisProperty || + matchResult == KeyframeEffect::MatchForCompositor::No) { + continue; + } + properties.AddProperty(property.mProperty.mID); + } + + if (!transformSet.IsEmpty()) { + KeyframeEffect::MatchForCompositor matchResult = + IsMatchForCompositor(transformSet, aFrame, aEffects, dummyWarning); + if (matchResult == KeyframeEffect::MatchForCompositor::Yes || + matchResult == KeyframeEffect::MatchForCompositor::IfNeeded) { + properties |= transformSet; + } + } + + return properties; +} + +AnimatedPropertyIDSet KeyframeEffect::GetPropertySet() const { + AnimatedPropertyIDSet result; + + for (const AnimationProperty& property : mProperties) { + result.AddProperty(property.mProperty); + } + + return result; +} + +#ifdef DEBUG +bool SpecifiedKeyframeArraysAreEqual(const nsTArray<Keyframe>& aA, + const nsTArray<Keyframe>& aB) { + if (aA.Length() != aB.Length()) { + return false; + } + + for (size_t i = 0; i < aA.Length(); i++) { + const Keyframe& a = aA[i]; + const Keyframe& b = aB[i]; + if (a.mOffset != b.mOffset || a.mTimingFunction != b.mTimingFunction || + a.mPropertyValues != b.mPropertyValues) { + return false; + } + } + + return true; +} +#endif + +static bool HasCurrentColor( + const nsTArray<AnimationPropertySegment>& aSegments) { + for (const AnimationPropertySegment& segment : aSegments) { + if ((!segment.mFromValue.IsNull() && segment.mFromValue.IsCurrentColor()) || + (!segment.mToValue.IsNull() && segment.mToValue.IsCurrentColor())) { + return true; + } + } + return false; +} +void KeyframeEffect::UpdateProperties(const ComputedStyle* aStyle, + const AnimationTimeline* aTimeline) { + MOZ_ASSERT(aStyle); + + nsTArray<AnimationProperty> properties = BuildProperties(aStyle); + + bool propertiesChanged = mProperties != properties; + + // We need to update base styles even if any properties are not changed at all + // since base styles might have been changed due to parent style changes, etc. + bool baseStylesChanged = false; + EnsureBaseStyles(aStyle, properties, aTimeline, + !propertiesChanged ? &baseStylesChanged : nullptr); + + if (!propertiesChanged) { + if (baseStylesChanged) { + RequestRestyle(EffectCompositor::RestyleType::Layer); + } + return; + } + + // Preserve the state of the mIsRunningOnCompositor flag. + nsCSSPropertyIDSet runningOnCompositorProperties; + + for (const AnimationProperty& property : mProperties) { + if (property.mIsRunningOnCompositor) { + runningOnCompositorProperties.AddProperty(property.mProperty.mID); + } + } + + mProperties = std::move(properties); + UpdateEffectSet(); + + mCumulativeChanges = {}; + for (AnimationProperty& property : mProperties) { + property.mIsRunningOnCompositor = + runningOnCompositorProperties.HasProperty(property.mProperty); + CalculateCumulativeChangesForProperty(property); + } + + MarkCascadeNeedsUpdate(); + + if (mAnimation) { + mAnimation->NotifyEffectPropertiesUpdated(); + } + + RequestRestyle(EffectCompositor::RestyleType::Layer); +} + +void KeyframeEffect::EnsureBaseStyles( + const ComputedStyle* aComputedValues, + const nsTArray<AnimationProperty>& aProperties, + const AnimationTimeline* aTimeline, bool* aBaseStylesChanged) { + if (aBaseStylesChanged != nullptr) { + *aBaseStylesChanged = false; + } + + if (!mTarget) { + return; + } + + BaseValuesHashmap previousBaseStyles; + if (aBaseStylesChanged != nullptr) { + previousBaseStyles = std::move(mBaseValues); + } + + mBaseValues.Clear(); + + nsPresContext* presContext = + nsContentUtils::GetContextForContent(mTarget.mElement); + // If |aProperties| is empty we're not going to dereference |presContext| so + // we don't care if it is nullptr. + // + // We could just return early when |aProperties| is empty and save looking up + // the pres context, but that won't save any effort normally since we don't + // call this function if we have no keyframes to begin with. Furthermore, the + // case where |presContext| is nullptr is so rare (we've only ever seen in + // fuzzing, and even then we've never been able to reproduce it reliably) + // it's not worth the runtime cost of an extra branch. + MOZ_ASSERT(presContext || aProperties.IsEmpty(), + "Typically presContext should not be nullptr but if it is" + " we should have also failed to calculate the computed values" + " passed-in as aProperties"); + + if (!aTimeline) { + // If we pass a valid timeline, we use it (note: this happens when we create + // a new animation or replace the old one, for CSS Animations and CSS + // Transitions). Otherwise, we check the timeline from |mAnimation|. + aTimeline = mAnimation ? mAnimation->GetTimeline() : nullptr; + } + + RefPtr<const ComputedStyle> baseComputedStyle; + for (const AnimationProperty& property : aProperties) { + EnsureBaseStyle(property, presContext, aComputedValues, aTimeline, + baseComputedStyle); + } + + if (aBaseStylesChanged != nullptr && + std::any_of( + mBaseValues.cbegin(), mBaseValues.cend(), [&](const auto& entry) { + return AnimationValue(entry.GetData()) != + AnimationValue(previousBaseStyles.Get(entry.GetKey())); + })) { + *aBaseStylesChanged = true; + } +} + +void KeyframeEffect::EnsureBaseStyle( + const AnimationProperty& aProperty, nsPresContext* aPresContext, + const ComputedStyle* aComputedStyle, const AnimationTimeline* aTimeline, + RefPtr<const ComputedStyle>& aBaseComputedStyle) { + auto needBaseStyleForScrollTimeline = + [this](const AnimationProperty& aProperty, + const AnimationTimeline* aTimeline) { + static constexpr TimeDuration zeroDuration; + const TimingParams& timing = NormalizedTiming(); + // For scroll-timeline with a positive delay, it's possible to scroll + // back and forth between delay phase and active phase, so we need to + // keep its base style and maybe use it to override the animations in + // delay on the compositor. + return aTimeline && aTimeline->IsScrollTimeline() && + nsCSSPropertyIDSet::CompositorAnimatables().HasProperty( + aProperty.mProperty) && + (timing.Delay() > zeroDuration || + timing.EndDelay() > zeroDuration); + }; + auto hasAdditiveValues = [](const AnimationProperty& aProperty) { + for (const AnimationPropertySegment& segment : aProperty.mSegments) { + if (!segment.HasReplaceableValues()) { + return true; + } + } + return false; + }; + + // Note: Check base style for compositor (i.e. for scroll-driven animations) + // first because it is much cleaper. + const bool needBaseStyle = + needBaseStyleForScrollTimeline(aProperty, aTimeline) || + hasAdditiveValues(aProperty); + if (!needBaseStyle) { + return; + } + + if (!aBaseComputedStyle) { + MOZ_ASSERT(mTarget, "Should have a valid target"); + + Element* animatingElement = AnimationUtils::GetElementForRestyle( + mTarget.mElement, mTarget.mPseudoType); + if (!animatingElement) { + return; + } + aBaseComputedStyle = aPresContext->StyleSet()->GetBaseContextForElement( + animatingElement, aComputedStyle); + } + RefPtr<StyleAnimationValue> baseValue = + Servo_ComputedValues_ExtractAnimationValue(aBaseComputedStyle, + &aProperty.mProperty) + .Consume(); + mBaseValues.InsertOrUpdate(aProperty.mProperty, std::move(baseValue)); +} + +void KeyframeEffect::WillComposeStyle() { + ComputedTiming computedTiming = GetComputedTiming(); + mProgressOnLastCompose = computedTiming.mProgress; + mCurrentIterationOnLastCompose = computedTiming.mCurrentIteration; +} + +void KeyframeEffect::ComposeStyleRule(StyleAnimationValueMap& aAnimationValues, + const AnimationProperty& aProperty, + const AnimationPropertySegment& aSegment, + const ComputedTiming& aComputedTiming) { + auto* opaqueTable = + reinterpret_cast<RawServoAnimationValueTable*>(&mBaseValues); + Servo_AnimationCompose(&aAnimationValues, opaqueTable, &aProperty.mProperty, + &aSegment, &aProperty.mSegments.LastElement(), + &aComputedTiming, mEffectOptions.mIterationComposite); +} + +void KeyframeEffect::ComposeStyle(StyleAnimationValueMap& aComposeResult, + const nsCSSPropertyIDSet& aPropertiesToSkip) { + ComputedTiming computedTiming = GetComputedTiming(); + + // If the progress is null, we don't have fill data for the current + // time so we shouldn't animate. + if (computedTiming.mProgress.IsNull()) { + return; + } + + for (size_t propIdx = 0, propEnd = mProperties.Length(); propIdx != propEnd; + ++propIdx) { + const AnimationProperty& prop = mProperties[propIdx]; + + MOZ_ASSERT(prop.mSegments[0].mFromKey == 0.0, "incorrect first from key"); + MOZ_ASSERT(prop.mSegments[prop.mSegments.Length() - 1].mToKey == 1.0, + "incorrect last to key"); + + if (aPropertiesToSkip.HasProperty(prop.mProperty)) { + continue; + } + + MOZ_ASSERT(prop.mSegments.Length() > 0, + "property should not be in animations if it has no segments"); + + // FIXME: Maybe cache the current segment? + const AnimationPropertySegment *segment = prop.mSegments.Elements(), + *segmentEnd = + segment + prop.mSegments.Length(); + while (segment->mToKey <= computedTiming.mProgress.Value()) { + MOZ_ASSERT(segment->mFromKey <= segment->mToKey, "incorrect keys"); + if ((segment + 1) == segmentEnd) { + break; + } + ++segment; + MOZ_ASSERT(segment->mFromKey == (segment - 1)->mToKey, "incorrect keys"); + } + MOZ_ASSERT(segment->mFromKey <= segment->mToKey, "incorrect keys"); + MOZ_ASSERT(segment >= prop.mSegments.Elements() && + size_t(segment - prop.mSegments.Elements()) < + prop.mSegments.Length(), + "out of array bounds"); + + ComposeStyleRule(aComposeResult, prop, *segment, computedTiming); + } + + // If the animation produces a change hint that affects the overflow region, + // we need to record the current time to unthrottle the animation + // periodically when the animation is being throttled because it's scrolled + // out of view. + if (HasPropertiesThatMightAffectOverflow()) { + nsPresContext* presContext = + nsContentUtils::GetContextForContent(mTarget.mElement); + EffectSet* effectSet = + EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + if (presContext && effectSet) { + TimeStamp now = presContext->RefreshDriver()->MostRecentRefresh(); + effectSet->UpdateLastOverflowAnimationSyncTime(now); + } + } +} + +bool KeyframeEffect::IsRunningOnCompositor() const { + // We consider animation is running on compositor if there is at least + // one property running on compositor. + // Animation.IsRunningOnCompotitor will return more fine grained + // information in bug 1196114. + for (const AnimationProperty& property : mProperties) { + if (property.mIsRunningOnCompositor) { + return true; + } + } + return false; +} + +void KeyframeEffect::SetIsRunningOnCompositor(nsCSSPropertyID aProperty, + bool aIsRunning) { + MOZ_ASSERT(aProperty != eCSSPropertyExtra_variable, + "Can't animate variables on compositor"); + MOZ_ASSERT( + nsCSSProps::PropHasFlags(aProperty, CSSPropFlags::CanAnimateOnCompositor), + "Property being animated on compositor is not a recognized " + "compositor-animatable property"); + + for (AnimationProperty& property : mProperties) { + if (property.mProperty.mID == aProperty) { + property.mIsRunningOnCompositor = aIsRunning; + // We currently only set a performance warning message when animations + // cannot be run on the compositor, so if this animation is running + // on the compositor we don't need a message. + if (aIsRunning) { + property.mPerformanceWarning.reset(); + } else if (mAnimation && mAnimation->IsPartialPrerendered()) { + ResetPartialPrerendered(); + } + return; + } + } +} + +void KeyframeEffect::SetIsRunningOnCompositor( + const nsCSSPropertyIDSet& aPropertySet, bool aIsRunning) { + for (AnimationProperty& property : mProperties) { + if (aPropertySet.HasProperty(property.mProperty)) { + MOZ_ASSERT(nsCSSProps::PropHasFlags(property.mProperty.mID, + CSSPropFlags::CanAnimateOnCompositor), + "Property being animated on compositor is a recognized " + "compositor-animatable property"); + property.mIsRunningOnCompositor = aIsRunning; + // We currently only set a performance warning message when animations + // cannot be run on the compositor, so if this animation is running + // on the compositor we don't need a message. + if (aIsRunning) { + property.mPerformanceWarning.reset(); + } + } + } + + if (!aIsRunning && mAnimation && mAnimation->IsPartialPrerendered()) { + ResetPartialPrerendered(); + } +} + +void KeyframeEffect::ResetIsRunningOnCompositor() { + for (AnimationProperty& property : mProperties) { + property.mIsRunningOnCompositor = false; + } + + if (mAnimation && mAnimation->IsPartialPrerendered()) { + ResetPartialPrerendered(); + } +} + +void KeyframeEffect::ResetPartialPrerendered() { + MOZ_ASSERT(mAnimation && mAnimation->IsPartialPrerendered()); + + nsIFrame* frame = GetPrimaryFrame(); + if (!frame) { + return; + } + + nsIWidget* widget = frame->GetNearestWidget(); + if (!widget) { + return; + } + + if (WindowRenderer* windowRenderer = widget->GetWindowRenderer()) { + windowRenderer->RemovePartialPrerenderedAnimation( + mAnimation->IdOnCompositor(), mAnimation); + } +} + +static const KeyframeEffectOptions& KeyframeEffectOptionsFromUnion( + const UnrestrictedDoubleOrKeyframeEffectOptions& aOptions) { + MOZ_ASSERT(aOptions.IsKeyframeEffectOptions()); + return aOptions.GetAsKeyframeEffectOptions(); +} + +static const KeyframeEffectOptions& KeyframeEffectOptionsFromUnion( + const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions) { + MOZ_ASSERT(aOptions.IsKeyframeAnimationOptions()); + return aOptions.GetAsKeyframeAnimationOptions(); +} + +template <class OptionsType> +static KeyframeEffectParams KeyframeEffectParamsFromUnion( + const OptionsType& aOptions, CallerType aCallerType, ErrorResult& aRv) { + KeyframeEffectParams result; + if (aOptions.IsUnrestrictedDouble()) { + return result; + } + + const KeyframeEffectOptions& options = + KeyframeEffectOptionsFromUnion(aOptions); + + // If dom.animations-api.compositing.enabled is turned off, + // iterationComposite and composite are the default value 'replace' in the + // dictionary. + result.mIterationComposite = options.mIterationComposite; + result.mComposite = options.mComposite; + + result.mPseudoType = PseudoStyleType::NotPseudo; + if (DOMStringIsNull(options.mPseudoElement)) { + return result; + } + + Maybe<PseudoStyleType> pseudoType = + nsCSSPseudoElements::GetPseudoType(options.mPseudoElement); + if (!pseudoType) { + // Per the spec, we throw SyntaxError for syntactically invalid pseudos. + aRv.ThrowSyntaxError( + nsPrintfCString("'%s' is a syntactically invalid pseudo-element.", + NS_ConvertUTF16toUTF8(options.mPseudoElement).get())); + return result; + } + + result.mPseudoType = *pseudoType; + if (!AnimationUtils::IsSupportedPseudoForAnimations(result.mPseudoType)) { + // Per the spec, we throw SyntaxError for unsupported pseudos. + aRv.ThrowSyntaxError( + nsPrintfCString("'%s' is an unsupported pseudo-element.", + NS_ConvertUTF16toUTF8(options.mPseudoElement).get())); + } + + return result; +} + +template <class OptionsType> +/* static */ +already_AddRefed<KeyframeEffect> KeyframeEffect::ConstructKeyframeEffect( + const GlobalObject& aGlobal, Element* aTarget, + JS::Handle<JSObject*> aKeyframes, const OptionsType& aOptions, + ErrorResult& aRv) { + // We should get the document from `aGlobal` instead of the current Realm + // to make this works in Xray case. + // + // In all non-Xray cases, `aGlobal` matches the current Realm, so this + // matches the spec behavior. + // + // In Xray case, the new objects should be created using the document of + // the target global, but the KeyframeEffect constructors are called in the + // caller's compartment to access `aKeyframes` object. + Document* doc = AnimationUtils::GetDocumentFromGlobal(aGlobal.Get()); + if (!doc) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + KeyframeEffectParams effectOptions = + KeyframeEffectParamsFromUnion(aOptions, aGlobal.CallerType(), aRv); + // An invalid Pseudo-element aborts all further steps. + if (aRv.Failed()) { + return nullptr; + } + + TimingParams timingParams = TimingParams::FromOptionsUnion(aOptions, aRv); + if (aRv.Failed()) { + return nullptr; + } + + RefPtr<KeyframeEffect> effect = new KeyframeEffect( + doc, OwningAnimationTarget(aTarget, effectOptions.mPseudoType), + std::move(timingParams), effectOptions); + + effect->SetKeyframes(aGlobal.Context(), aKeyframes, aRv); + if (aRv.Failed()) { + return nullptr; + } + + return effect.forget(); +} + +nsTArray<AnimationProperty> KeyframeEffect::BuildProperties( + const ComputedStyle* aStyle) { + MOZ_ASSERT(aStyle); + + nsTArray<AnimationProperty> result; + // If mTarget is false (i.e. mTarget.mElement is null), return an empty + // property array. + if (!mTarget) { + return result; + } + + // When GetComputedKeyframeValues or GetAnimationPropertiesFromKeyframes + // calculate computed values from |mKeyframes|, they could possibly + // trigger a subsequent restyle in which we rebuild animations. If that + // happens we could find that |mKeyframes| is overwritten while it is + // being iterated over. Normally that shouldn't happen but just in case we + // make a copy of |mKeyframes| first and iterate over that instead. + auto keyframesCopy(mKeyframes.Clone()); + + result = KeyframeUtils::GetAnimationPropertiesFromKeyframes( + keyframesCopy, mTarget.mElement, mTarget.mPseudoType, aStyle, + mEffectOptions.mComposite); + +#ifdef DEBUG + MOZ_ASSERT(SpecifiedKeyframeArraysAreEqual(mKeyframes, keyframesCopy), + "Apart from the computed offset members, the keyframes array" + " should not be modified"); +#endif + + mKeyframes = std::move(keyframesCopy); + return result; +} + +template <typename FrameEnumFunc> +static void EnumerateContinuationsOrIBSplitSiblings(nsIFrame* aFrame, + FrameEnumFunc&& aFunc) { + while (aFrame) { + aFunc(aFrame); + aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame); + } +} + +void KeyframeEffect::UpdateTarget(Element* aElement, + PseudoStyleType aPseudoType) { + OwningAnimationTarget newTarget(aElement, aPseudoType); + + if (mTarget == newTarget) { + // Assign the same target, skip it. + return; + } + + if (mTarget) { + // Call ResetIsRunningOnCompositor() prior to UnregisterTarget() since + // ResetIsRunningOnCompositor() might try to get the EffectSet associated + // with this keyframe effect to remove partial pre-render animation from + // the layer manager. + ResetIsRunningOnCompositor(); + UnregisterTarget(); + + RequestRestyle(EffectCompositor::RestyleType::Layer); + + nsAutoAnimationMutationBatch mb(mTarget.mElement->OwnerDoc()); + if (mAnimation) { + MutationObservers::NotifyAnimationRemoved(mAnimation); + } + } + + mTarget = newTarget; + + if (mTarget) { + UpdateTargetRegistration(); + RefPtr<const ComputedStyle> computedStyle = + GetTargetComputedStyle(Flush::None); + if (computedStyle) { + UpdateProperties(computedStyle); + } + + RequestRestyle(EffectCompositor::RestyleType::Layer); + + nsAutoAnimationMutationBatch mb(mTarget.mElement->OwnerDoc()); + if (mAnimation) { + MutationObservers::NotifyAnimationAdded(mAnimation); + } + } + + if (mAnimation) { + mAnimation->NotifyEffectTargetUpdated(); + } +} + +void KeyframeEffect::UpdateTargetRegistration() { + if (!mTarget) { + return; + } + + bool isRelevant = mAnimation && mAnimation->IsRelevant(); + + // Animation::IsRelevant() returns a cached value. It only updates when + // something calls Animation::UpdateRelevance. Whenever our timing changes, + // we should be notifying our Animation before calling this, so + // Animation::IsRelevant() should be up-to-date by the time we get here. + MOZ_ASSERT(isRelevant == + ((IsCurrent() || IsInEffect()) && mAnimation && + mAnimation->ReplaceState() != AnimationReplaceState::Removed), + "Out of date Animation::IsRelevant value"); + + if (isRelevant && !mInEffectSet) { + EffectSet* effectSet = + EffectSet::GetOrCreate(mTarget.mElement, mTarget.mPseudoType); + effectSet->AddEffect(*this); + mInEffectSet = true; + UpdateEffectSet(effectSet); + nsIFrame* frame = GetPrimaryFrame(); + EnumerateContinuationsOrIBSplitSiblings( + frame, [](nsIFrame* aFrame) { aFrame->MarkNeedsDisplayItemRebuild(); }); + } else if (!isRelevant && mInEffectSet) { + UnregisterTarget(); + } +} + +void KeyframeEffect::UnregisterTarget() { + if (!mInEffectSet) { + return; + } + + EffectSet* effectSet = EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + MOZ_ASSERT(effectSet, + "If mInEffectSet is true, there must be an EffectSet" + " on the target element"); + mInEffectSet = false; + if (effectSet) { + effectSet->RemoveEffect(*this); + + if (effectSet->IsEmpty()) { + EffectSet::DestroyEffectSet(mTarget.mElement, mTarget.mPseudoType); + } + } + nsIFrame* frame = GetPrimaryFrame(); + EnumerateContinuationsOrIBSplitSiblings( + frame, [](nsIFrame* aFrame) { aFrame->MarkNeedsDisplayItemRebuild(); }); +} + +void KeyframeEffect::RequestRestyle( + EffectCompositor::RestyleType aRestyleType) { + if (!mTarget) { + return; + } + nsPresContext* presContext = + nsContentUtils::GetContextForContent(mTarget.mElement); + if (presContext && mAnimation) { + presContext->EffectCompositor()->RequestRestyle( + mTarget.mElement, mTarget.mPseudoType, aRestyleType, + mAnimation->CascadeLevel()); + } +} + +already_AddRefed<const ComputedStyle> KeyframeEffect::GetTargetComputedStyle( + Flush aFlushType) const { + if (!GetRenderedDocument()) { + return nullptr; + } + + MOZ_ASSERT(mTarget, + "Should only have a document when we have a target element"); + + OwningAnimationTarget kungfuDeathGrip(mTarget.mElement, mTarget.mPseudoType); + + return aFlushType == Flush::Style + ? nsComputedDOMStyle::GetComputedStyle(mTarget.mElement, + mTarget.mPseudoType) + : nsComputedDOMStyle::GetComputedStyleNoFlush(mTarget.mElement, + mTarget.mPseudoType); +} + +#ifdef DEBUG +void DumpAnimationProperties( + const StylePerDocumentStyleData* aRawData, + nsTArray<AnimationProperty>& aAnimationProperties) { + for (auto& p : aAnimationProperties) { + printf("%s\n", + nsCString(nsCSSProps::GetStringValue(p.mProperty.mID)).get()); + for (auto& s : p.mSegments) { + nsAutoCString fromValue, toValue; + s.mFromValue.SerializeSpecifiedValue(p.mProperty, aRawData, fromValue); + s.mToValue.SerializeSpecifiedValue(p.mProperty, aRawData, toValue); + printf(" %f..%f: %s..%s\n", s.mFromKey, s.mToKey, fromValue.get(), + toValue.get()); + } + } +} +#endif + +/* static */ +already_AddRefed<KeyframeEffect> KeyframeEffect::Constructor( + const GlobalObject& aGlobal, Element* aTarget, + JS::Handle<JSObject*> aKeyframes, + const UnrestrictedDoubleOrKeyframeEffectOptions& aOptions, + ErrorResult& aRv) { + return ConstructKeyframeEffect(aGlobal, aTarget, aKeyframes, aOptions, aRv); +} + +/* static */ +already_AddRefed<KeyframeEffect> KeyframeEffect::Constructor( + const GlobalObject& aGlobal, Element* aTarget, + JS::Handle<JSObject*> aKeyframes, + const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions, + ErrorResult& aRv) { + return ConstructKeyframeEffect(aGlobal, aTarget, aKeyframes, aOptions, aRv); +} + +/* static */ +already_AddRefed<KeyframeEffect> KeyframeEffect::Constructor( + const GlobalObject& aGlobal, KeyframeEffect& aSource, ErrorResult& aRv) { + Document* doc = AnimationUtils::GetCurrentRealmDocument(aGlobal.Context()); + if (!doc) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + // Create a new KeyframeEffect object with aSource's target, + // iteration composite operation, composite operation, and spacing mode. + // The constructor creates a new AnimationEffect object by + // aSource's TimingParams. + // Note: we don't need to re-throw exceptions since the value specified on + // aSource's timing object can be assumed valid. + RefPtr<KeyframeEffect> effect = + new KeyframeEffect(doc, OwningAnimationTarget{aSource.mTarget}, aSource); + // Copy cumulative changes. mCumulativeChangeHint should be the same as the + // source one because both of targets are the same. + effect->mCumulativeChanges = aSource.mCumulativeChanges; + return effect.forget(); +} + +void KeyframeEffect::SetPseudoElement(const nsAString& aPseudoElement, + ErrorResult& aRv) { + if (DOMStringIsNull(aPseudoElement)) { + UpdateTarget(mTarget.mElement, PseudoStyleType::NotPseudo); + return; + } + + // Note: GetPseudoType() returns Some(NotPseudo) for the null string, + // so we handle null case before this. + Maybe<PseudoStyleType> pseudoType = + nsCSSPseudoElements::GetPseudoType(aPseudoElement); + if (!pseudoType || *pseudoType == PseudoStyleType::NotPseudo) { + // Per the spec, we throw SyntaxError for syntactically invalid pseudos. + aRv.ThrowSyntaxError( + nsPrintfCString("'%s' is a syntactically invalid pseudo-element.", + NS_ConvertUTF16toUTF8(aPseudoElement).get())); + return; + } + + if (!AnimationUtils::IsSupportedPseudoForAnimations(*pseudoType)) { + // Per the spec, we throw SyntaxError for unsupported pseudos. + aRv.ThrowSyntaxError( + nsPrintfCString("'%s' is an unsupported pseudo-element.", + NS_ConvertUTF16toUTF8(aPseudoElement).get())); + return; + } + + UpdateTarget(mTarget.mElement, *pseudoType); +} + +static void CreatePropertyValue( + const AnimatedPropertyID& aProperty, float aOffset, + const Maybe<StyleComputedTimingFunction>& aTimingFunction, + const AnimationValue& aValue, dom::CompositeOperation aComposite, + const StylePerDocumentStyleData* aRawData, + AnimationPropertyValueDetails& aResult) { + aResult.mOffset = aOffset; + + if (!aValue.IsNull()) { + nsAutoCString stringValue; + aValue.SerializeSpecifiedValue(aProperty, aRawData, stringValue); + aResult.mValue.Construct(stringValue); + } + + if (aTimingFunction) { + aResult.mEasing.Construct(); + aTimingFunction->AppendToString(aResult.mEasing.Value()); + } else { + aResult.mEasing.Construct("linear"_ns); + } + + aResult.mComposite = aComposite; +} + +void KeyframeEffect::GetProperties( + nsTArray<AnimationPropertyDetails>& aProperties, ErrorResult& aRv) const { + const StylePerDocumentStyleData* rawData = + mDocument->EnsureStyleSet().RawData(); + + for (const AnimationProperty& property : mProperties) { + AnimationPropertyDetails propertyDetails; + property.mProperty.ToString(propertyDetails.mProperty); + propertyDetails.mRunningOnCompositor = property.mIsRunningOnCompositor; + + nsAutoString localizedString; + if (property.mPerformanceWarning && + property.mPerformanceWarning->ToLocalizedString(localizedString)) { + propertyDetails.mWarning.Construct(localizedString); + } + + if (!propertyDetails.mValues.SetCapacity(property.mSegments.Length(), + mozilla::fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + for (size_t segmentIdx = 0, segmentLen = property.mSegments.Length(); + segmentIdx < segmentLen; segmentIdx++) { + const AnimationPropertySegment& segment = property.mSegments[segmentIdx]; + + binding_detail::FastAnimationPropertyValueDetails fromValue; + CreatePropertyValue(property.mProperty, segment.mFromKey, + segment.mTimingFunction, segment.mFromValue, + segment.mFromComposite, rawData, fromValue); + // We don't apply timing functions for zero-length segments, so + // don't return one here. + if (segment.mFromKey == segment.mToKey) { + fromValue.mEasing.Reset(); + } + // Even though we called SetCapacity before, this could fail, since we + // might add multiple elements to propertyDetails.mValues for an element + // of property.mSegments in the cases mentioned below. + if (!propertyDetails.mValues.AppendElement(fromValue, + mozilla::fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + // Normally we can ignore the to-value for this segment since it is + // identical to the from-value from the next segment. However, we need + // to add it if either: + // a) this is the last segment, or + // b) the next segment's from-value differs. + if (segmentIdx == segmentLen - 1 || + property.mSegments[segmentIdx + 1].mFromValue != segment.mToValue) { + binding_detail::FastAnimationPropertyValueDetails toValue; + CreatePropertyValue(property.mProperty, segment.mToKey, Nothing(), + segment.mToValue, segment.mToComposite, rawData, + toValue); + // It doesn't really make sense to have a timing function on the + // last property value or before a sudden jump so we just drop the + // easing property altogether. + toValue.mEasing.Reset(); + if (!propertyDetails.mValues.AppendElement(toValue, + mozilla::fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + } + } + + aProperties.AppendElement(propertyDetails); + } +} + +void KeyframeEffect::GetKeyframes(JSContext* aCx, nsTArray<JSObject*>& aResult, + ErrorResult& aRv) const { + MOZ_ASSERT(aResult.IsEmpty()); + MOZ_ASSERT(!aRv.Failed()); + + if (!aResult.SetCapacity(mKeyframes.Length(), mozilla::fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + + bool isCSSAnimation = mAnimation && mAnimation->AsCSSAnimation(); + + // For Servo, when we have CSS Animation @keyframes with variables, we convert + // shorthands to longhands if needed, and store a reference to the unparsed + // value. When it comes time to serialize, however, what do you serialize for + // a longhand that comes from a variable reference in a shorthand? Servo says, + // "an empty string" which is not particularly helpful. + // + // We should just store shorthands as-is (bug 1391537) and then return the + // variable references, but for now, since we don't do that, and in order to + // be consistent with Gecko, we just expand the variables (assuming we have + // enough context to do so). For that we need to grab the ComputedStyle so we + // know what custom property values to provide. + RefPtr<const ComputedStyle> computedStyle; + if (isCSSAnimation) { + // The following will flush style but that's ok since if you update a + // variable's computed value, you expect to see that updated value in the + // result of getKeyframes(). + // + // If we don't have a target, the following will return null. In that case + // we might end up returning variables as-is or empty string. That should be + // acceptable however, since such a case is rare and this is only + // short-term (and unshipped) behavior until bug 1391537 is fixed. + computedStyle = GetTargetComputedStyle(Flush::Style); + } + + const StylePerDocumentStyleData* rawData = + mDocument->EnsureStyleSet().RawData(); + + for (const Keyframe& keyframe : mKeyframes) { + // Set up a dictionary object for the explicit members + BaseComputedKeyframe keyframeDict; + if (keyframe.mOffset) { + keyframeDict.mOffset.SetValue(keyframe.mOffset.value()); + } + MOZ_ASSERT(keyframe.mComputedOffset != Keyframe::kComputedOffsetNotSet, + "Invalid computed offset"); + keyframeDict.mComputedOffset.Construct(keyframe.mComputedOffset); + if (keyframe.mTimingFunction) { + keyframeDict.mEasing.Truncate(); + keyframe.mTimingFunction.ref().AppendToString(keyframeDict.mEasing); + } // else if null, leave easing as its default "linear". + + // With the pref off (i.e. dom.animations-api.compositing.enabled:false), + // the dictionary-to-JS conversion will skip this member entirely. + keyframeDict.mComposite = keyframe.mComposite; + + JS::Rooted<JS::Value> keyframeJSValue(aCx); + if (!ToJSValue(aCx, keyframeDict, &keyframeJSValue)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + JS::Rooted<JSObject*> keyframeObject(aCx, &keyframeJSValue.toObject()); + for (const PropertyValuePair& propertyValue : keyframe.mPropertyValues) { + nsAutoCString stringValue; + if (propertyValue.mServoDeclarationBlock) { + Servo_DeclarationBlock_SerializeOneValue( + propertyValue.mServoDeclarationBlock, &propertyValue.mProperty, + &stringValue, computedStyle, rawData); + } else if (auto* value = mBaseValues.GetWeak(propertyValue.mProperty)) { + Servo_AnimationValue_Serialize(value, &propertyValue.mProperty, rawData, + &stringValue); + } + + // Basically, we need to do the mapping: + // * eCSSProperty_offset => "cssOffset" + // * eCSSProperty_float => "cssFloat" + // This means if property refers to the CSS "offset"/"float" property, + // return the string "cssOffset"/"cssFloat". (So avoid overlapping + // "offset" property in BaseKeyframe.) + // https://drafts.csswg.org/web-animations/#property-name-conversion + const char* name = nullptr; + nsAutoCString customName; + switch (propertyValue.mProperty.mID) { + case nsCSSPropertyID::eCSSPropertyExtra_variable: + customName.Append("--"); + customName.Append(nsAtomCString(propertyValue.mProperty.mCustomName)); + name = customName.get(); + break; + case nsCSSPropertyID::eCSSProperty_offset: + name = "cssOffset"; + break; + case nsCSSPropertyID::eCSSProperty_float: + // FIXME: Bug 1582314: Should handle cssFloat manually if we remove it + // from nsCSSProps::PropertyIDLName(). + default: + name = nsCSSProps::PropertyIDLName(propertyValue.mProperty.mID); + } + + JS::Rooted<JS::Value> value(aCx); + if (!NonVoidUTF8StringToJsval(aCx, stringValue, &value) || + !JS_DefineProperty(aCx, keyframeObject, name, value, + JSPROP_ENUMERATE)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + } + + aResult.AppendElement(keyframeObject); + } +} + +/* static */ const TimeDuration +KeyframeEffect::OverflowRegionRefreshInterval() { + // The amount of time we can wait between updating throttled animations + // on the main thread that influence the overflow region. + static const TimeDuration kOverflowRegionRefreshInterval = + TimeDuration::FromMilliseconds(200); + + return kOverflowRegionRefreshInterval; +} + +static bool CanOptimizeAwayDueToOpacity(const KeyframeEffect& aEffect, + const nsIFrame& aFrame) { + if (!aFrame.Style()->IsInOpacityZeroSubtree()) { + return false; + } + + // Find the root of the opacity: 0 subtree. + const nsIFrame* root = &aFrame; + while (true) { + auto* parent = root->GetInFlowParent(); + if (!parent || !parent->Style()->IsInOpacityZeroSubtree()) { + break; + } + root = parent; + } + + MOZ_ASSERT(root && root->Style()->IsInOpacityZeroSubtree()); + + // Even if we're in an opacity: zero subtree, if the root of the subtree may + // have an opacity animation, we can't optimize us away, as we may become + // visible ourselves. + return (root != &aFrame || !aEffect.HasOpacityChange()) && + !root->HasAnimationOfOpacity(); +} + +bool KeyframeEffect::CanThrottleIfNotVisible(nsIFrame& aFrame) const { + // Unless we are newly in-effect, 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 (!mInEffectOnLastAnimationTimingUpdate || !CanIgnoreIfNotVisible()) { + return false; + } + + PresShell* presShell = GetPresShell(); + if (presShell && !presShell->IsActive()) { + return true; + } + + const bool isVisibilityHidden = + !aFrame.IsVisibleOrMayHaveVisibleDescendants(); + const bool canOptimizeAwayVisibility = + isVisibilityHidden && !HasVisibilityChange(); + + const bool invisible = canOptimizeAwayVisibility || + CanOptimizeAwayDueToOpacity(*this, aFrame) || + aFrame.IsScrolledOutOfView(); + if (!invisible) { + return false; + } + + // If there are no overflow change hints, we don't need to worry about + // unthrottling the animation periodically to update scrollbar positions for + // the overflow region. + if (!HasPropertiesThatMightAffectOverflow()) { + return true; + } + + // Don't throttle finite animations since the animation might suddenly + // come into view and if it was throttled it will be out-of-sync. + if (HasFiniteActiveDuration()) { + return false; + } + + return isVisibilityHidden ? CanThrottleOverflowChangesInScrollable(aFrame) + : CanThrottleOverflowChanges(aFrame); +} + +bool KeyframeEffect::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* const frame = GetStyleFrame(); + 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; + } + + // Do not throttle any animations during print preview. + if (frame->PresContext()->IsPrintingOrPrintPreview()) { + return false; + } + + if (CanThrottleIfNotVisible(*frame)) { + return true; + } + + EffectSet* effectSet = nullptr; + for (const AnimationProperty& property : mProperties) { + if (!property.mIsRunningOnCompositor) { + return false; + } + + MOZ_ASSERT(nsCSSPropertyIDSet::CompositorAnimatables().HasProperty( + property.mProperty), + "The property should be able to run on the compositor"); + if (!effectSet) { + effectSet = EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + MOZ_ASSERT(effectSet, + "CanThrottle should be called on an effect " + "associated with a target element"); + } + MOZ_ASSERT(HasEffectiveAnimationOfProperty(property.mProperty, *effectSet), + "There should be an effective animation of the property while " + "it is marked as being run on the compositor"); + + DisplayItemType displayItemType = + LayerAnimationInfo::GetDisplayItemTypeForProperty( + property.mProperty.mID); + + // Note that AnimationInfo::GetGenarationFromFrame() is supposed to work + // with the primary frame instead of the style frame. + Maybe<uint64_t> generation = layers::AnimationInfo::GetGenerationFromFrame( + GetPrimaryFrame(), displayItemType); + // Unthrottle if the animation needs to be brought up to date + if (!generation || effectSet->GetAnimationGeneration() != *generation) { + return false; + } + + // If this is a transform animation that affects the overflow region, + // we should unthrottle the animation periodically. + if (HasPropertiesThatMightAffectOverflow() && + !CanThrottleOverflowChangesInScrollable(*frame)) { + return false; + } + } + + return true; +} + +bool KeyframeEffect::CanThrottleOverflowChanges(const nsIFrame& aFrame) const { + TimeStamp now = aFrame.PresContext()->RefreshDriver()->MostRecentRefresh(); + + EffectSet* effectSet = EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + MOZ_ASSERT(effectSet, + "CanOverflowTransformChanges is expected to be called" + " on an effect in an effect set"); + MOZ_ASSERT(mAnimation, + "CanOverflowTransformChanges is expected to be called" + " on an effect with a parent animation"); + TimeStamp lastSyncTime = effectSet->LastOverflowAnimationSyncTime(); + // If this animation can cause overflow, we can throttle some of the ticks. + return (!lastSyncTime.IsNull() && + (now - lastSyncTime) < OverflowRegionRefreshInterval()); +} + +bool KeyframeEffect::CanThrottleOverflowChangesInScrollable( + nsIFrame& aFrame) const { + // If the target element is not associated with any documents, we don't care + // it. + Document* doc = GetRenderedDocument(); + if (!doc) { + return true; + } + + // If we know that the animation cannot cause overflow, + // we can just disable flushes for this animation. + + // If we have no intersection observers, we don't care about overflow. + if (!doc->HasIntersectionObservers()) { + return true; + } + + if (CanThrottleOverflowChanges(aFrame)) { + return true; + } + + // If the nearest scrollable ancestor has overflow:hidden, + // we don't care about overflow. + nsIScrollableFrame* scrollable = + nsLayoutUtils::GetNearestScrollableFrame(&aFrame); + if (!scrollable) { + return true; + } + + ScrollStyles ss = scrollable->GetScrollStyles(); + if (ss.mVertical == StyleOverflow::Hidden && + ss.mHorizontal == StyleOverflow::Hidden && + scrollable->GetLogicalScrollPosition() == nsPoint(0, 0)) { + return true; + } + + return false; +} + +nsIFrame* KeyframeEffect::GetStyleFrame() const { + nsIFrame* frame = GetPrimaryFrame(); + if (!frame) { + return nullptr; + } + + return nsLayoutUtils::GetStyleFrame(frame); +} + +nsIFrame* KeyframeEffect::GetPrimaryFrame() const { + nsIFrame* frame = nullptr; + if (!mTarget) { + return frame; + } + + if (mTarget.mPseudoType == PseudoStyleType::before) { + frame = nsLayoutUtils::GetBeforeFrame(mTarget.mElement); + } else if (mTarget.mPseudoType == PseudoStyleType::after) { + frame = nsLayoutUtils::GetAfterFrame(mTarget.mElement); + } else if (mTarget.mPseudoType == PseudoStyleType::marker) { + frame = nsLayoutUtils::GetMarkerFrame(mTarget.mElement); + } else { + frame = mTarget.mElement->GetPrimaryFrame(); + MOZ_ASSERT(mTarget.mPseudoType == PseudoStyleType::NotPseudo, + "unknown mTarget.mPseudoType"); + } + + return frame; +} + +Document* KeyframeEffect::GetRenderedDocument() const { + if (!mTarget) { + return nullptr; + } + return mTarget.mElement->GetComposedDoc(); +} + +PresShell* KeyframeEffect::GetPresShell() const { + Document* doc = GetRenderedDocument(); + if (!doc) { + return nullptr; + } + return doc->GetPresShell(); +} + +/* static */ +bool KeyframeEffect::IsGeometricProperty(const nsCSSPropertyID aProperty) { + MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty), + "Property should be a longhand property"); + + switch (aProperty) { + case eCSSProperty_bottom: + case eCSSProperty_height: + case eCSSProperty_left: + case eCSSProperty_margin_bottom: + case eCSSProperty_margin_left: + case eCSSProperty_margin_right: + case eCSSProperty_margin_top: + case eCSSProperty_padding_bottom: + case eCSSProperty_padding_left: + case eCSSProperty_padding_right: + case eCSSProperty_padding_top: + case eCSSProperty_right: + case eCSSProperty_top: + case eCSSProperty_width: + return true; + default: + return false; + } +} + +/* static */ +bool KeyframeEffect::CanAnimateTransformOnCompositor( + const nsIFrame* aFrame, + AnimationPerformanceWarning::Type& aPerformanceWarning /* out */) { + // In some cases, such as when we are simply collecting all the compositor + // animations regardless of the frame on which they run in order to calculate + // change hints, |aFrame| will be the style frame. However, even in that case + // we should look at the primary frame since that is where the transform will + // be applied. + const nsIFrame* primaryFrame = + nsLayoutUtils::GetPrimaryFrameFromStyleFrame(aFrame); + + // Async 'transform' animations of aFrames with SVG transforms is not + // supported. See bug 779599. + if (primaryFrame->IsSVGTransformed()) { + aPerformanceWarning = AnimationPerformanceWarning::Type::TransformSVG; + return false; + } + + return true; +} + +bool KeyframeEffect::ShouldBlockAsyncTransformAnimations( + const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet, + AnimationPerformanceWarning::Type& aPerformanceWarning /* out */) const { + // If we depend on the SVG url (no matter whether there are any offset-path + // animations), we cannot run any transform-like animations in the compositor + // because we cannot resolve the url in the compositor if its style uses url. + if (aFrame->StyleDisplay()->mOffsetPath.IsUrl()) { + return true; + } + + EffectSet* effectSet = EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + // The various transform properties ('transform', 'scale' etc.) get combined + // on the compositor. + // + // As a result, if we have an animation of 'scale' and 'translate', but the + // 'translate' property is covered by an !important rule, we will not be + // able to combine the result on the compositor since we won't have the + // !important rule to incorporate. In that case we should run all the + // transform-related animations on the main thread (where we have the + // !important rule). + nsCSSPropertyIDSet blockedProperties = + effectSet->PropertiesWithImportantRules().Intersect( + effectSet->PropertiesForAnimationsLevel()); + if (blockedProperties.Intersects(aPropertySet)) { + aPerformanceWarning = + AnimationPerformanceWarning::Type::TransformIsBlockedByImportantRules; + return true; + } + + MOZ_ASSERT(mAnimation); + for (const AnimationProperty& property : mProperties) { + // If there is a property for animations level that is overridden by + // !important rules, it should not block other animations from running + // on the compositor. + // NOTE: We don't currently check for !important rules for properties that + // don't run on the compositor. As result such properties (e.g. margin-left) + // can still block async animations even if they are overridden by + // !important rules. + if (effectSet && + effectSet->PropertiesWithImportantRules().HasProperty( + property.mProperty) && + effectSet->PropertiesForAnimationsLevel().HasProperty( + property.mProperty)) { + continue; + } + + // Check for unsupported transform animations + if (LayerAnimationInfo::GetCSSPropertiesFor(DisplayItemType::TYPE_TRANSFORM) + .HasProperty(property.mProperty)) { + if (!CanAnimateTransformOnCompositor(aFrame, aPerformanceWarning)) { + return true; + } + } + + // If there are any offset-path animations whose animation values are url(), + // we have to sync with the main thread when resolving it. + if (property.mProperty.mID == eCSSProperty_offset_path) { + for (const auto& seg : property.mSegments) { + if (seg.mFromValue.IsOffsetPathUrl() || + seg.mToValue.IsOffsetPathUrl()) { + return true; + } + } + } + } + + return false; +} + +bool KeyframeEffect::HasGeometricProperties() const { + for (const AnimationProperty& property : mProperties) { + if (IsGeometricProperty(property.mProperty.mID)) { + return true; + } + } + + return false; +} + +void KeyframeEffect::SetPerformanceWarning( + const nsCSSPropertyIDSet& aPropertySet, + const AnimationPerformanceWarning& aWarning) { + nsCSSPropertyIDSet curr = aPropertySet; + for (AnimationProperty& property : mProperties) { + if (!curr.HasProperty(property.mProperty)) { + continue; + } + property.SetPerformanceWarning(aWarning, mTarget.mElement); + curr.RemoveProperty(property.mProperty.mID); + if (curr.IsEmpty()) { + return; + } + } +} + +void KeyframeEffect::CalculateCumulativeChangesForProperty( + const AnimationProperty& aProperty) { + if (aProperty.mProperty.IsCustom()) { + // Custom properties don't affect rendering on their own. + return; + } + + constexpr auto kInterestingFlags = + CSSPropFlags::AffectsLayout | CSSPropFlags::AffectsOverflow; + if (aProperty.mProperty.mID == eCSSProperty_opacity) { + mCumulativeChanges.mOpacity = true; + return; // We know opacity is visual-only. + } + + if (aProperty.mProperty.mID == eCSSProperty_visibility) { + mCumulativeChanges.mVisibility = true; + return; // We know visibility is visual-only. + } + + if (aProperty.mProperty.mID == eCSSProperty_background_color) { + if (!mCumulativeChanges.mHasBackgroundColorCurrentColor) { + mCumulativeChanges.mHasBackgroundColorCurrentColor = + HasCurrentColor(aProperty.mSegments); + } + return; // We know background-color is visual-only. + } + + auto flags = nsCSSProps::PropFlags(aProperty.mProperty.mID); + if (!(flags & kInterestingFlags)) { + return; // Property is visual-only. + } + + bool anyChange = false; + for (const AnimationPropertySegment& segment : aProperty.mSegments) { + if (!segment.HasReplaceableValues() || + segment.mFromValue != segment.mToValue) { + // We can't know non-replaceable values until we compose the animation, so + // assume a change there. + anyChange = true; + break; + } + } + + if (!anyChange) { + return; + } + + mCumulativeChanges.mOverflow |= bool(flags & CSSPropFlags::AffectsOverflow); + mCumulativeChanges.mLayout |= bool(flags & CSSPropFlags::AffectsLayout); +} + +void KeyframeEffect::SetAnimation(Animation* aAnimation) { + if (mAnimation == aAnimation) { + return; + } + + // Restyle for the old animation. + RequestRestyle(EffectCompositor::RestyleType::Layer); + + mAnimation = aAnimation; + + UpdateNormalizedTiming(); + + // The order of these function calls is important: + // NotifyAnimationTimingUpdated() need the updated mIsRelevant flag to check + // if it should create the effectSet or not, and MarkCascadeNeedsUpdate() + // needs a valid effectSet, so we should call them in this order. + if (mAnimation) { + mAnimation->UpdateRelevance(); + } + NotifyAnimationTimingUpdated(PostRestyleMode::IfNeeded); + if (mAnimation) { + MarkCascadeNeedsUpdate(); + } +} + +bool KeyframeEffect::CanIgnoreIfNotVisible() const { + if (!StaticPrefs::dom_animations_offscreen_throttling()) { + return false; + } + return !mCumulativeChanges.mLayout; +} + +void KeyframeEffect::MarkCascadeNeedsUpdate() { + if (!mTarget) { + return; + } + + EffectSet* effectSet = EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + if (!effectSet) { + return; + } + effectSet->MarkCascadeNeedsUpdate(); +} + +/* static */ +bool KeyframeEffect::HasComputedTimingChanged( + const ComputedTiming& aComputedTiming, + IterationCompositeOperation aIterationComposite, + const Nullable<double>& aProgressOnLastCompose, + uint64_t aCurrentIterationOnLastCompose) { + // Typically we don't need to request a restyle if the progress hasn't + // changed since the last call to ComposeStyle. The one exception is if the + // iteration composite mode is 'accumulate' and the current iteration has + // changed, since that will often produce a different result. + return aComputedTiming.mProgress != aProgressOnLastCompose || + (aIterationComposite == IterationCompositeOperation::Accumulate && + aComputedTiming.mCurrentIteration != aCurrentIterationOnLastCompose); +} + +bool KeyframeEffect::HasComputedTimingChanged() const { + ComputedTiming computedTiming = GetComputedTiming(); + return HasComputedTimingChanged( + computedTiming, mEffectOptions.mIterationComposite, + mProgressOnLastCompose, mCurrentIterationOnLastCompose); +} + +bool KeyframeEffect::ContainsAnimatedScale(const nsIFrame* aFrame) const { + // For display:table content, transform animations run on the table wrapper + // frame. If we are being passed a frame that doesn't support transforms + // (i.e. the inner table frame) we could just return false, but it possibly + // means we looked up the wrong EffectSet so for now we just assert instead. + MOZ_ASSERT(aFrame && aFrame->SupportsCSSTransforms(), + "We should be passed a frame that supports transforms"); + + if (!IsCurrent()) { + return false; + } + + if (!mAnimation || + mAnimation->ReplaceState() == AnimationReplaceState::Removed) { + return false; + } + + for (const AnimationProperty& prop : mProperties) { + if (prop.mProperty.mID != eCSSProperty_transform && + prop.mProperty.mID != eCSSProperty_scale && + prop.mProperty.mID != eCSSProperty_rotate) { + continue; + } + + AnimationValue baseStyle = BaseStyle(prop.mProperty); + if (!baseStyle.IsNull()) { + gfx::MatrixScales size = baseStyle.GetScaleValue(aFrame); + if (size != gfx::MatrixScales()) { + return true; + } + } + + // This is actually overestimate because there are some cases that combining + // the base value and from/to value produces 1:1 scale. But it doesn't + // really matter. + for (const AnimationPropertySegment& segment : prop.mSegments) { + if (!segment.mFromValue.IsNull()) { + gfx::MatrixScales from = segment.mFromValue.GetScaleValue(aFrame); + if (from != gfx::MatrixScales()) { + return true; + } + } + if (!segment.mToValue.IsNull()) { + gfx::MatrixScales to = segment.mToValue.GetScaleValue(aFrame); + if (to != gfx::MatrixScales()) { + return true; + } + } + } + } + + return false; +} + +void KeyframeEffect::UpdateEffectSet(EffectSet* aEffectSet) const { + if (!mInEffectSet) { + return; + } + + EffectSet* effectSet = + aEffectSet ? aEffectSet + : EffectSet::Get(mTarget.mElement, mTarget.mPseudoType); + if (!effectSet) { + return; + } + + nsIFrame* styleFrame = GetStyleFrame(); + if (HasAnimationOfPropertySet(nsCSSPropertyIDSet::OpacityProperties())) { + effectSet->SetMayHaveOpacityAnimation(); + EnumerateContinuationsOrIBSplitSiblings(styleFrame, [](nsIFrame* aFrame) { + aFrame->SetMayHaveOpacityAnimation(); + }); + } + + nsIFrame* primaryFrame = GetPrimaryFrame(); + if (HasAnimationOfPropertySet( + nsCSSPropertyIDSet::TransformLikeProperties())) { + effectSet->SetMayHaveTransformAnimation(); + // For table frames, it's not clear if we should iterate over the + // continuations of the table wrapper or the inner table frame. + // + // Fortunately, this is not currently an issue because we only split tables + // when printing (page breaks) where we don't run animations. + EnumerateContinuationsOrIBSplitSiblings(primaryFrame, [](nsIFrame* aFrame) { + aFrame->SetMayHaveTransformAnimation(); + }); + } +} + +KeyframeEffect::MatchForCompositor KeyframeEffect::IsMatchForCompositor( + const nsCSSPropertyIDSet& aPropertySet, const nsIFrame* aFrame, + const EffectSet& aEffects, + AnimationPerformanceWarning::Type& aPerformanceWarning /* out */) const { + MOZ_ASSERT(mAnimation); + + if (!mAnimation->IsRelevant()) { + return KeyframeEffect::MatchForCompositor::No; + } + + if (mAnimation->ShouldBeSynchronizedWithMainThread(aPropertySet, aFrame, + aPerformanceWarning)) { + // For a given |aFrame|, we don't want some animations of |aProperty| to + // run on the compositor and others to run on the main thread, so if any + // need to be synchronized with the main thread, run them all there. + return KeyframeEffect::MatchForCompositor::NoAndBlockThisProperty; + } + + if (mAnimation->UsingScrollTimeline()) { + const ScrollTimeline* scrollTimeline = + mAnimation->GetTimeline()->AsScrollTimeline(); + // We don't send this animation to the compositor if + // 1. the APZ is disabled entirely or for the source, or + // 2. the associated scroll-timeline is inactive, or + // 3. the scrolling direction is not available (i.e. no scroll range). + // 4. the scroll style of the scroller is overflow:hidden. + if (!scrollTimeline->APZIsActiveForSource() || + !scrollTimeline->IsActive() || + !scrollTimeline->ScrollingDirectionIsAvailable() || + scrollTimeline->SourceScrollStyle() == StyleOverflow::Hidden) { + return KeyframeEffect::MatchForCompositor::No; + } + + // FIXME: Bug 1818346. Support OMTA for view-timeline. We disable it for now + // because we need to make view-timeline-inset animations run on the OMTA as + // well before enable this. + if (scrollTimeline->IsViewTimeline()) { + return KeyframeEffect::MatchForCompositor::No; + } + } + + if (!HasEffectiveAnimationOfPropertySet(aPropertySet, aEffects)) { + return KeyframeEffect::MatchForCompositor::No; + } + + // If we know that the animation is not visible, we don't need to send the + // animation to the compositor. + if (!aFrame->IsVisibleOrMayHaveVisibleDescendants() || + CanOptimizeAwayDueToOpacity(*this, *aFrame) || + aFrame->IsScrolledOutOfView()) { + return KeyframeEffect::MatchForCompositor::NoAndBlockThisProperty; + } + + if (aPropertySet.HasProperty(eCSSProperty_background_color)) { + if (!StaticPrefs::gfx_omta_background_color()) { + return KeyframeEffect::MatchForCompositor::No; + } + + // We don't yet support off-main-thread background-color animations on + // canvas frame or on <html> or <body> which generate + // nsDisplayCanvasBackgroundColor or nsDisplaySolidColor display item. + if (aFrame->IsCanvasFrame() || + (aFrame->GetContent() && + (aFrame->GetContent()->IsHTMLElement(nsGkAtoms::body) || + aFrame->GetContent()->IsHTMLElement(nsGkAtoms::html)))) { + return KeyframeEffect::MatchForCompositor::No; + } + } + + // We can't run this background color animation on the compositor if there + // is any `current-color` keyframe. + if (mCumulativeChanges.mHasBackgroundColorCurrentColor) { + aPerformanceWarning = AnimationPerformanceWarning::Type::HasCurrentColor; + return KeyframeEffect::MatchForCompositor::NoAndBlockThisProperty; + } + + return mAnimation->IsPlaying() ? KeyframeEffect::MatchForCompositor::Yes + : KeyframeEffect::MatchForCompositor::IfNeeded; +} + +} // namespace dom +} // namespace mozilla |