/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "ElementAnimationData.h"
#include "mozilla/AnimationCollection.h"
#include "mozilla/TimelineCollection.h"
#include "mozilla/EffectSet.h"
#include "mozilla/dom/CSSTransition.h"
#include "mozilla/dom/CSSAnimation.h"
#include "mozilla/dom/ScrollTimeline.h"
#include "mozilla/dom/ViewTimeline.h"
namespace mozilla {
const ElementAnimationData::PerElementOrPseudoData*
ElementAnimationData::GetPseudoData(
const PseudoStyleRequest& aRequest)
const {
MOZ_ASSERT(!aRequest.IsNotPseudo(),
"Only for pseudo-elements");
auto entry = mPseudoData.Lookup(aRequest);
if (!entry) {
return nullptr;
}
MOZ_ASSERT(*entry,
"Should always have a valid UniquePtr");
return entry->get();
}
ElementAnimationData::PerElementOrPseudoData&
ElementAnimationData::GetOrCreatePseudoData(
const PseudoStyleRequest& aRequest) {
MOZ_ASSERT(!aRequest.IsNotPseudo(),
"Only for pseudo-elements");
UniquePtr<PerElementOrPseudoData>& data = mPseudoData.LookupOrInsertWith(
aRequest, [&] {
return MakeUnique<PerElementOrPseudoData>(); });
MOZ_ASSERT(data);
return *data;
}
void ElementAnimationData::Traverse(nsCycleCollectionTraversalCallback& cb) {
mElementData.Traverse(cb);
for (
auto& data : mPseudoData.Values()) {
data->Traverse(cb);
}
}
void ElementAnimationData::ClearAllAnimationCollections() {
mElementData.mAnimations = nullptr;
mElementData.mTransitions = nullptr;
mElementData.mScrollTimelines = nullptr;
mElementData.mViewTimelines = nullptr;
mElementData.mProgressTimelineScheduler = nullptr;
ClearAllPseudos(
false);
}
void ElementAnimationData::ClearAllPseudos(
bool aOnlyViewTransitions) {
if (mPseudoData.IsEmpty()) {
return;
}
mIsClearingPseudoData =
true;
for (
auto iter = mPseudoData.Iter(); !iter.Done(); iter.Next()) {
const auto& data = iter.Data();
MOZ_ASSERT(data);
if (aOnlyViewTransitions && !iter.Key().IsViewTransition()) {
continue;
}
// Note: We cannot remove EffectSet because we expect there is a valid
// EffectSet when unregistering the target.
// (See KeyframeEffect::UnregisterTarget() for more deatils).
// So we rely on EffectSet::Destroy() to clear it.
data->mAnimations = nullptr;
data->mTransitions = nullptr;
data->mScrollTimelines = nullptr;
data->mViewTimelines = nullptr;
data->mProgressTimelineScheduler = nullptr;
if (data->IsEmpty()) {
iter.Remove();
}
}
mIsClearingPseudoData =
false;
}
void ElementAnimationData::MaybeClearEntry(
PseudoData::LookupResult<PseudoData&>&& aEntry) {
if (mIsClearingPseudoData || !aEntry || !aEntry.Data()->IsEmpty()) {
return;
}
UniquePtr<PerElementOrPseudoData> temp(std::move(*aEntry));
aEntry.Remove();
}
template <
typename Fn>
void ElementAnimationData::WithDataForRemoval(
const PseudoStyleRequest& aRequest, Fn&& aFn) {
if (aRequest.IsNotPseudo()) {
aFn(mElementData);
return;
}
auto entry = mPseudoData.Lookup(aRequest);
if (!entry) {
return;
}
aFn(**entry);
MaybeClearEntry(std::move(entry));
}
void ElementAnimationData::ClearEffectSetFor(
const PseudoStyleRequest& aRequest) {
WithDataForRemoval(aRequest, [](PerElementOrPseudoData& aData) {
aData.mEffectSet = nullptr;
});
}
void ElementAnimationData::ClearTransitionCollectionFor(
const PseudoStyleRequest& aRequest) {
if (aRequest.IsNotPseudo()) {
mElementData.mTransitions = nullptr;
return;
}
auto entry = mPseudoData.Lookup(aRequest);
if (!entry || !entry.Data()->mTransitions) {
return;
}
// If a KeyframeEffect associated with only the animation in the collection,
// nullifying the collection may call ClearEffectSetFor(), which may clear the
// entry if all empty. Therefore, we move the collection out of the data
// first, and destroy the collection when leaving the function, to make sure
// |entry| is still valid when calling MaybeClearEntry().
// Note: It seems MaybeClearEntry() here may be redundant because we always
// rely on ClearEffectSetFor() to clear the entry. However, we still call it
// just in case.
auto autoRemoved(std::move(entry.Data()->mTransitions));
MaybeClearEntry(std::move(entry));
}
void ElementAnimationData::ClearAnimationCollectionFor(
const PseudoStyleRequest& aRequest) {
if (aRequest.IsNotPseudo()) {
mElementData.mAnimations = nullptr;
return;
}
auto entry = mPseudoData.Lookup(aRequest);
if (!entry || !entry.Data()->mAnimations) {
return;
}
// If a KeyframeEffect associated with only the animation in the collection,
// nullifying the collection may call ClearEffectSetFor(), which may clear the
// entry if all empty. Therefore, we move the collection out of the data
// first, and destroy the collection when leaving the function, to make sure
// |entry| is still valid when calling MaybeClearEntry().
// Note: It seems MaybeClearEntry() here may be redundant because we always
// rely on ClearEffectSetFor() to clear the entry. However, we still call it
// just in case.
auto autoRemoved(std::move(entry.Data()->mAnimations));
MaybeClearEntry(std::move(entry));
}
void ElementAnimationData::ClearScrollTimelineCollectionFor(
const PseudoStyleRequest& aRequest) {
WithDataForRemoval(aRequest, [](PerElementOrPseudoData& aData) {
aData.mScrollTimelines = nullptr;
});
}
void ElementAnimationData::ClearViewTimelineCollectionFor(
const PseudoStyleRequest& aRequest) {
WithDataForRemoval(aRequest, [](PerElementOrPseudoData& aData) {
aData.mViewTimelines = nullptr;
});
}
void ElementAnimationData::ClearProgressTimelineScheduler(
const PseudoStyleRequest& aRequest) {
WithDataForRemoval(aRequest, [](PerElementOrPseudoData& aData) {
aData.mProgressTimelineScheduler = nullptr;
});
}
ElementAnimationData::PerElementOrPseudoData::PerElementOrPseudoData() =
default;
ElementAnimationData::PerElementOrPseudoData::~PerElementOrPseudoData() =
default;
void ElementAnimationData::PerElementOrPseudoData::Traverse(
nsCycleCollectionTraversalCallback& cb) {
// We only care about mEffectSet. The animation collections are managed by the
// pres context and go away when presentation of the document goes away.
if (mEffectSet) {
mEffectSet->Traverse(cb);
}
}
EffectSet& ElementAnimationData::PerElementOrPseudoData::DoEnsureEffectSet() {
MOZ_ASSERT(!mEffectSet);
mEffectSet = MakeUnique<EffectSet>();
return *mEffectSet;
}
CSSTransitionCollection&
ElementAnimationData::PerElementOrPseudoData::DoEnsureTransitions(
dom::Element& aOwner,
const PseudoStyleRequest& aRequest) {
MOZ_ASSERT(!mTransitions);
mTransitions = MakeUnique<CSSTransitionCollection>(aOwner, aRequest);
return *mTransitions;
}
CSSAnimationCollection&
ElementAnimationData::PerElementOrPseudoData::DoEnsureAnimations(
dom::Element& aOwner,
const PseudoStyleRequest& aRequest) {
MOZ_ASSERT(!mAnimations);
mAnimations = MakeUnique<CSSAnimationCollection>(aOwner, aRequest);
return *mAnimations;
}
ScrollTimelineCollection&
ElementAnimationData::PerElementOrPseudoData::DoEnsureScrollTimelines(
dom::Element& aOwner,
const PseudoStyleRequest& aRequest) {
MOZ_ASSERT(!mScrollTimelines);
mScrollTimelines = MakeUnique<ScrollTimelineCollection>(aOwner, aRequest);
return *mScrollTimelines;
}
ViewTimelineCollection&
ElementAnimationData::PerElementOrPseudoData::DoEnsureViewTimelines(
dom::Element& aOwner,
const PseudoStyleRequest& aRequest) {
MOZ_ASSERT(!mViewTimelines);
mViewTimelines = MakeUnique<ViewTimelineCollection>(aOwner, aRequest);
return *mViewTimelines;
}
dom::ProgressTimelineScheduler& ElementAnimationData::PerElementOrPseudoData:
:
DoEnsureProgressTimelineScheduler() {
MOZ_ASSERT(!mProgressTimelineScheduler);
mProgressTimelineScheduler = MakeUnique<dom::ProgressTimelineScheduler>();
return *mProgressTimelineScheduler;
}
} // namespace mozilla
