diff --git a/layout/base/nsDisplayList.cpp b/layout/base/nsDisplayList.cpp index 0c295782a1f..3c61256f33d 100644 --- a/layout/base/nsDisplayList.cpp +++ b/layout/base/nsDisplayList.cpp @@ -415,12 +415,12 @@ nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(Layer* aLayer, if (!content) { return; } - ElementAnimationCollection* et = + ElementAnimationCollection* transitions = nsTransitionManager::GetAnimationsForCompositor(content, aProperty); - ElementAnimationCollection* ea = + ElementAnimationCollection* animations = nsAnimationManager::GetAnimationsForCompositor(content, aProperty); - if (!ea && !et) { + if (!animations && !transitions) { return; } @@ -475,16 +475,16 @@ nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(Layer* aLayer, data = null_t(); } - if (et) { - AddAnimationsForProperty(aFrame, aProperty, et->mAnimations, + if (transitions) { + AddAnimationsForProperty(aFrame, aProperty, transitions->mAnimations, aLayer, data, pending); - aLayer->SetAnimationGeneration(et->mAnimationGeneration); + aLayer->SetAnimationGeneration(transitions->mAnimationGeneration); } - if (ea) { - AddAnimationsForProperty(aFrame, aProperty, ea->mAnimations, + if (animations) { + AddAnimationsForProperty(aFrame, aProperty, animations->mAnimations, aLayer, data, pending); - aLayer->SetAnimationGeneration(ea->mAnimationGeneration); + aLayer->SetAnimationGeneration(animations->mAnimationGeneration); } } diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp index 6261b0e8dc6..21c310c9a8b 100644 --- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -261,15 +261,15 @@ GetAnimationsOrTransitionsForCompositor(nsIContent* aContent, nsIAtom* aAnimationProperty, nsCSSProperty aProperty) { - ElementAnimationCollection* animations = + ElementAnimationCollection* collection = static_cast( aContent->GetProperty(aAnimationProperty)); - if (animations) { - bool propertyMatches = animations->HasAnimationOfProperty(aProperty); + if (collection) { + bool propertyMatches = collection->HasAnimationOfProperty(aProperty); if (propertyMatches && - animations->CanPerformOnCompositorThread( + collection->CanPerformOnCompositorThread( ElementAnimationCollection::CanAnimate_AllowPartial)) { - return animations; + return collection; } } @@ -293,13 +293,13 @@ GetAnimationsOrTransitions(nsIContent* aContent, nsIAtom* aAnimationProperty, nsCSSProperty aProperty) { - ElementAnimationCollection* animations = + ElementAnimationCollection* collection = static_cast(aContent->GetProperty( aAnimationProperty)); - if (animations) { - bool propertyMatches = animations->HasAnimationOfProperty(aProperty); + if (collection) { + bool propertyMatches = collection->HasAnimationOfProperty(aProperty); if (propertyMatches) { - return animations; + return collection; } } return nullptr; @@ -327,10 +327,10 @@ nsLayoutUtils::HasCurrentAnimations(nsIContent* aContent, TimeStamp now = aPresContext->RefreshDriver()->MostRecentRefresh(); - ElementAnimationCollection* animations = + ElementAnimationCollection* collection = static_cast( aContent->GetProperty(aAnimationProperty)); - return (animations && animations->HasCurrentAnimationsAt(now)); + return (collection && collection->HasCurrentAnimationsAt(now)); } static gfxSize @@ -391,14 +391,14 @@ GetMinAndMaxScaleForAnimationProperty(nsIContent* aContent, gfxSize& aMaxScale, gfxSize& aMinScale) { - ElementAnimationCollection* animations = + ElementAnimationCollection* collection = GetAnimationsOrTransitionsForCompositor(aContent, aAnimationProperty, eCSSProperty_transform); - if (!animations) + if (!collection) return; - for (uint32_t animIdx = animations->mAnimations.Length(); animIdx-- != 0; ) { - mozilla::ElementAnimation* anim = animations->mAnimations[animIdx]; + for (uint32_t animIdx = collection->mAnimations.Length(); animIdx-- != 0; ) { + mozilla::ElementAnimation* anim = collection->mAnimations[animIdx]; if (anim->IsFinishedTransition()) { continue; } diff --git a/layout/style/AnimationCommon.cpp b/layout/style/AnimationCommon.cpp index 3a7452652f8..8d2d304574e 100644 --- a/layout/style/AnimationCommon.cpp +++ b/layout/style/AnimationCommon.cpp @@ -84,19 +84,19 @@ CommonAnimationManager::GetAnimationsForCompositor(nsIContent* aContent, { if (!aContent->MayHaveAnimations()) return nullptr; - ElementAnimationCollection* animations = + ElementAnimationCollection* collection = static_cast( aContent->GetProperty(aElementProperty)); - if (!animations || - !animations->HasAnimationOfProperty(aProperty) || - !animations->CanPerformOnCompositorThread( + if (!collection || + !collection->HasAnimationOfProperty(aProperty) || + !collection->CanPerformOnCompositorThread( ElementAnimationCollection::CanAnimate_AllowPartial)) { return nullptr; } // This animation can be done on the compositor. // Mark the frame as active, in case we are able to throttle this animation. - nsIFrame* frame = nsLayoutUtils::GetStyleFrame(animations->mElement); + nsIFrame* frame = nsLayoutUtils::GetStyleFrame(collection->mElement); if (frame) { if (aProperty == eCSSProperty_opacity) { ActiveLayerTracker::NotifyAnimated(frame, eCSSProperty_opacity); @@ -105,7 +105,7 @@ CommonAnimationManager::GetAnimationsForCompositor(nsIContent* aContent, } } - return animations; + return collection; } /* @@ -256,31 +256,31 @@ CommonAnimationManager::UpdateThrottledStyle(dom::Element* aElement, curRule.mLevel = ruleNode->GetLevel(); if (curRule.mLevel == nsStyleSet::eAnimationSheet) { - ElementAnimationCollection* ea = + ElementAnimationCollection* collection = mPresContext->AnimationManager()->GetElementAnimations( aElement, oldStyle->GetPseudoType(), false); - NS_ASSERTION(ea, + NS_ASSERTION(collection, "Rule has level eAnimationSheet without animation on manager"); mPresContext->AnimationManager()->UpdateStyleAndEvents( - ea, mPresContext->RefreshDriver()->MostRecentRefresh(), + collection, mPresContext->RefreshDriver()->MostRecentRefresh(), EnsureStyleRule_IsNotThrottled); - curRule.mRule = ea->mStyleRule; + curRule.mRule = collection->mStyleRule; } else if (curRule.mLevel == nsStyleSet::eTransitionSheet) { - ElementAnimationCollection* et = + ElementAnimationCollection* collection = mPresContext->TransitionManager()->GetElementTransitions( aElement, oldStyle->GetPseudoType(), false); - NS_ASSERTION(et, + NS_ASSERTION(collection, "Rule has level eTransitionSheet without transition on manager"); - et->EnsureStyleRuleFor( + collection->EnsureStyleRuleFor( mPresContext->RefreshDriver()->MostRecentRefresh(), EnsureStyleRule_IsNotThrottled); - curRule.mRule = et->mStyleRule; + curRule.mRule = collection->mStyleRule; } else { curRule.mRule = ruleNode->GetRule(); } @@ -584,8 +584,8 @@ ElementAnimation::ActiveDuration(const AnimationTiming& aTiming) bool ElementAnimationCollection::CanAnimatePropertyOnCompositor( const dom::Element *aElement, - nsCSSProperty aProperty, - CanAnimateFlags aFlags) + nsCSSProperty aProperty, + CanAnimateFlags aFlags) { bool shouldLog = nsLayoutUtils::IsAnimationLoggingEnabled(); if (!gfxPlatform::OffMainThreadCompositingEnabled()) { @@ -759,13 +759,13 @@ ElementAnimationCollection::LogAsyncAnimationFailure(nsCString& aMessage, ElementAnimationCollection::PropertyDtor(void *aObject, nsIAtom *aPropertyName, void *aPropertyValue, void *aData) { - ElementAnimationCollection* data = + ElementAnimationCollection* collection = static_cast(aPropertyValue); #ifdef DEBUG - NS_ABORT_IF_FALSE(!data->mCalledPropertyDtor, "can't call dtor twice"); - data->mCalledPropertyDtor = true; + NS_ABORT_IF_FALSE(!collection->mCalledPropertyDtor, "can't call dtor twice"); + collection->mCalledPropertyDtor = true; #endif - delete data; + delete collection; } void diff --git a/layout/style/AnimationCommon.h b/layout/style/AnimationCommon.h index 26ac07c607c..a32ca603f57 100644 --- a/layout/style/AnimationCommon.h +++ b/layout/style/AnimationCommon.h @@ -119,11 +119,11 @@ class_::UpdateAllThrottledStylesInternal() \ its descendants*/ \ PRCList *next = PR_LIST_HEAD(&mElementData); \ while (next != &mElementData) { \ - ElementAnimationCollection* ea = \ + ElementAnimationCollection* collection = \ static_cast(next); \ next = PR_NEXT_LINK(next); \ \ - if (ea->mFlushGeneration == now) { \ + if (collection->mFlushGeneration == now) { \ /* this element has been ticked already */ \ continue; \ } \ @@ -131,7 +131,7 @@ class_::UpdateAllThrottledStylesInternal() \ /* element is initialised to the starting element (i.e., one we know has an animation) and ends up with the root-most animated ancestor, that is, the element where we begin updates. */ \ - dom::Element* element = ea->mElement; \ + dom::Element* element = collection->mElement; \ /* make a list of ancestors */ \ nsTArray ancestors; \ do { \ diff --git a/layout/style/nsAnimationManager.cpp b/layout/style/nsAnimationManager.cpp index e883effbca6..fadd1d00d0e 100644 --- a/layout/style/nsAnimationManager.cpp +++ b/layout/style/nsAnimationManager.cpp @@ -25,22 +25,23 @@ using namespace mozilla; using namespace mozilla::css; void -nsAnimationManager::UpdateStyleAndEvents(ElementAnimationCollection* aEA, +nsAnimationManager::UpdateStyleAndEvents(ElementAnimationCollection* + aCollection, TimeStamp aRefreshTime, EnsureStyleRuleFlags aFlags) { - aEA->EnsureStyleRuleFor(aRefreshTime, aFlags); - GetEventsAt(aEA, aRefreshTime, mPendingEvents); + aCollection->EnsureStyleRuleFor(aRefreshTime, aFlags); + GetEventsAt(aCollection, aRefreshTime, mPendingEvents); CheckNeedsRefresh(); } void -nsAnimationManager::GetEventsAt(ElementAnimationCollection* aEA, +nsAnimationManager::GetEventsAt(ElementAnimationCollection* aCollection, TimeStamp aRefreshTime, EventArray& aEventsToDispatch) { - for (uint32_t animIdx = aEA->mAnimations.Length(); animIdx-- != 0; ) { - ElementAnimation* anim = aEA->mAnimations[animIdx]; + for (uint32_t animIdx = aCollection->mAnimations.Length(); animIdx-- != 0; ) { + ElementAnimation* anim = aCollection->mAnimations[animIdx]; TimeDuration localTime = anim->GetLocalTimeAt(aRefreshTime); ComputedTiming computedTiming = @@ -70,8 +71,8 @@ nsAnimationManager::GetEventsAt(ElementAnimationCollection* aEA, computedTiming.mCurrentIteration; TimeDuration elapsedTime = std::max(iterationStart, anim->InitialAdvance()); - AnimationEventInfo ei(aEA->mElement, anim->mName, message, - elapsedTime, aEA->PseudoElement()); + AnimationEventInfo ei(aCollection->mElement, anim->mName, message, + elapsedTime, aCollection->PseudoElement()); aEventsToDispatch.AppendElement(ei); } break; @@ -87,17 +88,19 @@ nsAnimationManager::GetEventsAt(ElementAnimationCollection* aEA, anim->mLastNotification = 0; TimeDuration elapsedTime = std::min(anim->InitialAdvance(), computedTiming.mActiveDuration); - AnimationEventInfo ei(aEA->mElement, anim->mName, NS_ANIMATION_START, - elapsedTime, aEA->PseudoElement()); + AnimationEventInfo ei(aCollection->mElement, + anim->mName, NS_ANIMATION_START, + elapsedTime, aCollection->PseudoElement()); aEventsToDispatch.AppendElement(ei); } // Dispatch 'animationend' when needed. if (anim->mLastNotification != ElementAnimation::LAST_NOTIFICATION_END) { anim->mLastNotification = ElementAnimation::LAST_NOTIFICATION_END; - AnimationEventInfo ei(aEA->mElement, anim->mName, NS_ANIMATION_END, + AnimationEventInfo ei(aCollection->mElement, + anim->mName, NS_ANIMATION_END, computedTiming.mActiveDuration, - aEA->PseudoElement()); + aCollection->PseudoElement()); aEventsToDispatch.AppendElement(ei); } break; @@ -128,28 +131,29 @@ nsAnimationManager::GetElementAnimations(dom::Element *aElement, "other than :before or :after"); return nullptr; } - ElementAnimationCollection *ea = static_cast( - aElement->GetProperty(propName)); - if (!ea && aCreateIfNeeded) { + ElementAnimationCollection* collection = + static_cast(aElement->GetProperty(propName)); + if (!collection && aCreateIfNeeded) { // FIXME: Consider arena-allocating? - ea = new ElementAnimationCollection(aElement, propName, this, - mPresContext->RefreshDriver()->MostRecentRefresh()); + collection = + new ElementAnimationCollection(aElement, propName, this, + mPresContext->RefreshDriver()->MostRecentRefresh()); nsresult rv = - aElement->SetProperty(propName, ea, + aElement->SetProperty(propName, collection, &ElementAnimationCollection::PropertyDtor, false); if (NS_FAILED(rv)) { NS_WARNING("SetProperty failed"); - delete ea; + delete collection; return nullptr; } if (propName == nsGkAtoms::animationsProperty) { aElement->SetMayHaveAnimations(); } - AddElementData(ea); + AddElementData(collection); } - return ea; + return collection; } /* virtual */ void @@ -227,10 +231,10 @@ nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext, // Likewise, when we initially construct frames, we're not in a // style change, but also not in an animation restyle. - const nsStyleDisplay *disp = aStyleContext->StyleDisplay(); - ElementAnimationCollection *ea = + const nsStyleDisplay* disp = aStyleContext->StyleDisplay(); + ElementAnimationCollection* collection = GetElementAnimations(aElement, aStyleContext->GetPseudoType(), false); - if (!ea && + if (!collection && disp->mAnimationNameCount == 1 && disp->mAnimations[0].GetName().IsEmpty()) { return nullptr; @@ -241,18 +245,18 @@ nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext, BuildAnimations(aStyleContext, newAnimations); if (newAnimations.IsEmpty()) { - if (ea) { - ea->Destroy(); + if (collection) { + collection->Destroy(); } return nullptr; } TimeStamp refreshTime = mPresContext->RefreshDriver()->MostRecentRefresh(); - if (ea) { - ea->mStyleRule = nullptr; - ea->mStyleRuleRefreshTime = TimeStamp(); - ea->UpdateAnimationGeneration(mPresContext); + if (collection) { + collection->mStyleRule = nullptr; + collection->mStyleRuleRefreshTime = TimeStamp(); + collection->UpdateAnimationGeneration(mPresContext); // Copy over the start times and (if still paused) pause starts // for each animation (matching on name only) that was also in the @@ -264,7 +268,7 @@ nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext, // In order to honor what the spec said, we'd copy more data over // (or potentially optimize BuildAnimations to avoid rebuilding it // in the first place). - if (!ea->mAnimations.IsEmpty()) { + if (!collection->mAnimations.IsEmpty()) { for (uint32_t newIdx = 0, newEnd = newAnimations.Length(); newIdx != newEnd; ++newIdx) { nsRefPtr newAnim = newAnimations[newIdx]; @@ -278,8 +282,9 @@ nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext, // We'll use the last one since it's more likely to be the one // doing something. const ElementAnimation* oldAnim = nullptr; - for (uint32_t oldIdx = ea->mAnimations.Length(); oldIdx-- != 0; ) { - const ElementAnimation* a = ea->mAnimations[oldIdx]; + for (uint32_t oldIdx = collection->mAnimations.Length(); + oldIdx-- != 0; ) { + const ElementAnimation* a = collection->mAnimations[oldIdx]; if (a->mName == newAnim->mName) { oldAnim = a; break; @@ -305,13 +310,14 @@ nsAnimationManager::CheckAnimationRule(nsStyleContext* aStyleContext, } } } else { - ea = GetElementAnimations(aElement, aStyleContext->GetPseudoType(), - true); + collection = + GetElementAnimations(aElement, aStyleContext->GetPseudoType(), true); } - ea->mAnimations.SwapElements(newAnimations); - ea->mNeedsRefreshes = true; + collection->mAnimations.SwapElements(newAnimations); + collection->mNeedsRefreshes = true; - UpdateStyleAndEvents(ea, refreshTime, EnsureStyleRule_IsNotThrottled); + UpdateStyleAndEvents(collection, refreshTime, + EnsureStyleRule_IsNotThrottled); // We don't actually dispatch the mPendingEvents now. We'll either // dispatch them the next time we get a refresh driver notification // or the next time somebody calls @@ -614,9 +620,9 @@ nsAnimationManager::GetAnimationRule(mozilla::dom::Element* aElement, return nullptr; } - ElementAnimationCollection *ea = + ElementAnimationCollection* collection = GetElementAnimations(aElement, aPseudoType, false); - if (!ea) { + if (!collection) { return nullptr; } @@ -625,19 +631,19 @@ nsAnimationManager::GetAnimationRule(mozilla::dom::Element* aElement, // During the non-animation part of processing restyles, we don't // add the animation rule. - if (ea->mStyleRule) { - ea->PostRestyleForAnimation(mPresContext); + if (collection->mStyleRule) { + collection->PostRestyleForAnimation(mPresContext); } return nullptr; } - NS_WARN_IF_FALSE(!ea->mNeedsRefreshes || - ea->mStyleRuleRefreshTime == + NS_WARN_IF_FALSE(!collection->mNeedsRefreshes || + collection->mStyleRuleRefreshTime == mPresContext->RefreshDriver()->MostRecentRefresh(), "should already have refreshed style rule"); - return ea->mStyleRule; + return collection->mStyleRule; } /* virtual */ void @@ -702,19 +708,19 @@ nsAnimationManager::FlushAnimations(FlushFlags aFlags) bool didThrottle = false; for (PRCList *l = PR_LIST_HEAD(&mElementData); l != &mElementData; l = PR_NEXT_LINK(l)) { - ElementAnimationCollection *ea = + ElementAnimationCollection* collection = static_cast(l); bool canThrottleTick = aFlags == Can_Throttle && - ea->CanPerformOnCompositorThread( + collection->CanPerformOnCompositorThread( ElementAnimationCollection::CanAnimateFlags(0)) && - ea->CanThrottleAnimation(now); + collection->CanThrottleAnimation(now); - nsRefPtr oldStyleRule = ea->mStyleRule; - UpdateStyleAndEvents(ea, now, canThrottleTick - ? EnsureStyleRule_IsThrottled - : EnsureStyleRule_IsNotThrottled); - if (oldStyleRule != ea->mStyleRule) { - ea->PostRestyleForAnimation(mPresContext); + nsRefPtr oldStyleRule = collection->mStyleRule; + UpdateStyleAndEvents(collection, now, canThrottleTick + ? EnsureStyleRule_IsThrottled + : EnsureStyleRule_IsNotThrottled); + if (oldStyleRule != collection->mStyleRule) { + collection->PostRestyleForAnimation(mPresContext); } else { didThrottle = true; } @@ -756,15 +762,17 @@ nsAnimationManager::UpdateThrottledStylesForSubtree(nsIContent* aContent, nsRefPtr newStyle; - ElementAnimationCollection* ea; + ElementAnimationCollection* collection; if (element && - (ea = GetElementAnimations(element, - nsCSSPseudoElements::ePseudo_NotPseudoElement, - false))) { + (collection = + GetElementAnimations(element, + nsCSSPseudoElements::ePseudo_NotPseudoElement, + false))) { // re-resolve our style newStyle = UpdateThrottledStyle(element, aParentStyle, aChangeList); // remove the current transition from the working set - ea->mFlushGeneration = mPresContext->RefreshDriver()->MostRecentRefresh(); + collection->mFlushGeneration = + mPresContext->RefreshDriver()->MostRecentRefresh(); } else { newStyle = ReparentContent(aContent, aParentStyle); } diff --git a/layout/style/nsTransitionManager.cpp b/layout/style/nsTransitionManager.cpp index b4cadb86146..98ec569a928 100644 --- a/layout/style/nsTransitionManager.cpp +++ b/layout/style/nsTransitionManager.cpp @@ -85,15 +85,17 @@ nsTransitionManager::UpdateThrottledStylesForSubtree(nsIContent* aContent, nsRefPtr newStyle; - ElementAnimationCollection* et; + ElementAnimationCollection* collection; if (element && - (et = GetElementTransitions(element, - nsCSSPseudoElements::ePseudo_NotPseudoElement, - false))) { + (collection = + GetElementTransitions(element, + nsCSSPseudoElements::ePseudo_NotPseudoElement, + false))) { // re-resolve our style newStyle = UpdateThrottledStyle(element, aParentStyle, aChangeList); // remove the current transition from the working set - et->mFlushGeneration = mPresContext->RefreshDriver()->MostRecentRefresh(); + collection->mFlushGeneration = + mPresContext->RefreshDriver()->MostRecentRefresh(); } else { newStyle = ReparentContent(aContent, aParentStyle); } @@ -196,9 +198,9 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, aElement = aElement->GetParent()->AsElement(); } - ElementAnimationCollection* et = + ElementAnimationCollection* collection = GetElementTransitions(aElement, pseudoType, false); - if (!et && + if (!collection && disp->mTransitionPropertyCount == 1 && disp->mTransitions[0].GetDelay() == 0.0f && disp->mTransitions[0].GetDuration() == 0.0f) { @@ -246,18 +248,18 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, for (nsCSSProperty p = nsCSSProperty(0); p < eCSSProperty_COUNT_no_shorthands; p = nsCSSProperty(p + 1)) { - ConsiderStartingTransition(p, t, aElement, et, + ConsiderStartingTransition(p, t, aElement, collection, aOldStyleContext, aNewStyleContext, &startedAny, &whichStarted); } } else if (nsCSSProps::IsShorthand(property)) { CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subprop, property) { - ConsiderStartingTransition(*subprop, t, aElement, et, + ConsiderStartingTransition(*subprop, t, aElement, collection, aOldStyleContext, aNewStyleContext, &startedAny, &whichStarted); } } else { - ConsiderStartingTransition(property, t, aElement, et, + ConsiderStartingTransition(property, t, aElement, collection, aOldStyleContext, aNewStyleContext, &startedAny, &whichStarted); } @@ -269,7 +271,7 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, // 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 (et) { + if (collection) { bool checkProperties = disp->mTransitions[0].GetProperty() != eCSSPropertyExtra_all_properties; nsCSSPropertySet allTransitionProperties; @@ -299,7 +301,7 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, } } - ElementAnimationPtrArray& animations = et->mAnimations; + ElementAnimationPtrArray& animations = collection->mAnimations; uint32_t i = animations.Length(); NS_ABORT_IF_FALSE(i != 0, "empty transitions list?"); StyleAnimationValue currentValue; @@ -322,13 +324,13 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, currentValue != segment.mToValue) { // stop the transition animations.RemoveElementAt(i); - et->UpdateAnimationGeneration(mPresContext); + collection->UpdateAnimationGeneration(mPresContext); } } while (i != 0); if (animations.IsEmpty()) { - et->Destroy(); - et = nullptr; + collection->Destroy(); + collection = nullptr; } } @@ -336,8 +338,8 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, return nullptr; } - NS_ABORT_IF_FALSE(et, "must have element transitions if we started " - "any transitions"); + 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 @@ -356,7 +358,7 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, nsRefPtr coverRule = new css::AnimValuesStyleRule; - ElementAnimationPtrArray& animations = et->mAnimations; + ElementAnimationPtrArray& animations = collection->mAnimations; for (uint32_t i = 0, i_end = animations.Length(); i < i_end; ++i) { ElementAnimation* animation = animations[i]; MOZ_ASSERT(animation->mProperties.Length() == 1, @@ -370,7 +372,7 @@ nsTransitionManager::StyleContextChanged(dom::Element *aElement, } } - et->mStyleRule = nullptr; + collection->mStyleRule = nullptr; return coverRule.forget(); } @@ -590,9 +592,10 @@ nsTransitionManager::ConsiderStartingTransition( } ElementAnimationCollection* -nsTransitionManager::GetElementTransitions(dom::Element *aElement, - nsCSSPseudoElements::Type aPseudoType, - bool aCreateIfNeeded) +nsTransitionManager::GetElementTransitions( + dom::Element *aElement, + nsCSSPseudoElements::Type aPseudoType, + bool aCreateIfNeeded) { if (!aCreateIfNeeded && PR_CLIST_IS_EMPTY(&mElementData)) { // Early return for the most common case. @@ -612,28 +615,28 @@ nsTransitionManager::GetElementTransitions(dom::Element *aElement, "other than :before or :after"); return nullptr; } - ElementAnimationCollection* et = + ElementAnimationCollection* collection = static_cast(aElement->GetProperty(propName)); - if (!et && aCreateIfNeeded) { + if (!collection && aCreateIfNeeded) { // FIXME: Consider arena-allocating? - et = new ElementAnimationCollection(aElement, propName, this, + collection = new ElementAnimationCollection(aElement, propName, this, mPresContext->RefreshDriver()->MostRecentRefresh()); nsresult rv = - aElement->SetProperty(propName, et, + aElement->SetProperty(propName, collection, &ElementAnimationCollection::PropertyDtor, false); if (NS_FAILED(rv)) { NS_WARNING("SetProperty failed"); - delete et; + delete collection; return nullptr; } if (propName == nsGkAtoms::transitionsProperty) { aElement->SetMayHaveAnimations(); } - AddElementData(et); + AddElementData(collection); } - return et; + return collection; } /* @@ -641,12 +644,13 @@ nsTransitionManager::GetElementTransitions(dom::Element *aElement, */ void -nsTransitionManager::WalkTransitionRule(ElementDependentRuleProcessorData* aData, - nsCSSPseudoElements::Type aPseudoType) +nsTransitionManager::WalkTransitionRule( + ElementDependentRuleProcessorData* aData, + nsCSSPseudoElements::Type aPseudoType) { - ElementAnimationCollection* et = + ElementAnimationCollection* collection = GetElementTransitions(aData->mElement, aPseudoType, false); - if (!et) { + if (!collection) { return; } @@ -664,17 +668,17 @@ nsTransitionManager::WalkTransitionRule(ElementDependentRuleProcessorData* aData // We need to immediately restyle with animation // after doing this. - et->PostRestyleForAnimation(mPresContext); + collection->PostRestyleForAnimation(mPresContext); return; } - et->mNeedsRefreshes = true; - et->EnsureStyleRuleFor( + collection->mNeedsRefreshes = true; + collection->EnsureStyleRuleFor( aData->mPresContext->RefreshDriver()->MostRecentRefresh(), EnsureStyleRule_IsNotThrottled); - if (et->mStyleRule) { - aData->mRuleWalker->Forward(et->mStyleRule); + if (collection->mStyleRule) { + aData->mRuleWalker->Forward(collection->mStyleRule); } } @@ -783,26 +787,26 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) { PRCList *next = PR_LIST_HEAD(&mElementData); while (next != &mElementData) { - ElementAnimationCollection* et = + ElementAnimationCollection* collection = static_cast(next); next = PR_NEXT_LINK(next); bool canThrottleTick = aFlags == Can_Throttle && - et->CanPerformOnCompositorThread( + collection->CanPerformOnCompositorThread( ElementAnimationCollection::CanAnimateFlags(0)) && - et->CanThrottleAnimation(now); + collection->CanThrottleAnimation(now); - NS_ABORT_IF_FALSE(et->mElement->GetCrossShadowCurrentDoc() == + NS_ABORT_IF_FALSE(collection->mElement->GetCrossShadowCurrentDoc() == mPresContext->Document(), "Element::UnbindFromTree should have " "destroyed the element transitions object"); - uint32_t i = et->mAnimations.Length(); + uint32_t i = collection->mAnimations.Length(); NS_ABORT_IF_FALSE(i != 0, "empty transitions list?"); bool transitionStartedOrEnded = false; do { --i; - ElementAnimation* anim = et->mAnimations[i]; + ElementAnimation* anim = collection->mAnimations[i]; if (anim->IsFinishedTransition()) { // Actually remove transitions one throttle-able cycle after their // completion. We only clear on a throttle-able cycle because that @@ -810,7 +814,7 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) // 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) { - et->mAnimations.RemoveElementAt(i); + collection->mAnimations.RemoveElementAt(i); } } else { TimeDuration localTime = anim->GetLocalTimeAt(now); @@ -825,9 +829,9 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) prop = nsCSSProps::OtherNameFor(prop); } events.AppendElement( - TransitionEventInfo(et->mElement, prop, + TransitionEventInfo(collection->mElement, prop, anim->mTiming.mIterationDuration, - et->PseudoElement())); + collection->PseudoElement())); // Leave this transition in the list for one more refresh // cycle, since we haven't yet processed its style change, and @@ -837,7 +841,7 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) // to know not to start a new transition for the transition // from the almost-completed value to the final value. anim->SetFinishedTransition(); - et->UpdateAnimationGeneration(mPresContext); + collection->UpdateAnimationGeneration(mPresContext); transitionStartedOrEnded = true; } else if ((computedTiming.mPhase == ComputedTiming::AnimationPhase_Active) && @@ -845,7 +849,7 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) !anim->mIsRunningOnCompositor) { // Start a transition with a delay where we should start the // transition proper. - et->UpdateAnimationGeneration(mPresContext); + collection->UpdateAnimationGeneration(mPresContext); transitionStartedOrEnded = true; } } @@ -853,20 +857,22 @@ nsTransitionManager::FlushTransitions(FlushFlags aFlags) // We need to restyle even if the transition rule no longer // applies (in which case we just made it not apply). - NS_ASSERTION(et->mElementProperty == nsGkAtoms::transitionsProperty || - et->mElementProperty == nsGkAtoms::transitionsOfBeforeProperty || - et->mElementProperty == nsGkAtoms::transitionsOfAfterProperty, - "Unexpected element property; might restyle too much"); + MOZ_ASSERT( + collection->mElementProperty == nsGkAtoms::transitionsProperty || + collection->mElementProperty == + nsGkAtoms::transitionsOfBeforeProperty || + collection->mElementProperty == nsGkAtoms::transitionsOfAfterProperty, + "Unexpected element property; might restyle too much"); if (!canThrottleTick || transitionStartedOrEnded) { - et->PostRestyleForAnimation(mPresContext); + collection->PostRestyleForAnimation(mPresContext); } else { didThrottle = true; } - if (et->mAnimations.IsEmpty()) { - et->Destroy(); - // |et| is now a dangling pointer! - et = nullptr; + if (collection->mAnimations.IsEmpty()) { + collection->Destroy(); + // |collection| is now a dangling pointer! + collection = nullptr; } } }