From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- layout/style/TimelineManager.cpp | 171 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 layout/style/TimelineManager.cpp (limited to 'layout/style/TimelineManager.cpp') diff --git a/layout/style/TimelineManager.cpp b/layout/style/TimelineManager.cpp new file mode 100644 index 0000000000..0d2d98e31c --- /dev/null +++ b/layout/style/TimelineManager.cpp @@ -0,0 +1,171 @@ +/* -*- 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 "TimelineManager.h" + +#include "mozilla/ElementAnimationData.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/ScrollTimeline.h" +#include "mozilla/dom/ViewTimeline.h" +#include "nsPresContext.h" + +namespace mozilla { +using dom::Element; +using dom::ScrollTimeline; +using dom::ViewTimeline; + +template +void TryDestroyTimeline(Element* aElement, PseudoStyleType aPseudoType) { + auto* collection = + TimelineCollection::Get(aElement, aPseudoType); + if (!collection) { + return; + } + collection->Destroy(); +} + +void TimelineManager::UpdateTimelines(Element* aElement, + PseudoStyleType aPseudoType, + const ComputedStyle* aComputedStyle, + ProgressTimelineType aType) { + MOZ_ASSERT( + aElement->IsInComposedDoc(), + "No need to update timelines that are not attached to the document tree"); + + // If we are in a display:none subtree we will have no computed values. + // However, if we are on the root of display:none subtree, the computed values + // might not have been cleared yet. In either case, since CSS animations + // should not run in display:none subtrees, so we don't need timeline, either. + const bool shouldDestroyTimelines = + !aComputedStyle || + aComputedStyle->StyleDisplay()->mDisplay == StyleDisplay::None; + + switch (aType) { + case ProgressTimelineType::Scroll: + if (shouldDestroyTimelines) { + TryDestroyTimeline(aElement, aPseudoType); + return; + } + DoUpdateTimelines( + mPresContext, aElement, aPseudoType, + aComputedStyle->StyleUIReset()->mScrollTimelines, + aComputedStyle->StyleUIReset()->mScrollTimelineNameCount); + break; + + case ProgressTimelineType::View: + if (shouldDestroyTimelines) { + TryDestroyTimeline(aElement, aPseudoType); + return; + } + DoUpdateTimelines( + mPresContext, aElement, aPseudoType, + aComputedStyle->StyleUIReset()->mViewTimelines, + aComputedStyle->StyleUIReset()->mViewTimelineNameCount); + break; + } +} + +template +static already_AddRefed PopExistingTimeline( + const nsAtom* aName, TimelineCollection* aCollection) { + if (!aCollection) { + return nullptr; + } + return aCollection->Extract(aName); +} + +template +static auto BuildTimelines(nsPresContext* aPresContext, Element* aElement, + PseudoStyleType aPseudoType, + const nsStyleAutoArray& aTimelines, + size_t aTimelineCount, + TimelineCollection* aCollection) { + typename TimelineCollection::TimelineMap result; + // If multiple timelines are attempting to modify the same property, then the + // timeline closest to the end of the list of names wins. + // The spec doesn't mention this specifically for scroll-timeline-name and + // view-timeline-name, so we follow the same rule with animation-name. + for (size_t idx = 0; idx < aTimelineCount; ++idx) { + const StyleType& timeline = aTimelines[idx]; + if (timeline.GetName() == nsGkAtoms::_empty) { + continue; + } + + RefPtr dest = + PopExistingTimeline(timeline.GetName(), aCollection); + if (dest) { + dest->ReplacePropertiesWith(aElement, aPseudoType, timeline); + } else { + dest = TimelineType::MakeNamed(aPresContext->Document(), aElement, + aPseudoType, timeline); + } + MOZ_ASSERT(dest); + + // Override the previous one if it is duplicated. + Unused << result.InsertOrUpdate(timeline.GetName(), dest); + } + return result; +} + +template +static TimelineCollection& EnsureTimelineCollection( + Element& aElement, PseudoStyleType aPseudoType); + +template <> +ScrollTimelineCollection& EnsureTimelineCollection( + Element& aElement, PseudoStyleType aPseudoType) { + return aElement.EnsureAnimationData().EnsureScrollTimelineCollection( + aElement, aPseudoType); +} + +template <> +ViewTimelineCollection& EnsureTimelineCollection( + Element& aElement, PseudoStyleType aPseudoType) { + return aElement.EnsureAnimationData().EnsureViewTimelineCollection( + aElement, aPseudoType); +} + +template +void TimelineManager::DoUpdateTimelines( + nsPresContext* aPresContext, Element* aElement, PseudoStyleType aPseudoType, + const nsStyleAutoArray& aStyleTimelines, size_t aTimelineCount) { + auto* collection = + TimelineCollection::Get(aElement, aPseudoType); + if (!collection && aTimelineCount == 1 && + aStyleTimelines[0].GetName() == nsGkAtoms::_empty) { + return; + } + + // We create a new timeline list based on its computed style and the existing + // timelines. + auto newTimelines = BuildTimelines( + aPresContext, aElement, aPseudoType, aStyleTimelines, aTimelineCount, + collection); + + if (newTimelines.IsEmpty()) { + if (collection) { + collection->Destroy(); + } + return; + } + + if (!collection) { + collection = + &EnsureTimelineCollection(*aElement, aPseudoType); + if (!collection->isInList()) { + AddTimelineCollection(collection); + } + } + + // Replace unused timeline with new ones. + collection->Swap(newTimelines); + + // FIXME: Bug 1774060. We may have to restyle the animations which use the + // dropped timelines. Or rely on restyling the subtree and the following + // siblings when mutating {scroll|view}-timeline-name. +} + +} // namespace mozilla -- cgit v1.2.3