TEST(AnimationKeyframeEffectModel, ZeroKeyframes)
{
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(AnimatableValueKeyframeVector());
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.5, duration, values);
EXPECT_TRUE(values.isEmpty());
}
// FIXME: Re-enable this test once compositing of CompositeAdd is supported.
TEST(AnimationKeyframeEffectModel, DISABLED_DependsOnUnderlyingValue)
{
AnimatableValueKeyframeVector keyframes(3);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.0);
keyframes[0]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(1.0).get());
keyframes[0]->setComposite(EffectModel::CompositeAdd);
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(0.5);
keyframes[1]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(1.0).get());
keyframes[2] = AnimatableValueKeyframe::create();
keyframes[2]->setOffset(1.0);
keyframes[2]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(1.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0, duration, values);
EXPECT_TRUE(values.at(0));
effect->sample(0, 0.1, duration, values);
EXPECT_TRUE(values.at(0));
effect->sample(0, 0.25, duration, values);
EXPECT_TRUE(values.at(0));
effect->sample(0, 0.4, duration, values);
EXPECT_TRUE(values.at(0));
effect->sample(0, 0.5, duration, values);
EXPECT_FALSE(values.at(0));
effect->sample(0, 0.6, duration, values);
EXPECT_FALSE(values.at(0));
effect->sample(0, 0.75, duration, values);
EXPECT_FALSE(values.at(0));
effect->sample(0, 0.8, duration, values);
EXPECT_FALSE(values.at(0));
effect->sample(0, 1, duration, values);
EXPECT_FALSE(values.at(0));
}
TEST(AnimationKeyframeEffectModel, BasicOperation)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(unknownAnimatableValue(3.0), unknownAnimatableValue(5.0));
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
ASSERT_EQ(1UL, values.size());
expectProperty(CSSPropertyLeft, values.at(0));
expectDoubleValue(5.0, values.at(0));
}
TEST(AnimationKeyframeEffectModel, ExtrapolateReplaceNonInterpolable)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(unknownAnimatableValue(3.0), unknownAnimatableValue(5.0));
keyframes[0]->setComposite(EffectModel::CompositeReplace);
keyframes[1]->setComposite(EffectModel::CompositeReplace);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 1.6, duration, values);
expectDoubleValue(5.0, values.at(0));
}
// FIXME: Re-enable this test once compositing of CompositeAdd is supported.
TEST(AnimationKeyframeEffectModel, DISABLED_ExtrapolateAdd)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
keyframes[0]->setComposite(EffectModel::CompositeAdd);
keyframes[1]->setComposite(EffectModel::CompositeAdd);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 1.6, duration, values);
expectDoubleValue((7.0 + 3.0) * -0.6 + (7.0 + 5.0) * 1.6, values.at(0));
}
TEST(AnimationKeyframeEffectModel, CompositeReplace)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
keyframes[0]->setComposite(EffectModel::CompositeReplace);
keyframes[1]->setComposite(EffectModel::CompositeReplace);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
expectDoubleValue(3.0 * 0.4 + 5.0 * 0.6, values.at(0));
}
// FIXME: Re-enable this test once compositing of CompositeAdd is supported.
TEST(AnimationKeyframeEffectModel, DISABLED_SingleKeyframeAtOffsetOne)
{
AnimatableValueKeyframeVector keyframes(1);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(1.0);
keyframes[0]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(5.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
expectDoubleValue(7.0 * 0.4 + 5.0 * 0.6, values.at(0));
}
TEST(AnimationKeyframeEffectModel, MultipleIterations)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(pixelAnimatableValue(1.0), pixelAnimatableValue(3.0));
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.5, duration, values);
expectDoubleValue(2.0, values.at(0));
effect->sample(1, 0.5, duration, values);
expectDoubleValue(2.0, values.at(0));
effect->sample(2, 0.5, duration, values);
expectDoubleValue(2.0, values.at(0));
}
TEST(AnimationKeyframeEffectModel, CompositeCubicBezier)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
keyframes[0]->setComposite(EffectModel::CompositeReplace);
keyframes[0]->setEasing(CubicBezierTimingFunction::create(0.42, 0, 0.58, 1));
keyframes[1]->setComposite(EffectModel::CompositeReplace);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
expectDoubleValue(4.3363357, values.at(0));
effect->sample(0, 0.6, duration * 1000, values);
expectDoubleValue(4.3362322, values.at(0));
}
TEST(AnimationKeyframeEffectModel, CompositeEaseIn)
{
AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
keyframes[0]->setComposite(EffectModel::CompositeReplace);
keyframes[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
keyframes[1]->setComposite(EffectModel::CompositeReplace);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
expectDoubleValue(3.8579516, values.at(0));
effect->sample(0, 0.6, duration * 100, values);
expectDoubleValue(3.8582394, values.at(0));
}
TEST(AnimationKeyframeEffectModel, AddSyntheticKeyframes)
{
AnimatableValueKeyframeVector keyframes(1);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.5);
keyframes[0]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(4.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
const AnimatableValuePropertySpecificKeyframeVector& propertySpecificKeyframes = effect->getPropertySpecificKeyframes(PropertyHandle(CSSPropertyLeft));
EXPECT_EQ(3U, propertySpecificKeyframes.size());
EXPECT_DOUBLE_EQ(0.0, propertySpecificKeyframes[0]->offset());
EXPECT_DOUBLE_EQ(0.5, propertySpecificKeyframes[1]->offset());
EXPECT_DOUBLE_EQ(1.0, propertySpecificKeyframes[2]->offset());
}
// FIXME: Re-enable this test once compositing of CompositeAdd is supported.
TEST(AnimationKeyframeEffectModel, DISABLED_PerKeyframeComposite)
{
AnimatableValueKeyframeVector keyframes(2);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.0);
keyframes[0]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(3.0).get());
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(1.0);
keyframes[1]->setPropertyValue(CSSPropertyLeft, pixelAnimatableValue(5.0).get());
keyframes[1]->setComposite(EffectModel::CompositeAdd);
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
expectDoubleValue(3.0 * 0.4 + (7.0 + 5.0) * 0.6, values.at(0));
}
blink::Animation* InspectorAnimationAgent::animationClone(
blink::Animation* animation) {
const String id = String::number(animation->sequenceNumber());
if (!m_idToAnimationClone.get(id)) {
KeyframeEffect* oldEffect = toKeyframeEffect(animation->effect());
ASSERT(oldEffect->model()->isKeyframeEffectModel());
KeyframeEffectModelBase* oldModel =
toKeyframeEffectModelBase(oldEffect->model());
EffectModel* newModel = nullptr;
// Clone EffectModel.
// TODO(samli): Determine if this is an animations bug.
if (oldModel->isStringKeyframeEffectModel()) {
StringKeyframeEffectModel* oldStringKeyframeModel =
toStringKeyframeEffectModel(oldModel);
KeyframeVector oldKeyframes = oldStringKeyframeModel->getFrames();
StringKeyframeVector newKeyframes;
for (auto& oldKeyframe : oldKeyframes)
newKeyframes.append(toStringKeyframe(oldKeyframe.get()));
newModel = StringKeyframeEffectModel::create(newKeyframes);
} else if (oldModel->isAnimatableValueKeyframeEffectModel()) {
AnimatableValueKeyframeEffectModel* oldAnimatableValueKeyframeModel =
toAnimatableValueKeyframeEffectModel(oldModel);
KeyframeVector oldKeyframes =
oldAnimatableValueKeyframeModel->getFrames();
AnimatableValueKeyframeVector newKeyframes;
for (auto& oldKeyframe : oldKeyframes)
newKeyframes.append(toAnimatableValueKeyframe(oldKeyframe.get()));
newModel = AnimatableValueKeyframeEffectModel::create(newKeyframes);
}
KeyframeEffect* newEffect = KeyframeEffect::create(
oldEffect->target(), newModel, oldEffect->specifiedTiming());
m_isCloning = true;
blink::Animation* clone =
blink::Animation::create(newEffect, animation->timeline());
m_isCloning = false;
m_idToAnimationClone.set(id, clone);
m_idToAnimation.set(String::number(clone->sequenceNumber()), clone);
clone->play();
clone->setStartTime(animation->startTime());
animation->setEffectSuppressed(true);
}
return m_idToAnimationClone.get(id);
}
TEST(AnimationKeyframeEffectModel, EndKeyframeOffsetsUnspecified)
{
AnimatableValueKeyframeVector keyframes(3);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(3.0).get());
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(0.5);
keyframes[1]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(4.0).get());
keyframes[2] = AnimatableValueKeyframe::create();
keyframes[2]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(5.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.1, duration, values);
expectDoubleValue(3.0, values.at(0));
effect->sample(0, 0.6, duration, values);
expectDoubleValue(4.0, values.at(0));
effect->sample(0, 0.9, duration, values);
expectDoubleValue(5.0, values.at(0));
}
TEST(AnimationKeyframeEffectModel, MultipleKeyframesWithSameOffset)
{
AnimatableValueKeyframeVector keyframes(9);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.0);
keyframes[0]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(0.0).get());
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(0.1);
keyframes[1]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(1.0).get());
keyframes[2] = AnimatableValueKeyframe::create();
keyframes[2]->setOffset(0.1);
keyframes[2]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(2.0).get());
keyframes[3] = AnimatableValueKeyframe::create();
keyframes[3]->setOffset(0.5);
keyframes[3]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(3.0).get());
keyframes[4] = AnimatableValueKeyframe::create();
keyframes[4]->setOffset(0.5);
keyframes[4]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(4.0).get());
keyframes[5] = AnimatableValueKeyframe::create();
keyframes[5]->setOffset(0.5);
keyframes[5]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(5.0).get());
keyframes[6] = AnimatableValueKeyframe::create();
keyframes[6]->setOffset(0.9);
keyframes[6]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(6.0).get());
keyframes[7] = AnimatableValueKeyframe::create();
keyframes[7]->setOffset(0.9);
keyframes[7]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(7.0).get());
keyframes[8] = AnimatableValueKeyframe::create();
keyframes[8]->setOffset(1.0);
keyframes[8]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(7.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.0, duration, values);
expectDoubleValue(0.0, values.at(0));
effect->sample(0, 0.2, duration, values);
expectDoubleValue(2.0, values.at(0));
effect->sample(0, 0.4, duration, values);
expectDoubleValue(3.0, values.at(0));
effect->sample(0, 0.5, duration, values);
expectDoubleValue(5.0, values.at(0));
effect->sample(0, 0.6, duration, values);
expectDoubleValue(5.0, values.at(0));
effect->sample(0, 0.8, duration, values);
expectDoubleValue(6.0, values.at(0));
effect->sample(0, 1.0, duration, values);
expectDoubleValue(7.0, values.at(0));
}
TEST(AnimationKeyframeEffectModel, MultipleProperties)
{
AnimatableValueKeyframeVector keyframes(2);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.0);
keyframes[0]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(3.0).get());
keyframes[0]->setPropertyValue(CSSPropertyRight, unknownAnimatableValue(4.0).get());
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(1.0);
keyframes[1]->setPropertyValue(CSSPropertyLeft, unknownAnimatableValue(5.0).get());
keyframes[1]->setPropertyValue(CSSPropertyRight, unknownAnimatableValue(6.0).get());
AnimatableValueKeyframeEffectModel* effect = AnimatableValueKeyframeEffectModel::create(keyframes);
Vector<RefPtr<Interpolation>> values;
effect->sample(0, 0.6, duration, values);
EXPECT_EQ(2UL, values.size());
Interpolation* leftValue = findValue(values, CSSPropertyLeft);
ASSERT_TRUE(leftValue);
expectDoubleValue(5.0, leftValue);
Interpolation* rightValue = findValue(values, CSSPropertyRight);
ASSERT_TRUE(rightValue);
expectDoubleValue(6.0, rightValue);
}
void CSSAnimations::maybeApplyPendingUpdate(Element* element)
{
m_previousActiveInterpolationsForAnimations.clear();
if (m_pendingUpdate.isEmpty())
return;
m_previousActiveInterpolationsForAnimations.swap(m_pendingUpdate.activeInterpolationsForAnimations());
// FIXME: cancelling, pausing, unpausing animations all query compositingState, which is not necessarily up to date here
// since we call this from recalc style.
// https://code.google.com/p/chromium/issues/detail?id=339847
DisableCompositingQueryAsserts disabler;
for (const AtomicString& animationName : m_pendingUpdate.cancelledAnimationNames()) {
Animation* animation = m_animations.take(animationName)->animation;
animation->cancel();
animation->update(TimingUpdateOnDemand);
}
for (const AtomicString& animationName : m_pendingUpdate.animationsWithPauseToggled()) {
Animation* animation = m_animations.get(animationName)->animation.get();
if (animation->paused())
animation->unpause();
else
animation->pause();
if (animation->outdated())
animation->update(TimingUpdateOnDemand);
}
for (const auto& animation : m_pendingUpdate.updatedCompositorKeyframes())
animation->setCompositorPending(true);
for (const auto& entry : m_pendingUpdate.animationsWithUpdates()) {
KeyframeEffect* effect = toKeyframeEffect(entry.animation->effect());
effect->setModel(entry.effect->model());
effect->updateSpecifiedTiming(entry.effect->specifiedTiming());
m_animations.find(entry.name)->value->update(entry);
}
for (const auto& entry : m_pendingUpdate.newAnimations()) {
const InertEffect* inertAnimation = entry.effect.get();
AnimationEventDelegate* eventDelegate = new AnimationEventDelegate(element, entry.name);
KeyframeEffect* effect = KeyframeEffect::create(element, inertAnimation->model(), inertAnimation->specifiedTiming(), KeyframeEffect::DefaultPriority, eventDelegate);
effect->setName(inertAnimation->name());
Animation* animation = element->document().timeline().play(effect);
if (inertAnimation->paused())
animation->pause();
animation->update(TimingUpdateOnDemand);
m_animations.set(entry.name, new RunningAnimation(animation, entry));
}
// Transitions that are run on the compositor only update main-thread state
// lazily. However, we need the new state to know what the from state shoud
// be when transitions are retargeted. Instead of triggering complete style
// recalculation, we find these cases by searching for new transitions that
// have matching cancelled animation property IDs on the compositor.
HeapHashMap<CSSPropertyID, std::pair<Member<KeyframeEffect>, double>> retargetedCompositorTransitions;
for (CSSPropertyID id : m_pendingUpdate.cancelledTransitions()) {
ASSERT(m_transitions.contains(id));
Animation* animation = m_transitions.take(id).animation;
KeyframeEffect* effect = toKeyframeEffect(animation->effect());
if (effect->hasActiveAnimationsOnCompositor(id) && m_pendingUpdate.newTransitions().find(id) != m_pendingUpdate.newTransitions().end() && !animation->limited())
retargetedCompositorTransitions.add(id, std::pair<KeyframeEffect*, double>(effect, animation->startTimeInternal()));
animation->cancel();
// after cancelation, transitions must be downgraded or they'll fail
// to be considered when retriggering themselves. This can happen if
// the transition is captured through getAnimations then played.
if (animation->effect() && animation->effect()->isKeyframeEffect())
toKeyframeEffect(animation->effect())->downgradeToNormal();
animation->update(TimingUpdateOnDemand);
}
for (CSSPropertyID id : m_pendingUpdate.finishedTransitions()) {
// This transition can also be cancelled and finished at the same time
if (m_transitions.contains(id)) {
Animation* animation = m_transitions.take(id).animation;
// Transition must be downgraded
if (animation->effect() && animation->effect()->isKeyframeEffect())
toKeyframeEffect(animation->effect())->downgradeToNormal();
}
}
for (const auto& entry : m_pendingUpdate.newTransitions()) {
const CSSAnimationUpdate::NewTransition& newTransition = entry.value;
RunningTransition runningTransition;
runningTransition.from = newTransition.from;
runningTransition.to = newTransition.to;
CSSPropertyID id = newTransition.id;
InertEffect* inertAnimation = newTransition.effect.get();
TransitionEventDelegate* eventDelegate = new TransitionEventDelegate(element, id);
EffectModel* model = inertAnimation->model();
if (retargetedCompositorTransitions.contains(id)) {
const std::pair<Member<KeyframeEffect>, double>& oldTransition = retargetedCompositorTransitions.get(id);
KeyframeEffect* oldAnimation = oldTransition.first;
double oldStartTime = oldTransition.second;
double inheritedTime = isNull(oldStartTime) ? 0 : element->document().timeline().currentTimeInternal() - oldStartTime;
AnimatableValueKeyframeEffectModel* oldEffect = toAnimatableValueKeyframeEffectModel(inertAnimation->model());
const KeyframeVector& frames = oldEffect->getFrames();
AnimatableValueKeyframeVector newFrames;
newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
newFrames.append(toAnimatableValueKeyframe(frames[2]->clone().get()));
newFrames[0]->clearPropertyValue(id);
newFrames[1]->clearPropertyValue(id);
InertEffect* inertAnimationForSampling = InertEffect::create(oldAnimation->model(), oldAnimation->specifiedTiming(), false, inheritedTime);
OwnPtr<Vector<RefPtr<Interpolation>>> sample = nullptr;
inertAnimationForSampling->sample(sample);
if (sample && sample->size() == 1) {
newFrames[0]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
newFrames[1]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
model = AnimatableValueKeyframeEffectModel::create(newFrames);
}
}
KeyframeEffect* transition = KeyframeEffect::create(element, model, inertAnimation->specifiedTiming(), KeyframeEffect::TransitionPriority, eventDelegate);
transition->setName(inertAnimation->name());
Animation* animation = element->document().timeline().play(transition);
// Set the current time as the start time for retargeted transitions
if (retargetedCompositorTransitions.contains(id))
animation->setStartTime(element->document().timeline().currentTime());
animation->update(TimingUpdateOnDemand);
runningTransition.animation = animation;
m_transitions.set(id, runningTransition);
ASSERT(id != CSSPropertyInvalid);
Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
}
clearPendingUpdate();
}
void CSSAnimations::maybeApplyPendingUpdate(Element* element)
{
if (!m_pendingUpdate) {
m_previousActiveInterpolationsForAnimations.clear();
return;
}
OwnPtrWillBeRawPtr<CSSAnimationUpdate> update = m_pendingUpdate.release();
m_previousActiveInterpolationsForAnimations.swap(update->activeInterpolationsForAnimations());
// FIXME: cancelling, pausing, unpausing animations all query compositingState, which is not necessarily up to date here
// since we call this from recalc style.
// https://code.google.com/p/chromium/issues/detail?id=339847
DisableCompositingQueryAsserts disabler;
for (const AtomicString& animationName : update->cancelledAnimationNames()) {
RefPtrWillBeRawPtr<AnimationPlayer> player = m_animations.take(animationName);
player->cancel();
player->update(TimingUpdateOnDemand);
}
for (const AtomicString& animationName : update->animationsWithPauseToggled()) {
AnimationPlayer* player = m_animations.get(animationName);
if (player->paused())
player->unpause();
else
player->pause();
if (player->outdated())
player->update(TimingUpdateOnDemand);
}
for (const auto& entry : update->newAnimations()) {
const InertAnimation* inertAnimation = entry.animation.get();
OwnPtrWillBeRawPtr<AnimationEventDelegate> eventDelegate = adoptPtrWillBeNoop(new AnimationEventDelegate(element, entry.name));
RefPtrWillBeRawPtr<Animation> animation = Animation::create(element, inertAnimation->effect(), inertAnimation->specifiedTiming(), Animation::DefaultPriority, eventDelegate.release());
animation->setName(inertAnimation->name());
RefPtrWillBeRawPtr<AnimationPlayer> player = element->document().timeline().createAnimationPlayer(animation.get());
if (inertAnimation->paused())
player->pause();
player->update(TimingUpdateOnDemand);
m_animations.set(entry.name, player.get());
}
// Transitions that are run on the compositor only update main-thread state
// lazily. However, we need the new state to know what the from state shoud
// be when transitions are retargeted. Instead of triggering complete style
// recalculation, we find these cases by searching for new transitions that
// have matching cancelled animation property IDs on the compositor.
WillBeHeapHashMap<CSSPropertyID, std::pair<RefPtrWillBeMember<Animation>, double>> retargetedCompositorTransitions;
for (CSSPropertyID id : update->cancelledTransitions()) {
ASSERT(m_transitions.contains(id));
RefPtrWillBeRawPtr<AnimationPlayer> player = m_transitions.take(id).player;
Animation* animation = toAnimation(player->source());
if (animation->hasActiveAnimationsOnCompositor(id) && update->newTransitions().find(id) != update->newTransitions().end())
retargetedCompositorTransitions.add(id, std::pair<RefPtrWillBeMember<Animation>, double>(animation, player->startTimeInternal()));
player->cancel();
player->update(TimingUpdateOnDemand);
}
for (const auto& entry : update->newTransitions()) {
const CSSAnimationUpdate::NewTransition& newTransition = entry.value;
RunningTransition runningTransition;
runningTransition.from = newTransition.from;
runningTransition.to = newTransition.to;
CSSPropertyID id = newTransition.id;
InertAnimation* inertAnimation = newTransition.animation.get();
OwnPtrWillBeRawPtr<TransitionEventDelegate> eventDelegate = adoptPtrWillBeNoop(new TransitionEventDelegate(element, newTransition.eventId));
RefPtrWillBeRawPtr<AnimationEffect> effect = inertAnimation->effect();
if (retargetedCompositorTransitions.contains(id)) {
const std::pair<RefPtrWillBeMember<Animation>, double>& oldTransition = retargetedCompositorTransitions.get(id);
RefPtrWillBeRawPtr<Animation> oldAnimation = oldTransition.first;
double oldStartTime = oldTransition.second;
double inheritedTime = isNull(oldStartTime) ? 0 : element->document().timeline().currentTimeInternal() - oldStartTime;
AnimatableValueKeyframeEffectModel* oldEffect = toAnimatableValueKeyframeEffectModel(inertAnimation->effect());
const KeyframeVector& frames = oldEffect->getFrames();
AnimatableValueKeyframeVector newFrames;
newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
newFrames[0]->clearPropertyValue(id);
RefPtrWillBeRawPtr<InertAnimation> inertAnimationForSampling = InertAnimation::create(oldAnimation->effect(), oldAnimation->specifiedTiming(), false);
OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<Interpolation>>> sample = inertAnimationForSampling->sample(inheritedTime);
ASSERT(sample->size() == 1);
newFrames[0]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
effect = AnimatableValueKeyframeEffectModel::create(newFrames);
}
RefPtrWillBeRawPtr<Animation> transition = Animation::create(element, effect, inertAnimation->specifiedTiming(), Animation::TransitionPriority, eventDelegate.release());
transition->setName(inertAnimation->name());
RefPtrWillBeRawPtr<AnimationPlayer> player = element->document().timeline().createAnimationPlayer(transition.get());
player->update(TimingUpdateOnDemand);
runningTransition.player = player;
m_transitions.set(id, runningTransition);
ASSERT(id != CSSPropertyInvalid);
blink::Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
}
}