diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 14:29:10 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 14:29:10 +0000 |
commit | 2aa4a82499d4becd2284cdb482213d541b8804dd (patch) | |
tree | b80bf8bf13c3766139fbacc530efd0dd9d54394c /dom/animation/EffectCompositor.h | |
parent | Initial commit. (diff) | |
download | firefox-2aa4a82499d4becd2284cdb482213d541b8804dd.tar.xz firefox-2aa4a82499d4becd2284cdb482213d541b8804dd.zip |
Adding upstream version 86.0.1.upstream/86.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/animation/EffectCompositor.h')
-rw-r--r-- | dom/animation/EffectCompositor.h | 267 |
1 files changed, 267 insertions, 0 deletions
diff --git a/dom/animation/EffectCompositor.h b/dom/animation/EffectCompositor.h new file mode 100644 index 0000000000..7367884ec4 --- /dev/null +++ b/dom/animation/EffectCompositor.h @@ -0,0 +1,267 @@ +/* -*- 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/. */ + +#ifndef mozilla_EffectCompositor_h +#define mozilla_EffectCompositor_h + +#include "mozilla/AnimationPerformanceWarning.h" +#include "mozilla/AnimationTarget.h" +#include "mozilla/EnumeratedArray.h" +#include "mozilla/HashTable.h" +#include "mozilla/Maybe.h" +#include "mozilla/OwningNonNull.h" +#include "mozilla/PseudoElementHashEntry.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ServoTypes.h" +#include "nsCSSPropertyID.h" +#include "nsCycleCollectionParticipant.h" +#include "nsDataHashtable.h" +#include "nsTArray.h" + +class nsCSSPropertyIDSet; +class nsAtom; +class nsIFrame; +class nsPresContext; +enum class DisplayItemType : uint8_t; +struct RawServoAnimationValueMap; + +namespace mozilla { + +class ComputedStyle; +class EffectSet; +class RestyleTracker; +class StyleAnimationValue; +struct AnimationProperty; +struct NonOwningAnimationTarget; + +namespace dom { +class Animation; +class Element; +class KeyframeEffect; +} // namespace dom + +class EffectCompositor { + public: + explicit EffectCompositor(nsPresContext* aPresContext) + : mPresContext(aPresContext) {} + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(EffectCompositor) + NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(EffectCompositor) + + void Disconnect() { mPresContext = nullptr; } + + // Animations can be applied at two different levels in the CSS cascade: + enum class CascadeLevel : uint32_t { + // The animations sheet (CSS animations, script-generated animations, + // and CSS transitions that are no longer tied to CSS markup) + Animations = 0, + // The transitions sheet (CSS transitions that are tied to CSS markup) + Transitions = 1 + }; + // We don't define this as part of CascadeLevel as then we'd have to add + // explicit checks for the Count enum value everywhere CascadeLevel is used. + static const size_t kCascadeLevelCount = + static_cast<size_t>(CascadeLevel::Transitions) + 1; + + // NOTE: This can return null after Disconnect(). + nsPresContext* PresContext() const { return mPresContext; } + + enum class RestyleType { + // Animation style has changed but the compositor is applying the same + // change so we might be able to defer updating the main thread until it + // becomes necessary. + Throttled, + // Animation style has changed and needs to be updated on the main thread. + Standard, + // Animation style has changed and needs to be updated on the main thread + // as well as forcing animations on layers to be updated. + // This is needed in cases such as when an animation becomes paused or has + // its playback rate changed. In such cases, although the computed style + // and refresh driver time might not change, we still need to ensure the + // corresponding animations on layers are updated to reflect the new + // configuration of the animation. + Layer + }; + + // Notifies the compositor that the animation rule for the specified + // (pseudo-)element at the specified cascade level needs to be updated. + // The specified steps taken to update the animation rule depend on + // |aRestyleType| whose values are described above. + void RequestRestyle(dom::Element* aElement, PseudoStyleType aPseudoType, + RestyleType aRestyleType, CascadeLevel aCascadeLevel); + + // Schedule an animation restyle. This is called automatically by + // RequestRestyle when necessary. However, it is exposed here since we also + // need to perform this step when triggering transitions *without* also + // invalidating the animation style rule (which RequestRestyle would do). + void PostRestyleForAnimation(dom::Element* aElement, + PseudoStyleType aPseudoType, + CascadeLevel aCascadeLevel); + + // Posts an animation restyle for any elements whose animation style rule + // is out of date but for which an animation restyle has not yet been + // posted because updates on the main thread are throttled. + void PostRestyleForThrottledAnimations(); + + // Clear all pending restyle requests for the given (pseudo-) element (and its + // ::before, ::after and ::marker elements if the given element is not + // pseudo). + void ClearRestyleRequestsFor(dom::Element* aElement); + + // Called when computed style on the specified (pseudo-) element might + // have changed so that any context-sensitive values stored within + // animation effects (e.g. em-based endpoints used in keyframe effects) + // can be re-resolved to computed values. + void UpdateEffectProperties(const ComputedStyle* aStyle, + dom::Element* aElement, + PseudoStyleType aPseudoType); + + // Get the animation rule for the appropriate level of the cascade for + // a (pseudo-)element. Called from the Servo side. + // + // The animation rule is stored in |RawServoAnimationValueMap|. + // We need to be careful while doing any modification because it may cause + // some thread-safe issues. + bool GetServoAnimationRule(const dom::Element* aElement, + PseudoStyleType aPseudoType, + CascadeLevel aCascadeLevel, + RawServoAnimationValueMap* aAnimationValues); + + // A variant on GetServoAnimationRule that composes all the effects for an + // element up to and including |aEffect|. + // + // Note that |aEffect| might not be in the EffectSet since we can use this for + // committing the computed style of a removed Animation. + bool ComposeServoAnimationRuleForEffect( + dom::KeyframeEffect& aEffect, CascadeLevel aCascadeLevel, + RawServoAnimationValueMap* aAnimationValues); + + bool HasPendingStyleUpdates() const; + + static bool HasAnimationsForCompositor(const nsIFrame* aFrame, + DisplayItemType aType); + + static nsTArray<RefPtr<dom::Animation>> GetAnimationsForCompositor( + const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet); + + static void ClearIsRunningOnCompositor(const nsIFrame* aFrame, + DisplayItemType aType); + + // Update animation cascade results for the specified (pseudo-)element + // but only if we have marked the cascade as needing an update due a + // the change in the set of effects or a change in one of the effects' + // "in effect" state. + // + // This method does NOT detect if other styles that apply above the + // animation level of the cascade have changed. + static void MaybeUpdateCascadeResults(dom::Element* aElement, + PseudoStyleType aPseudoType); + + // Update the mPropertiesWithImportantRules and + // mPropertiesForAnimationsLevel members of the given EffectSet, and also + // request any restyles required by changes to the cascade result. + // + // NOTE: This can be expensive so we should only call it if styles that apply + // above the animation level of the cascade might have changed. For all + // other cases we should call MaybeUpdateCascadeResults. + // + // This is typically reserved for internal callers but is public here since + // when we detect changes to the cascade on the Servo side we can't call + // MarkCascadeNeedsUpdate during the traversal so instead we call this as part + // of a follow-up sequential task. + static void UpdateCascadeResults(EffectSet& aEffectSet, + dom::Element* aElement, + PseudoStyleType aPseudoType); + + // Helper to fetch the corresponding element and pseudo-type from a frame. + // + // For frames corresponding to pseudo-elements, the returned element is the + // element on which we store the animations (i.e. the EffectSet and/or + // AnimationCollection), *not* the generated content. + // + // For display:table content, which maintains a distinction between primary + // frame (table wrapper frame) and style frame (inner table frame), animations + // are stored on the content associated with the _style_ frame even though + // some (particularly transform-like animations) may be applied to the + // _primary_ frame. As a result, callers will typically want to pass the style + // frame to this function. + // + // Returns an empty result when a suitable element cannot be found including + // when the frame represents a pseudo-element on which we do not support + // animations. + static Maybe<NonOwningAnimationTarget> GetAnimationElementAndPseudoForFrame( + const nsIFrame* aFrame); + + // Associates a performance warning with effects on |aFrame| that animate + // properties in |aPropertySet|. + static void SetPerformanceWarning( + const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet, + const AnimationPerformanceWarning& aWarning); + + // Do a bunch of stuff that we should avoid doing during the parallel + // traversal (e.g. changing member variables) for all elements that we expect + // to restyle on the next traversal. + // + // Returns true if there are elements needing a restyle for animation. + bool PreTraverse(ServoTraversalFlags aFlags); + + // Similar to the above but for all elements in the subtree rooted + // at aElement. + bool PreTraverseInSubtree(ServoTraversalFlags aFlags, dom::Element* aRoot); + + // Record a (pseudo-)element that may have animations that can be removed. + void NoteElementForReducing(const NonOwningAnimationTarget& aTarget); + + bool NeedsReducing() const { return !mElementsToReduce.empty(); } + void ReduceAnimations(); + + // Returns the target element for restyling. + // + // If |aPseudoType| is ::after, ::before or ::marker, returns the generated + // content element of which |aElement| is the parent. If |aPseudoType| is any + // other pseudo type (other than PseudoStyleType::NotPseudo) returns nullptr. + // Otherwise, returns |aElement|. + static dom::Element* GetElementToRestyle(dom::Element* aElement, + PseudoStyleType aPseudoType); + + // Returns true if any type of compositor animations on |aFrame| allow + // runnning on the compositor. + // Sets the reason in |aWarning| if the result is false. + static bool AllowCompositorAnimationsOnFrame( + const nsIFrame* aFrame, + AnimationPerformanceWarning::Type& aWarning /* out */); + + private: + ~EffectCompositor() = default; + + // Get the properties in |aEffectSet| that we are able to animate on the + // compositor but which are also specified at a higher level in the cascade + // than the animations level. + static nsCSSPropertyIDSet GetOverriddenProperties( + EffectSet& aEffectSet, dom::Element* aElement, + PseudoStyleType aPseudoType); + + static nsPresContext* GetPresContext(dom::Element* aElement); + + nsPresContext* mPresContext; + + // Elements with a pending animation restyle. The associated bool value is + // true if a pending animation restyle has also been dispatched. For + // animations that can be throttled, we will add an entry to the hashtable to + // indicate that the style rule on the element is out of date but without + // posting a restyle to update it. + EnumeratedArray<CascadeLevel, CascadeLevel(kCascadeLevelCount), + nsDataHashtable<PseudoElementHashEntry, bool>> + mElementsToRestyle; + + bool mIsInPreTraverse = false; + + HashSet<OwningAnimationTarget> mElementsToReduce; +}; + +} // namespace mozilla + +#endif // mozilla_EffectCompositor_h |