wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
694e866a21
gecko/layout/style/nsTransitionManager.cpp

766 lines
30 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
/* 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/. */
/* Code to start and animate CSS transitions. */
#include "nsTransitionManager.h"
#include "nsAnimationManager.h"
#include "nsIContent.h"
#include "nsStyleContext.h"
#include "nsCSSProps.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/TimeStamp.h"
#include "nsRefreshDriver.h"
#include "nsRuleProcessorData.h"
#include "nsRuleWalker.h"
#include "nsCSSPropertySet.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/ContentEvents.h"
#include "mozilla/StyleAnimationValue.h"
#include "mozilla/dom/Element.h"
#include "nsIFrame.h"
#include "Layers.h"
#include "FrameLayerBuilder.h"
#include "nsDisplayList.h"
#include "nsStyleChangeList.h"
#include "nsStyleSet.h"
#include "RestyleManager.h"
using mozilla::TimeStamp;
using mozilla::TimeDuration;
using mozilla::dom::AnimationPlayer;
using mozilla::dom::Animation;
using namespace mozilla;
using namespace mozilla::layers;
using namespace mozilla::css;
double
ElementPropertyTransition::CurrentValuePortion() const
{
// It would be easy enough to handle finished transitions by using a time
// fraction of 1 but currently we should not be called for finished
// transitions.
MOZ_ASSERT(!IsFinishedTransition(),
"Getting the value portion of a finished transition");
MOZ_ASSERT(!GetLocalTime().IsNull(),
"Getting the value portion of an animation that's not being "
"sampled");
// Transitions use a fill mode of 'backwards' so GetComputedTiming will
// never return a null time fraction due to being *before* the animation
// interval. However, it might be possible that we're behind on flushing
// causing us to get called *after* the animation interval. So, just in
// case, we override the fill mode to 'both' to ensure the time fraction
// is never null.
AnimationTiming timingToUse = mTiming;
timingToUse.mFillMode = NS_STYLE_ANIMATION_FILL_MODE_BOTH;
ComputedTiming computedTiming = GetComputedTiming(&timingToUse);
MOZ_ASSERT(computedTiming.mTimeFraction != ComputedTiming::kNullTimeFraction,
"Got a null time fraction for a fill mode of 'both'");
MOZ_ASSERT(mProperties.Length() == 1,
"Should have one animation property for a transition");
MOZ_ASSERT(mProperties[0].mSegments.Length() == 1,
"Animation property should have one segment for a transition");
return mProperties[0].mSegments[0].mTimingFunction
.GetValue(computedTiming.mTimeFraction);
}
/*****************************************************************************
* CSSTransitionPlayer *
*****************************************************************************/
mozilla::dom::AnimationPlayState
CSSTransitionPlayer::PlayStateFromJS() const
{
FlushStyle();
return AnimationPlayer::PlayStateFromJS();
}
void
CSSTransitionPlayer::PlayFromJS()
{
FlushStyle();
AnimationPlayer::PlayFromJS();
}
CommonAnimationManager*
CSSTransitionPlayer::GetAnimationManager() const
{
nsPresContext* context = GetPresContext();
if (!context) {
return nullptr;
}
return context->TransitionManager();
}
/*****************************************************************************
* nsTransitionManager *
*****************************************************************************/
already_AddRefed<nsIStyleRule>
nsTransitionManager::StyleContextChanged(dom::Element *aElement,
nsStyleContext *aOldStyleContext,
nsStyleContext *aNewStyleContext)
{
NS_PRECONDITION(aOldStyleContext->GetPseudo() ==
aNewStyleContext->GetPseudo(),
"pseudo type mismatch");
if (mInAnimationOnlyStyleUpdate) {
// If we're doing an animation-only style update, return, since the
// purpose of an animation-only style update is to update only the
// animation styles so that we don't consider style changes
// resulting from changes in the animation time for starting a
// transition.
return nullptr;
}
if (!mPresContext->IsDynamic()) {
// For print or print preview, ignore transitions.
return nullptr;
}
if (aOldStyleContext->HasPseudoElementData() !=
aNewStyleContext->HasPseudoElementData()) {
// If the old style context and new style context differ in terms of
// whether they're inside ::first-letter, ::first-line, or similar,
// bail. We can't hit this codepath for normal style changes
// involving moving frames around the boundaries of these
// pseudo-elements since we don't call StyleContextChanged from
// ReparentStyleContext. However, we can hit this codepath during
// the handling of transitions that start across reframes.
//
// While there isn't an easy *perfect* way to handle this case, err
// on the side of missing some transitions that we ought to have
// rather than having bogus transitions that we shouldn't.
//
// We could consider changing this handling, although it's worth
// thinking about whether the code below could do anything weird in
// this case.
return nullptr;
}
// NOTE: Things in this function (and ConsiderStartingTransition)
// should never call PeekStyleData because we don't preserve gotten
// structs across reframes.
// Return sooner (before the startedAny check below) for the most
// common case: no transitions specified or running.
const nsStyleDisplay *disp = aNewStyleContext->StyleDisplay();
nsCSSPseudoElements::Type pseudoType = aNewStyleContext->GetPseudoType();
if (pseudoType != nsCSSPseudoElements::ePseudo_NotPseudoElement) {
if (pseudoType != nsCSSPseudoElements::ePseudo_before &&
pseudoType != nsCSSPseudoElements::ePseudo_after) {
return nullptr;
}
NS_ASSERTION((pseudoType == nsCSSPseudoElements::ePseudo_before &&
aElement->Tag() == nsGkAtoms::mozgeneratedcontentbefore) ||
(pseudoType == nsCSSPseudoElements::ePseudo_after &&
aElement->Tag() == nsGkAtoms::mozgeneratedcontentafter),
"Unexpected aElement coming through");
// Else the element we want to use from now on is the element the
// :before or :after is attached to.
aElement = aElement->GetParent()->AsElement();
}
AnimationPlayerCollection* collection =
GetAnimationPlayers(aElement, pseudoType, false);
if (!collection &&
disp->mTransitionPropertyCount == 1 &&
disp->mTransitions[0].GetDelay() == 0.0f &&
disp->mTransitions[0].GetDuration() == 0.0f) {
return nullptr;
}
// FIXME (bug 960465): This test should go away.
if (aNewStyleContext->PresContext()->RestyleManager()->
IsProcessingAnimationStyleChange()) {
return nullptr;
}
if (aNewStyleContext->GetParent() &&
aNewStyleContext->GetParent()->HasPseudoElementData()) {
// Ignore transitions on things that inherit properties from
// pseudo-elements.
// FIXME (Bug 522599): Add tests for this.
return nullptr;
}
NS_WARN_IF_FALSE(!nsLayoutUtils::AreAsyncAnimationsEnabled() ||
mPresContext->RestyleManager()->
ThrottledAnimationStyleIsUpToDate(),
"throttled animations not up to date");
// Per http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html
// I'll consider only the transitions from the number of items in
// 'transition-property' on down, and later ones will override earlier
// ones (tracked using |whichStarted|).
bool startedAny = false;
nsCSSPropertySet whichStarted;
for (uint32_t i = disp->mTransitionPropertyCount; i-- != 0; ) {
const StyleTransition& t = disp->mTransitions[i];
// Check delay and duration first, since they default to zero, and
// when they're both zero, we can ignore the transition.
if (t.GetDelay() != 0.0f || t.GetDuration() != 0.0f) {
// We might have something to transition. See if any of the
// properties in question changed and are animatable.
// FIXME: Would be good to find a way to share code between this
// interpretation of transition-property and the one below.
nsCSSProperty property = t.GetProperty();
if (property == eCSSPropertyExtra_no_properties ||
property == eCSSPropertyExtra_variable ||
property == eCSSProperty_UNKNOWN) {
// Nothing to do, but need to exclude this from cases below.
} else if (property == eCSSPropertyExtra_all_properties) {
for (nsCSSProperty p = nsCSSProperty(0);
p < eCSSProperty_COUNT_no_shorthands;
p = nsCSSProperty(p + 1)) {
ConsiderStartingTransition(p, t, aElement, collection,
aOldStyleContext, aNewStyleContext,
&startedAny, &whichStarted);
}
} else if (nsCSSProps::IsShorthand(property)) {
CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subprop, property) {
ConsiderStartingTransition(*subprop, t, aElement, collection,
aOldStyleContext, aNewStyleContext,
&startedAny, &whichStarted);
}
} else {
ConsiderStartingTransition(property, t, aElement, collection,
aOldStyleContext, aNewStyleContext,
&startedAny, &whichStarted);
}
}
}
// Stop any transitions for properties that are no longer in
// 'transition-property'.
// Also stop any transitions for properties that just changed (and are
// still in the set of properties to transition), but we didn't just
// start the transition because delay and duration are both zero.
if (collection) {
bool checkProperties =
disp->mTransitions[0].GetProperty() != eCSSPropertyExtra_all_properties;
nsCSSPropertySet allTransitionProperties;
if (checkProperties) {
for (uint32_t i = disp->mTransitionPropertyCount; i-- != 0; ) {
const StyleTransition& t = disp->mTransitions[i];
// FIXME: Would be good to find a way to share code between this
// interpretation of transition-property and the one above.
nsCSSProperty property = t.GetProperty();
if (property == eCSSPropertyExtra_no_properties ||
property == eCSSPropertyExtra_variable ||
property == eCSSProperty_UNKNOWN) {
// Nothing to do, but need to exclude this from cases below.
} else if (property == eCSSPropertyExtra_all_properties) {
for (nsCSSProperty p = nsCSSProperty(0);
p < eCSSProperty_COUNT_no_shorthands;
p = nsCSSProperty(p + 1)) {
allTransitionProperties.AddProperty(p);
}
} else if (nsCSSProps::IsShorthand(property)) {
CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subprop, property) {
allTransitionProperties.AddProperty(*subprop);
}
} else {
allTransitionProperties.AddProperty(property);
}
}
}
AnimationPlayerPtrArray& players = collection->mPlayers;
size_t i = players.Length();
NS_ABORT_IF_FALSE(i != 0, "empty transitions list?");
StyleAnimationValue currentValue;
do {
--i;
AnimationPlayer* player = players[i];
dom::Animation* anim = player->GetSource();
MOZ_ASSERT(anim && anim->Properties().Length() == 1,
"Should have one animation property for a transition");
MOZ_ASSERT(anim && anim->Properties()[0].mSegments.Length() == 1,
"Animation property should have one segment for a transition");
const AnimationProperty& prop = anim->Properties()[0];
const AnimationPropertySegment& segment = prop.mSegments[0];
// properties no longer in 'transition-property'
if ((checkProperties &&
!allTransitionProperties.HasProperty(prop.mProperty)) ||
// properties whose computed values changed but delay and
// duration are both zero
!ExtractComputedValueForTransition(prop.mProperty, aNewStyleContext,
currentValue) ||
currentValue != segment.mToValue) {
// stop the transition
players.RemoveElementAt(i);
collection->UpdateAnimationGeneration(mPresContext);
}
} while (i != 0);
if (players.IsEmpty()) {
collection->Destroy();
collection = nullptr;
}
}
if (!startedAny) {
return nullptr;
}
NS_ABORT_IF_FALSE(collection, "must have element transitions if we started "
"any transitions");
// In the CSS working group discussion (2009 Jul 15 telecon,
// http://www.w3.org/mid/4A5E1470.4030904@inkedblade.net ) of
// http://lists.w3.org/Archives/Public/www-style/2009Jun/0121.html ,
// the working group decided that a transition property on an
// element should not cause any transitions if the property change
// is itself inheriting a value that is transitioning on an
// ancestor. So, to get the correct behavior, we continue the
// restyle that caused this transition using a "covering" rule that
// covers up any changes on which we started transitions, so that
// descendants don't start their own transitions. (In the case of
// negative transition delay, this covering rule produces different
// results than applying the transition rule immediately would).
// Our caller is responsible for restyling again using this covering
// rule.
nsRefPtr<css::AnimValuesStyleRule> coverRule = new css::AnimValuesStyleRule;
AnimationPlayerPtrArray& players = collection->mPlayers;
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
dom::Animation* anim = players[i]->GetSource();
MOZ_ASSERT(anim && anim->Properties().Length() == 1,
"Should have one animation property for a transition");
MOZ_ASSERT(anim && anim->Properties()[0].mSegments.Length() == 1,
"Animation property should have one segment for a transition");
AnimationProperty& prop = anim->Properties()[0];
AnimationPropertySegment& segment = prop.mSegments[0];
if (whichStarted.HasProperty(prop.mProperty)) {
coverRule->AddValue(prop.mProperty, segment.mFromValue);
}
}
// Set the style rule refresh time to null so that EnsureStyleRuleFor
// creates a new style rule.
collection->mStyleRuleRefreshTime = TimeStamp();
return coverRule.forget();
}
void
nsTransitionManager::ConsiderStartingTransition(
nsCSSProperty aProperty,
const StyleTransition& aTransition,
dom::Element* aElement,
AnimationPlayerCollection*& aElementTransitions,
nsStyleContext* aOldStyleContext,
nsStyleContext* aNewStyleContext,
bool* aStartedAny,
nsCSSPropertySet* aWhichStarted)
{
// IsShorthand itself will assert if aProperty is not a property.
NS_ABORT_IF_FALSE(!nsCSSProps::IsShorthand(aProperty),
"property out of range");
NS_ASSERTION(!aElementTransitions ||
aElementTransitions->mElement == aElement, "Element mismatch");
if (aWhichStarted->HasProperty(aProperty)) {
// A later item in transition-property already started a
// transition for this property, so we ignore this one.
// See comment above and
// http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html .
return;
}
if (nsCSSProps::kAnimTypeTable[aProperty] == eStyleAnimType_None) {
return;
}
dom::AnimationTimeline* timeline = aElement->OwnerDoc()->Timeline();
StyleAnimationValue startValue, endValue, dummyValue;
bool haveValues =
ExtractComputedValueForTransition(aProperty, aOldStyleContext,
startValue) &&
ExtractComputedValueForTransition(aProperty, aNewStyleContext,
endValue);
bool haveChange = startValue != endValue;
bool shouldAnimate =
haveValues &&
haveChange &&
// Check that we can interpolate between these values
// (If this is ever a performance problem, we could add a
// CanInterpolate method, but it seems fine for now.)
StyleAnimationValue::Interpolate(aProperty, startValue, endValue,
0.5, dummyValue);
bool haveCurrentTransition = false;
size_t currentIndex = nsTArray<ElementPropertyTransition>::NoIndex;
const ElementPropertyTransition *oldPT = nullptr;
if (aElementTransitions) {
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
MOZ_ASSERT(players[i]->GetSource() &&
players[i]->GetSource()->Properties().Length() == 1,
"Should have one animation property for a transition");
if (players[i]->GetSource()->Properties()[0].mProperty == aProperty) {
haveCurrentTransition = true;
currentIndex = i;
oldPT = players[currentIndex]->GetSource()->AsTransition();
break;
}
}
}
// If we got a style change that changed the value to the endpoint
// of the currently running transition, we don't want to interrupt
// its timing function.
// This needs to be before the !shouldAnimate && haveCurrentTransition
// case below because we might be close enough to the end of the
// transition that the current value rounds to the final value. In
// this case, we'll end up with shouldAnimate as false (because
// there's no value change), but we need to return early here rather
// than cancel the running transition because shouldAnimate is false!
MOZ_ASSERT(!oldPT || oldPT->Properties()[0].mSegments.Length() == 1,
"Should have one animation property segment for a transition");
if (haveCurrentTransition && haveValues &&
oldPT->Properties()[0].mSegments[0].mToValue == endValue) {
// GetAnimationRule already called RestyleForAnimation.
return;
}
nsPresContext *presContext = aNewStyleContext->PresContext();
if (!shouldAnimate) {
if (haveCurrentTransition) {
// We're in the middle of a transition, and just got a non-transition
// style change to something that we can't animate. This might happen
// because we got a non-transition style change changing to the current
// in-progress value (which is particularly easy to cause when we're
// currently in the 'transition-delay'). It also might happen because we
// just got a style change to a value that can't be interpolated.
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
oldPT = nullptr; // Clear pointer so it doesn't dangle
players.RemoveElementAt(currentIndex);
aElementTransitions->UpdateAnimationGeneration(mPresContext);
if (players.IsEmpty()) {
aElementTransitions->Destroy();
// |aElementTransitions| is now a dangling pointer!
aElementTransitions = nullptr;
}
// GetAnimationRule already called RestyleForAnimation.
}
return;
}
const nsTimingFunction &tf = aTransition.GetTimingFunction();
float delay = aTransition.GetDelay();
float duration = aTransition.GetDuration();
if (duration < 0.0) {
// The spec says a negative duration is treated as zero.
duration = 0.0;
}
StyleAnimationValue startForReversingTest = startValue;
double reversePortion = 1.0;
// If the new transition reverses an existing one, we'll need to
// handle the timing differently.
if (haveCurrentTransition &&
!oldPT->IsFinishedTransition() &&
oldPT->mStartForReversingTest == endValue) {
// Compute the appropriate negative transition-delay such that right
// now we'd end up at the current position.
double valuePortion =
oldPT->CurrentValuePortion() * oldPT->mReversePortion +
(1.0 - oldPT->mReversePortion);
// A timing function with negative y1 (or y2!) might make
// valuePortion negative. In this case, we still want to apply our
// reversing logic based on relative distances, not make duration
// negative.
if (valuePortion < 0.0) {
valuePortion = -valuePortion;
}
// A timing function with y2 (or y1!) greater than one might
// advance past its terminal value. It's probably a good idea to
// clamp valuePortion to be at most one to preserve the invariant
// that a transition will complete within at most its specified
// time.
if (valuePortion > 1.0) {
valuePortion = 1.0;
}
// Negative delays are essentially part of the transition
// function, so reduce them along with the duration, but don't
// reduce positive delays.
if (delay < 0.0f) {
delay *= valuePortion;
}
duration *= valuePortion;
startForReversingTest = oldPT->Properties()[0].mSegments[0].mToValue;
reversePortion = valuePortion;
}
AnimationTiming timing;
timing.mIterationDuration = TimeDuration::FromMilliseconds(duration);
timing.mDelay = TimeDuration::FromMilliseconds(delay);
timing.mIterationCount = 1;
timing.mDirection = NS_STYLE_ANIMATION_DIRECTION_NORMAL;
timing.mFillMode = NS_STYLE_ANIMATION_FILL_MODE_BACKWARDS;
nsRefPtr<ElementPropertyTransition> pt =
new ElementPropertyTransition(aElement->OwnerDoc(), aElement,
aNewStyleContext->GetPseudoType(), timing);
pt->mStartForReversingTest = startForReversingTest;
pt->mReversePortion = reversePortion;
AnimationProperty& prop = *pt->Properties().AppendElement();
prop.mProperty = aProperty;
AnimationPropertySegment& segment = *prop.mSegments.AppendElement();
segment.mFromValue = startValue;
segment.mToValue = endValue;
segment.mFromKey = 0;
segment.mToKey = 1;
segment.mTimingFunction.Init(tf);
nsRefPtr<CSSTransitionPlayer> player = new CSSTransitionPlayer(timeline);
player->mStartTime = timeline->GetCurrentTime();
player->SetSource(pt);
if (!aElementTransitions) {
aElementTransitions =
GetAnimationPlayers(aElement, aNewStyleContext->GetPseudoType(), true);
if (!aElementTransitions) {
NS_WARNING("allocating CommonAnimationManager failed");
return;
}
}
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
#ifdef DEBUG
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
NS_ABORT_IF_FALSE(players[i]->GetSource() &&
players[i]->GetSource()->Properties().Length() == 1,
"Should have one animation property for a transition");
NS_ABORT_IF_FALSE(i == currentIndex ||
(players[i]->GetSource() &&
players[i]->GetSource()->Properties()[0].mProperty
!= aProperty),
"duplicate transitions for property");
}
#endif
if (haveCurrentTransition) {
players[currentIndex] = player;
} else {
if (!players.AppendElement(player)) {
NS_WARNING("out of memory");
return;
}
}
aElementTransitions->UpdateAnimationGeneration(mPresContext);
aElementTransitions->PostRestyleForAnimation(presContext);
*aStartedAny = true;
aWhichStarted->AddProperty(aProperty);
}
/*
* nsIStyleRuleProcessor implementation
*/
/* virtual */ size_t
nsTransitionManager::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
{
return CommonAnimationManager::SizeOfExcludingThis(aMallocSizeOf);
}
/* virtual */ size_t
nsTransitionManager::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
{
return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
}
struct TransitionEventInfo {
nsCOMPtr<nsIContent> mElement;
InternalTransitionEvent mEvent;
TransitionEventInfo(nsIContent *aElement, nsCSSProperty aProperty,
TimeDuration aDuration, const nsAString& aPseudoElement)
: mElement(aElement)
, mEvent(true, NS_TRANSITION_END)
{
// XXX Looks like nobody initialize WidgetEvent::time
mEvent.propertyName =
NS_ConvertUTF8toUTF16(nsCSSProps::GetStringValue(aProperty));
mEvent.elapsedTime = aDuration.ToSeconds();
mEvent.pseudoElement = aPseudoElement;
}
// InternalTransitionEvent doesn't support copy-construction, so we need
// to ourselves in order to work with nsTArray
TransitionEventInfo(const TransitionEventInfo &aOther)
: mElement(aOther.mElement)
, mEvent(true, NS_TRANSITION_END)
{
mEvent.AssignTransitionEventData(aOther.mEvent, false);
}
};
/* virtual */ void
nsTransitionManager::WillRefresh(mozilla::TimeStamp aTime)
{
NS_ABORT_IF_FALSE(mPresContext,
"refresh driver should not notify additional observers "
"after pres context has been destroyed");
if (!mPresContext->GetPresShell()) {
// Someone might be keeping mPresContext alive past the point
// where it has been torn down; don't bother doing anything in
// this case. But do get rid of all our transitions so we stop
// triggering refreshes.
RemoveAllElementCollections();
return;
}
FlushTransitions(Can_Throttle);
}
void
nsTransitionManager::FlushTransitions(FlushFlags aFlags)
{
if (PR_CLIST_IS_EMPTY(&mElementCollections)) {
// no transitions, leave early
return;
}
nsTArray<TransitionEventInfo> events;
TimeStamp now = mPresContext->RefreshDriver()->MostRecentRefresh();
bool didThrottle = false;
// Trim transitions that have completed, post restyle events for frames that
// are still transitioning, and start transitions with delays.
{
PRCList *next = PR_LIST_HEAD(&mElementCollections);
while (next != &mElementCollections) {
AnimationPlayerCollection* collection =
static_cast<AnimationPlayerCollection*>(next);
next = PR_NEXT_LINK(next);
collection->Tick();
bool canThrottleTick = aFlags == Can_Throttle &&
collection->CanPerformOnCompositorThread(
AnimationPlayerCollection::CanAnimateFlags(0)) &&
collection->CanThrottleAnimation(now);
NS_ABORT_IF_FALSE(collection->mElement->GetCrossShadowCurrentDoc() ==
mPresContext->Document(),
"Element::UnbindFromTree should have "
"destroyed the element transitions object");
size_t i = collection->mPlayers.Length();
NS_ABORT_IF_FALSE(i != 0, "empty transitions list?");
bool transitionStartedOrEnded = false;
do {
--i;
AnimationPlayer* player = collection->mPlayers[i];
if (player->GetSource()->IsFinishedTransition()) {
// Actually remove transitions one throttle-able cycle after their
// completion. We only clear on a throttle-able cycle because that
// means it is a regular restyle tick and thus it is safe to discard
// the transition. If the flush is not throttle-able, we might still
// have new transitions left to process. See comment below.
if (aFlags == Can_Throttle) {
collection->mPlayers.RemoveElementAt(i);
}
} else {
MOZ_ASSERT(player->GetSource(),
"Transitions should have source content");
ComputedTiming computedTiming =
player->GetSource()->GetComputedTiming();
if (computedTiming.mPhase == ComputedTiming::AnimationPhase_After) {
MOZ_ASSERT(player->GetSource()->Properties().Length() == 1,
"Should have one animation property for a transition");
nsCSSProperty prop = player->GetSource()->Properties()[0].mProperty;
if (nsCSSProps::PropHasFlags(prop, CSS_PROPERTY_REPORT_OTHER_NAME))
{
prop = nsCSSProps::OtherNameFor(prop);
}
TimeDuration duration =
player->GetSource()->Timing().mIterationDuration;
events.AppendElement(
TransitionEventInfo(collection->mElement, prop,
duration,
collection->PseudoElement()));
// Leave this transition in the list for one more refresh
// cycle, since we haven't yet processed its style change, and
// if we also have (already, or will have from processing
// transitionend events or other refresh driver notifications)
// a non-animation style change that would affect it, we need
// to know not to start a new transition for the transition
// from the almost-completed value to the final value.
player->GetSource()->SetIsFinishedTransition();
collection->UpdateAnimationGeneration(mPresContext);
transitionStartedOrEnded = true;
} else if ((computedTiming.mPhase ==
ComputedTiming::AnimationPhase_Active) &&
canThrottleTick &&
!player->IsRunningOnCompositor()) {
// Start a transition with a delay where we should start the
// transition proper.
collection->UpdateAnimationGeneration(mPresContext);
transitionStartedOrEnded = true;
}
}
} while (i != 0);
// We need to restyle even if the transition rule no longer
// applies (in which case we just made it not apply).
MOZ_ASSERT(collection->mElementProperty ==
nsGkAtoms::transitionsProperty ||
collection->mElementProperty ==
nsGkAtoms::transitionsOfBeforeProperty ||
collection->mElementProperty ==
nsGkAtoms::transitionsOfAfterProperty,
"Unexpected element property; might restyle too much");
if (!canThrottleTick || transitionStartedOrEnded) {
collection->PostRestyleForAnimation(mPresContext);
} else {
didThrottle = true;
}
if (collection->mPlayers.IsEmpty()) {
collection->Destroy();
// |collection| is now a dangling pointer!
collection = nullptr;
}
}
}
if (didThrottle) {
mPresContext->Document()->SetNeedStyleFlush();
}
for (uint32_t i = 0, i_end = events.Length(); i < i_end; ++i) {
TransitionEventInfo &info = events[i];
EventDispatcher::Dispatch(info.mElement, mPresContext, &info.mEvent);
if (!mPresContext) {
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink