firefox-main/dom/animation/CSSAnimation.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* 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 "CSSAnimation.h"
#include "mozilla/AnimationEventDispatcher.h"
#include "mozilla/KeyframeUtils.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/CSSAnimationBinding.h"
#include "mozilla/dom/KeyframeEffectBinding.h"
#include "nsPresContext.h"
namespace mozilla::dom {
using AnimationPhase = ComputedTiming::AnimationPhase;
JSObject* CSSAnimation::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) {
return dom::CSSAnimation_Binding::Wrap(aCx, this, aGivenProto);
}
void CSSAnimation::SetEffect(AnimationEffect* aEffect) {
Animation::SetEffect(aEffect);
PropertiesWillSetFromJS(CSSAnimationProperties::Effect);
}
void CSSAnimation::SetStartTime(const Nullable<CSSNumberish>& aStartTime,
ErrorResult& aRv) {
// Note that we always compare with the paused state since for the purposes
// of determining if play control is being overridden or not, we want to
// treat the finished state as running.
bool wasPaused = PlayState() == AnimationPlayState::Paused;
Animation::SetStartTime(aStartTime, aRv);
if (aRv.Failed()) {
return;
}
bool isPaused = PlayState() == AnimationPlayState::Paused;
if (wasPaused != isPaused) {
PropertiesWillSetFromJS(CSSAnimationProperties::PlayState);
}
}
mozilla::dom::Promise* CSSAnimation::GetReady(ErrorResult& aRv) {
FlushUnanimatedStyle();
return Animation::GetReady(aRv);
}
void CSSAnimation::Reverse(ErrorResult& aRv) {
// As with CSSAnimation::SetStartTime, we're really only interested in the
// paused state.
bool wasPaused = PlayState() == AnimationPlayState::Paused;
Animation::Reverse(aRv);
if (aRv.Failed()) {
return;
}
bool isPaused = PlayState() == AnimationPlayState::Paused;
if (wasPaused != isPaused) {
PropertiesWillSetFromJS(CSSAnimationProperties::PlayState);
}
}
AnimationPlayState CSSAnimation::PlayStateFromJS() const {
// Flush style to ensure that any properties controlling animation state
// (e.g. animation-play-state) are fully updated.
FlushUnanimatedStyle();
return Animation::PlayStateFromJS();
}
bool CSSAnimation::PendingFromJS() const {
// Flush style since, for example, if the animation-play-state was just
// changed its possible we should now be pending.
FlushUnanimatedStyle();
return Animation::PendingFromJS();
}
void CSSAnimation::PlayFromJS(ErrorResult& aRv) {
// Note that flushing style below might trigger calls to
// PlayFromStyle()/PauseFromStyle() on this object.
FlushUnanimatedStyle();
Animation::PlayFromJS(aRv);
if (aRv.Failed()) {
return;
}
PropertiesWillSetFromJS(CSSAnimationProperties::PlayState);
}
void CSSAnimation::PauseFromJS(ErrorResult& aRv) {
Animation::PauseFromJS(aRv);
if (aRv.Failed()) {
return;
}
PropertiesWillSetFromJS(CSSAnimationProperties::PlayState);
}
void CSSAnimation::PlayFromStyle() {
ErrorResult rv;
Animation::Play(rv, Animation::LimitBehavior::Continue);
// play() should not throw when LimitBehavior is Continue
MOZ_ASSERT(!rv.Failed(), "Unexpected exception playing animation");
}
void CSSAnimation::PauseFromStyle() {
ErrorResult rv;
Animation::Pause(rv);
// pause() should only throw when *all* of the following conditions are true:
// - we are in the idle state, and
// - we have a negative playback rate, and
// - we have an infinitely repeating animation
// The first two conditions will never happen under regular style processing
// but could happen if an author made modifications to the Animation object
// and then updated animation-play-state. It's an unusual case and there's
// no obvious way to pass on the exception information so we just silently
// fail for now.
if (rv.Failed()) {
NS_WARNING("Unexpected exception pausing animation - silently failing");
}
}
void CSSAnimation::Tick(TickState& aState) {
Animation::Tick(aState);
QueueEvents();
}
int32_t CSSAnimation::CompareCompositeOrder(
const CSSAnimation& aOther, nsContentUtils::NodeIndexCache& aCache) const {
MOZ_ASSERT(IsTiedToMarkup() && aOther.IsTiedToMarkup(),
"Should only be called for CSS animations that are sorted "
"as CSS animations (i.e. tied to CSS markup)");
// 0. Object-equality case
if (&aOther == this) {
return 0;
}
// 1. Sort by document order
if (!mOwningElement.Equals(aOther.mOwningElement)) {
return mOwningElement.Compare(aOther.mOwningElement, aCache);
}
// 2. (Same element and pseudo): Sort by position in animation-name
MOZ_ASSERT(mAnimationIndex != aOther.mAnimationIndex);
return mAnimationIndex < aOther.mAnimationIndex ? -1 : 1;
}
void CSSAnimation::QueueEvents(const StickyTimeDuration& aActiveTime) {
// If the animation is pending, we ignore animation events until we finish
// pending.
if (mPendingState != PendingState::NotPending) {
return;
}
// CSS animations dispatch events at their owning element. This allows
// script to repurpose a CSS animation to target a different element,
// to use a group effect (which has no obvious "target element"), or
// to remove the animation effect altogether whilst still getting
// animation events.
//
// It does mean, however, that for a CSS animation that has no owning
// element (e.g. it was created using the CSSAnimation constructor or
// disassociated from CSS) no events are fired. If it becomes desirable
// for these animations to still fire events we should spec the concept
// of the "original owning element" or "event target" and allow script
// to set it when creating a CSSAnimation object.
if (!mOwningElement.ShouldFireEvents()) {
return;
}
nsPresContext* presContext = mOwningElement.GetPresContext();
if (!presContext) {
return;
}
uint64_t currentIteration = 0;
ComputedTiming::AnimationPhase currentPhase;
StickyTimeDuration intervalStartTime;
StickyTimeDuration intervalEndTime;
StickyTimeDuration iterationStartTime;
if (!mEffect) {
currentPhase =
GetAnimationPhaseWithoutEffect<ComputedTiming::AnimationPhase>(*this);
if (currentPhase == mPreviousPhase) {
return;
}
} else {
ComputedTiming computedTiming = mEffect->GetComputedTiming();
currentPhase = computedTiming.mPhase;
currentIteration = computedTiming.mCurrentIteration;
if (currentPhase == mPreviousPhase &&
currentIteration == mPreviousIteration) {
return;
}
intervalStartTime = IntervalStartTime(computedTiming.mActiveDuration);
intervalEndTime = IntervalEndTime(computedTiming.mActiveDuration);
uint64_t iterationBoundary = mPreviousIteration > currentIteration
? currentIteration + 1
: currentIteration;
double multiplier = iterationBoundary - computedTiming.mIterationStart;
if (multiplier != 0.0) {
iterationStartTime = computedTiming.mDuration.MultDouble(multiplier);
}
}
TimeStamp startTimeStamp = ElapsedTimeToTimeStamp(intervalStartTime);
TimeStamp endTimeStamp = ElapsedTimeToTimeStamp(intervalEndTime);
TimeStamp iterationTimeStamp = ElapsedTimeToTimeStamp(iterationStartTime);
AutoTArray<AnimationEventInfo, 2> events;
auto appendAnimationEvent = [&](EventMessage aMessage,
const StickyTimeDuration& aElapsedTime,
const TimeStamp& aScheduledEventTimeStamp) {
double elapsedTime = aElapsedTime.ToSeconds();
if (aMessage == eAnimationCancel) {
// 0 is an inappropriate value for this callsite. What we need to do is
// use a single random value for all increasing times reportable.
// That is to say, whenever elapsedTime goes negative (because an
// animation restarts, something rewinds the animation, or otherwise)
// a new random value for the mix-in must be generated.
elapsedTime = nsRFPService::ReduceTimePrecisionAsSecsRFPOnly(
elapsedTime, 0, mRTPCallerType);
}
events.AppendElement(AnimationEventInfo(
mAnimationName, mOwningElement.Target(), aMessage, elapsedTime,
mAnimationIndex, aScheduledEventTimeStamp, this));
};
// Handle cancel event first
if ((mPreviousPhase != AnimationPhase::Idle &&
mPreviousPhase != AnimationPhase::After) &&
currentPhase == AnimationPhase::Idle) {
appendAnimationEvent(eAnimationCancel, aActiveTime,
GetTimelineCurrentTimeAsTimeStamp());
}
switch (mPreviousPhase) {
case AnimationPhase::Idle:
case AnimationPhase::Before:
if (currentPhase == AnimationPhase::Active) {
appendAnimationEvent(eAnimationStart, intervalStartTime,
startTimeStamp);
} else if (currentPhase == AnimationPhase::After) {
appendAnimationEvent(eAnimationStart, intervalStartTime,
startTimeStamp);
appendAnimationEvent(eAnimationEnd, intervalEndTime, endTimeStamp);
}
break;
case AnimationPhase::Active:
if (currentPhase == AnimationPhase::Before) {
appendAnimationEvent(eAnimationEnd, intervalStartTime, startTimeStamp);
} else if (currentPhase == AnimationPhase::Active) {
// The currentIteration must have changed or element we would have
// returned early above.
MOZ_ASSERT(currentIteration != mPreviousIteration);
appendAnimationEvent(eAnimationIteration, iterationStartTime,
iterationTimeStamp);
} else if (currentPhase == AnimationPhase::After) {
appendAnimationEvent(eAnimationEnd, intervalEndTime, endTimeStamp);
}
break;
case AnimationPhase::After:
if (currentPhase == AnimationPhase::Before) {
appendAnimationEvent(eAnimationStart, intervalEndTime, startTimeStamp);
appendAnimationEvent(eAnimationEnd, intervalStartTime, endTimeStamp);
} else if (currentPhase == AnimationPhase::Active) {
appendAnimationEvent(eAnimationStart, intervalEndTime, endTimeStamp);
}
break;
}
mPreviousPhase = currentPhase;
mPreviousIteration = currentIteration;
if (!events.IsEmpty()) {
presContext->AnimationEventDispatcher()->QueueEvents(std::move(events));
}
}
void CSSAnimation::UpdateTiming(SeekFlag aSeekFlag,
SyncNotifyFlag aSyncNotifyFlag) {
if (mNeedsNewAnimationIndexWhenRun &&
PlayState() != AnimationPlayState::Idle) {
mAnimationIndex = sNextAnimationIndex++;
mNeedsNewAnimationIndexWhenRun = false;
}
Animation::UpdateTiming(aSeekFlag, aSyncNotifyFlag);
}
/////////////////////// CSSAnimationKeyframeEffect ////////////////////////
void CSSAnimationKeyframeEffect::GetTiming(EffectTiming& aRetVal) const {
MaybeFlushUnanimatedStyle();
KeyframeEffect::GetTiming(aRetVal);
}
void CSSAnimationKeyframeEffect::GetComputedTimingAsDict(
ComputedEffectTiming& aRetVal) const {
MaybeFlushUnanimatedStyle();
KeyframeEffect::GetComputedTimingAsDict(aRetVal);
}
void CSSAnimationKeyframeEffect::UpdateTiming(
const OptionalEffectTiming& aTiming, ErrorResult& aRv) {
KeyframeEffect::UpdateTiming(aTiming, aRv);
if (aRv.Failed()) {
return;
}
if (CSSAnimation* cssAnimation = GetOwningCSSAnimation()) {
CSSAnimationProperties updatedProperties = CSSAnimationProperties::None;
if (aTiming.mDuration.WasPassed()) {
updatedProperties |= CSSAnimationProperties::Duration;
}
if (aTiming.mIterations.WasPassed()) {
updatedProperties |= CSSAnimationProperties::IterationCount;
}
if (aTiming.mDirection.WasPassed()) {
updatedProperties |= CSSAnimationProperties::Direction;
}
if (aTiming.mDelay.WasPassed()) {
updatedProperties |= CSSAnimationProperties::Delay;
}
if (aTiming.mFill.WasPassed()) {
updatedProperties |= CSSAnimationProperties::FillMode;
}
cssAnimation->PropertiesWillSetFromJS(updatedProperties);
}
}
void CSSAnimationKeyframeEffect::SetKeyframes(JSContext* aContext,
JS::Handle<JSObject*> aKeyframes,
ErrorResult& aRv) {
nsTArray<Keyframe> keyframes = KeyframeUtils::GetKeyframesFromObject(
aContext, mDocument, aKeyframes, "KeyframeEffect.setKeyframes", aRv);
if (aRv.Failed()) {
return;
}
// SetKeyframes below will trigger the keyframe generation (for missing 0% and
// 100%), so we set this flag to avoid generating the keyframes if they come
// from JS.
// Note that this is different from CSSAnimationProperties::Keyframes below
// because we have to avoid generating keyframes even if we don't have
// animation, i.e. this is a keyframe-effect-specific flag for keyframes
// generation.
mIgnoreKeyframesGeneration = true;
// This is from the JS API, so we use the associated animation's timeline and
// range if any.
RefPtr<const ComputedStyle> style = GetTargetComputedStyle(Flush::None);
KeyframeEffect::SetKeyframes(
std::move(keyframes), style,
mAnimation ? mAnimation->GetTimeline() : nullptr,
mAnimation ? &mAnimation->GetTimelineRange() : nullptr);
if (CSSAnimation* cssAnimation = GetOwningCSSAnimation()) {
cssAnimation->PropertiesWillSetFromJS(CSSAnimationProperties::Keyframes);
}
}
void CSSAnimationKeyframeEffect::SetComposite(
const CompositeOperation& aComposite) {
KeyframeEffect::SetComposite(aComposite);
if (CSSAnimation* cssAnimation = GetOwningCSSAnimation()) {
cssAnimation->PropertiesWillSetFromJS(CSSAnimationProperties::Composition);
}
}
class ComputedOffsetComparator {
public:
static bool LessThan(const Keyframe& aLhs, const Keyframe& aRhs) {
// Keep the specified order if any of the keyframes have no computed offset.
return !std::isnan(aLhs.mComputedOffset) &&
!std::isnan(aRhs.mComputedOffset) &&
aLhs.mComputedOffset < aRhs.mComputedOffset;
}
};
enum class TargetKeyframe : uint8_t {
Initial,
Final,
};
static Keyframe* GetOrCreateInitialOrFinalComputedKeyframe(
nsTArray<Keyframe>& aPercentageKeyframes,
nsTArray<Keyframe>& aRangeKeyframes, const TargetKeyframe aTargetKeyframe,
const StyleComputedTimingFunction& aDefaultTimingFunction,
const CompositeOperationOrAuto aDefaultComposite) {
const double targetOffset =
aTargetKeyframe == TargetKeyframe::Initial ? 0.0 : 1.0;
auto IsKeyframeMatched = [&](const Keyframe& aKeyframe) {
return aKeyframe.mComputedOffset == targetOffset &&
(aKeyframe.mComposite == CompositeOperationOrAuto::Auto ||
aKeyframe.mComposite == aDefaultComposite) &&
(aKeyframe.mTimingFunction
? *aKeyframe.mTimingFunction == aDefaultTimingFunction
: aDefaultTimingFunction.IsLinearKeyword());
};
// 1. Search the offset in |aRangeKeyframes| first, in the reverse order. We
// search |aRangeKeyframes| first because we perfer the later keyframe in
// the used order, which breaks the tie with the computed order. And range
// offsets are always put after percentage offsets in the computed order.
//
// Note: We intentionally search in the reverse order because we prefer the
// later keyframe if mulitple keyframes have 0% or 100% (with the matched
// easing and composite). It should happen only in keyframes with
// <timeline-range-offset> offsets because we don't group them when converting
// them from Servo |KeyframesStep| into Gecko |Keyframe|, in
// Servo_StyleSet_GetKeyframesForName(), and intentionally keep those
// keyframes unsorted (i.e. the specified order).
// e.g.
// cover 0% {...}
// entry 0% {...}
// Both of them have computed offset 0%. Since we keep |mKeyframes| with
// <timeline-range-offset> offsets unsorted, so we can simply choose the last
// one when breaking a tie.
//
// This is spec'ed especially for 100%. For 0%, the spec doesnt' mention that
// so we use the same rule for now.
for (auto& keyframe : Reversed(aRangeKeyframes)) {
MOZ_ASSERT(keyframe.mOffset);
// Skip the keyframe with unresolved computed offset.
if (std::isnan(keyframe.mComputedOffset)) {
continue;
}
if (IsKeyframeMatched(keyframe)) {
return &keyframe;
}
// |aRangeKeyframes| is sorted by |keyframe.mComputedOffset|, so we can
// break early.
if (keyframe.mComputedOffset < targetOffset) {
break;
}
}
// 2. Search the offset in |aPercentageKeyframes|. We group the keyframes with
// <percentage> offsets already so we shouldn't have mulitple matches.
//
// Note: |insertPosition| is used to find the last 0% or 100% keyframe. We
// would like to insert the missing keyframe after it.
// e.g.
// 0% { animation-timing-function: linear; }
// 50% { width: 100px; }
// 100% { animation-composition: add; }
// We have to generate the keyframes like this:
// [0] { offset: 0.0, easing: 'linear', composite: 'auto' }
// [1] { offset: 0.0, easing: 'ease', composite: 'replace' } // generated 0%
// [2] { offset: 0.5, easing: 'ease', composite: 'auto' }
// [3] { offset: 1.0, easing: 'ease', composite: 'add' }
// [4] { offset: 1.0, easing: 'ease', composite: 'replace' } // generated 100%
// So |insertPosition| for 0% is 1, and for 100% is 4.
size_t insertPosition = 0;
for (auto& keyframe : aPercentageKeyframes) {
MOZ_ASSERT(keyframe.mOffset);
MOZ_ASSERT(!std::isnan(keyframe.mComputedOffset));
if (IsKeyframeMatched(keyframe)) {
return &keyframe;
}
if (keyframe.mComputedOffset > targetOffset) {
break;
}
++insertPosition;
}
// Now this is a missing 0%/100% keyframe. Let's generate it.
Keyframe* newKeyframe = aPercentageKeyframes.InsertElementAt(insertPosition);
newKeyframe->mOffset.emplace(
Keyframe::OffsetType::PercentageOffset(targetOffset));
newKeyframe->mComputedOffset = targetOffset;
if (!aDefaultTimingFunction.IsLinearKeyword()) {
newKeyframe->mTimingFunction.emplace(aDefaultTimingFunction);
}
newKeyframe->mComposite = aDefaultComposite;
return newKeyframe;
}
// The step 3 (Generate Initial and Final Frames) in
//
// Note: we use "computed keyframes" here because we expect those keyframe
// offsets have been resolved (so we have resolved computed offsets here for the
// active timeline). The only difference from spec is that we don't compute the
// property values here since the caller will do that. Perhaps we could merge
// them together in the future.
bool CSSAnimationKeyframeEffect::GetComputedKeyframes(
nsTArray<Keyframe>& aKeyframes) const {
// Check if we do need to do this. This flag is set if the keyframes come from
// the JS API.
if (mIgnoreKeyframesGeneration) {
return false;
}
// FIXME: Perhaps we could cache |allProperties| for keyframes with
// <percentage> offsets. (The properties of keyframes with
// <timeline-range-offset> offsets need to be checked everytime
// unfortunately.)
AnimatedPropertyIDSet allProperties;
AnimatedPropertyIDSet fromProperties;
AnimatedPropertyIDSet toProperties;
// Add 2 more elements for the insertion of 0% and 100% if any.
nsTArray<Keyframe> percentageKeyframes(mKeyframes.Length() + 2);
nsTArray<Keyframe> rangeKeyframes(mKeyframes.Length());
// Iterate keyframes and collect properties first. We have to append the
// propeties to the 0% or 100% keyframes if needed. We merged keyframes and
// converted the properties into physical longhands for the specified
// keyframes already, so we can just collect the propertis information here.
for (const Keyframe& keyframe : mKeyframes) {
MOZ_ASSERT(keyframe.mOffset);
if (keyframe.mOffset->IsPercentageOffset()) {
percentageKeyframes.AppendElement(keyframe);
} else {
rangeKeyframes.AppendElement(keyframe);
}
if (std::isnan(keyframe.mComputedOffset)) {
continue;
}
AnimatedPropertyIDSet currentProperties;
for (const auto& pair : keyframe.mPropertyValues) {
MOZ_ASSERT(
!pair.mProperty.IsShorthand(),
"The shorthands should be expanded already for CSS Animations");
MOZ_ASSERT(KeyframeUtils::IsAnimatableProperty(pair.mProperty),
"It should be animatable for CSS Animations");
currentProperties.AddProperty(pair.mProperty);
}
allProperties.AddProperties(currentProperties);
// Note that the automatic from (0%) and to (100%) keyframes are only
// generated for properties that don’t have keyframes at or earlier than 0%
// or at or after 100% (respectively).
//
// So we have to collect the properties with offsets <= 0 and offsets >= 1,
// no matter what keyframe-specific timing function and keyframe-specific
// composite are used.
if (keyframe.mComputedOffset <= 0.0) {
fromProperties.AddProperties(currentProperties);
} else if (keyframe.mComputedOffset >= 1.0) {
toProperties.AddProperties(currentProperties);
}
}
// We keep the specified order if all of them are unresolved. Otherwise, sort
// them with computed offsets to get the used order. We do this for finding
// and generating the initial and final keyframes (since we need the used
// order to search the keyframes below).
//
// Also, in getKeyframes(), other browsers show the keyframes with
// <timeline-range-offset> offsets in the order of the computed offsets. This
// is vague in the spec after we introduced <timeline-range-offset>, so we
// just match the behavior of other browsers here.
rangeKeyframes.StableSort(ComputedOffsetComparator());
// The default composite used to search to 0% and 100% keyframes below.
const dom::CompositeOperationOrAuto defaultComposite = [&]() {
switch (mDefaultComposite) {
case CompositeOperation::Replace:
return dom::CompositeOperationOrAuto::Replace;
case CompositeOperation::Add:
return dom::CompositeOperationOrAuto::Add;
case CompositeOperation::Accumulate:
return dom::CompositeOperationOrAuto::Accumulate;
}
// The initial value is replace.
return dom::CompositeOperationOrAuto::Replace;
}();
// Generate Initial and Final Frames:
// 1. Find or create the initial keyframe, a keyframe with a keyframe offset
// of 0%, default timing function as its keyframe timing function, and
// default composite as its keyframe composite.
// 2. For any property in animated properties that is not otherwise present
// in a keyframe with an offset of 0% or one that would be positioned
// earlier in the used keyframe order, add the computed value of that
// property on element to initial keyframe’s keyframe values.
// 3. If initial keyframe’s keyframe values is not empty, prepend initial
// keyframe to keyframes. (Note: We add it to keyframes after the last
// keyframe with offset 0%.)
const bool isEmptyKeyframes =
percentageKeyframes.IsEmpty() && rangeKeyframes.IsEmpty();
auto appendProperties = [&](Keyframe& aKeyframe,
const AnimatedPropertyIDSet& aCurrentProperties) {
auto& propertyValues = aKeyframe.mPropertyValues;
for (const auto& property : allProperties) {
if (aCurrentProperties.HasProperty(property)) {
continue;
}
// The nullptr of |mServoDeclarationBlock| means we use the base values,
// i.e. the value generated for that property by finding the computed
// value for that property in the absence of animations.
propertyValues.AppendElement(PropertyValuePair{property, nullptr});
}
};
// Check the equality of two property sets. Note that |fromProperties| must be
// a subset of |allProperties|.
if (!allProperties.IsSubsetOf(fromProperties) && !isEmptyKeyframes) {
Keyframe* fromKeyframe = GetOrCreateInitialOrFinalComputedKeyframe(
percentageKeyframes, rangeKeyframes, TargetKeyframe::Initial,
mDefaultTimingFunction, defaultComposite);
MOZ_ASSERT(fromKeyframe);
appendProperties(*fromKeyframe, fromProperties);
}
// 4. Repeat for final keyframe, using an offset of 100%, considering
// keyframes positioned later in the used keyframe order, and appending to
// keyframes. Note that |toProperties| must be a subset of |allProperties|.
if (!allProperties.IsSubsetOf(toProperties) && !isEmptyKeyframes) {
Keyframe* toKeyframe = GetOrCreateInitialOrFinalComputedKeyframe(
percentageKeyframes, rangeKeyframes, TargetKeyframe::Final,
mDefaultTimingFunction, defaultComposite);
MOZ_ASSERT(toKeyframe);
appendProperties(*toKeyframe, toProperties);
}
aKeyframes = std::move(percentageKeyframes);
if (!rangeKeyframes.IsEmpty()) {
aKeyframes.AppendElements(std::move(rangeKeyframes));
}
return true;
}
void CSSAnimationKeyframeEffect::MaybeFlushUnanimatedStyle() const {
if (!GetOwningCSSAnimation()) {
return;
}
if (dom::Document* doc = GetRenderedDocument()) {
doc->FlushPendingNotifications(
ChangesToFlush(FlushType::Style, false /* flush animations */, false));
}
}
} // namespace mozilla::dom