mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
cbee07055c
Now that we have both AnimationPlayer and Animation in use we need to clarify which object we are referring to. This patch renames a number of member and local variables to better reflect whether they point to an AnimationPlayer or an Animation. This patch is mostly renaming only with one exception. Since we are touching a number of local variables used in loops (for looping over the array of animation players) we take the opportunity to replace a number of instances of uint32_t with size_t since that is the preferred type for array indices now.
314 lines
10 KiB
C++
314 lines
10 KiB
C++
/* 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/. */
|
|
|
|
#ifndef mozilla_css_AnimationCommon_h
|
|
#define mozilla_css_AnimationCommon_h
|
|
|
|
#include "nsIStyleRuleProcessor.h"
|
|
#include "nsIStyleRule.h"
|
|
#include "nsRefreshDriver.h"
|
|
#include "prclist.h"
|
|
#include "nsCSSProperty.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/StyleAnimationValue.h"
|
|
#include "mozilla/dom/AnimationPlayer.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/Nullable.h"
|
|
#include "nsStyleStruct.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
#include "nsCSSPseudoElements.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
|
|
class nsIFrame;
|
|
class nsPresContext;
|
|
class nsStyleChangeList;
|
|
|
|
namespace mozilla {
|
|
|
|
class RestyleTracker;
|
|
struct AnimationPlayerCollection;
|
|
|
|
namespace css {
|
|
|
|
bool IsGeometricProperty(nsCSSProperty aProperty);
|
|
|
|
class CommonAnimationManager : public nsIStyleRuleProcessor,
|
|
public nsARefreshObserver {
|
|
public:
|
|
CommonAnimationManager(nsPresContext *aPresContext);
|
|
|
|
// nsISupports
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsIStyleRuleProcessor (parts)
|
|
virtual nsRestyleHint HasStateDependentStyle(StateRuleProcessorData* aData) MOZ_OVERRIDE;
|
|
virtual nsRestyleHint HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData) MOZ_OVERRIDE;
|
|
virtual bool HasDocumentStateDependentStyle(StateRuleProcessorData* aData) MOZ_OVERRIDE;
|
|
virtual nsRestyleHint
|
|
HasAttributeDependentStyle(AttributeRuleProcessorData* aData) MOZ_OVERRIDE;
|
|
virtual bool MediumFeaturesChanged(nsPresContext* aPresContext) MOZ_OVERRIDE;
|
|
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf)
|
|
const MOZ_MUST_OVERRIDE MOZ_OVERRIDE;
|
|
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
|
|
const MOZ_MUST_OVERRIDE MOZ_OVERRIDE;
|
|
|
|
/**
|
|
* Notify the manager that the pres context is going away.
|
|
*/
|
|
void Disconnect();
|
|
|
|
// Tell the restyle tracker about all the styles that we're currently
|
|
// animating, so that it can update the animation rule for these
|
|
// elements.
|
|
void AddStyleUpdatesTo(mozilla::RestyleTracker& aTracker);
|
|
|
|
enum FlushFlags {
|
|
Can_Throttle,
|
|
Cannot_Throttle
|
|
};
|
|
|
|
static bool ExtractComputedValueForTransition(
|
|
nsCSSProperty aProperty,
|
|
nsStyleContext* aStyleContext,
|
|
mozilla::StyleAnimationValue& aComputedValue);
|
|
protected:
|
|
virtual ~CommonAnimationManager();
|
|
|
|
// For ElementCollectionRemoved
|
|
friend struct mozilla::AnimationPlayerCollection;
|
|
|
|
virtual void
|
|
AddElementCollection(AnimationPlayerCollection* aCollection) = 0;
|
|
virtual void ElementCollectionRemoved() = 0;
|
|
void RemoveAllElementCollections();
|
|
|
|
// When this returns a value other than nullptr, it also,
|
|
// as a side-effect, notifies the ActiveLayerTracker.
|
|
static AnimationPlayerCollection*
|
|
GetAnimationsForCompositor(nsIContent* aContent,
|
|
nsIAtom* aElementProperty,
|
|
nsCSSProperty aProperty);
|
|
|
|
PRCList mElementCollections;
|
|
nsPresContext *mPresContext; // weak (non-null from ctor to Disconnect)
|
|
};
|
|
|
|
/**
|
|
* A style rule that maps property-StyleAnimationValue pairs.
|
|
*/
|
|
class AnimValuesStyleRule MOZ_FINAL : public nsIStyleRule
|
|
{
|
|
public:
|
|
// nsISupports implementation
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsIStyleRule implementation
|
|
virtual void MapRuleInfoInto(nsRuleData* aRuleData) MOZ_OVERRIDE;
|
|
#ifdef DEBUG
|
|
virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;
|
|
#endif
|
|
|
|
void AddValue(nsCSSProperty aProperty,
|
|
mozilla::StyleAnimationValue &aStartValue)
|
|
{
|
|
PropertyValuePair v = { aProperty, aStartValue };
|
|
mPropertyValuePairs.AppendElement(v);
|
|
}
|
|
|
|
// Caller must fill in returned value.
|
|
mozilla::StyleAnimationValue* AddEmptyValue(nsCSSProperty aProperty)
|
|
{
|
|
PropertyValuePair *p = mPropertyValuePairs.AppendElement();
|
|
p->mProperty = aProperty;
|
|
return &p->mValue;
|
|
}
|
|
|
|
struct PropertyValuePair {
|
|
nsCSSProperty mProperty;
|
|
mozilla::StyleAnimationValue mValue;
|
|
};
|
|
|
|
private:
|
|
~AnimValuesStyleRule() {}
|
|
|
|
InfallibleTArray<PropertyValuePair> mPropertyValuePairs;
|
|
};
|
|
|
|
} /* end css sub-namespace */
|
|
|
|
typedef InfallibleTArray<nsRefPtr<dom::AnimationPlayer> >
|
|
AnimationPlayerPtrArray;
|
|
|
|
enum EnsureStyleRuleFlags {
|
|
EnsureStyleRule_IsThrottled,
|
|
EnsureStyleRule_IsNotThrottled
|
|
};
|
|
|
|
struct AnimationPlayerCollection : public PRCList
|
|
{
|
|
AnimationPlayerCollection(dom::Element *aElement, nsIAtom *aElementProperty,
|
|
mozilla::css::CommonAnimationManager *aManager,
|
|
TimeStamp aNow)
|
|
: mElement(aElement)
|
|
, mElementProperty(aElementProperty)
|
|
, mManager(aManager)
|
|
, mAnimationGeneration(0)
|
|
, mNeedsRefreshes(true)
|
|
#ifdef DEBUG
|
|
, mCalledPropertyDtor(false)
|
|
#endif
|
|
{
|
|
MOZ_COUNT_CTOR(AnimationPlayerCollection);
|
|
PR_INIT_CLIST(this);
|
|
}
|
|
~AnimationPlayerCollection()
|
|
{
|
|
NS_ABORT_IF_FALSE(mCalledPropertyDtor,
|
|
"must call destructor through element property dtor");
|
|
MOZ_COUNT_DTOR(AnimationPlayerCollection);
|
|
PR_REMOVE_LINK(this);
|
|
mManager->ElementCollectionRemoved();
|
|
}
|
|
|
|
void Destroy()
|
|
{
|
|
// This will call our destructor.
|
|
mElement->DeleteProperty(mElementProperty);
|
|
}
|
|
|
|
static void PropertyDtor(void *aObject, nsIAtom *aPropertyName,
|
|
void *aPropertyValue, void *aData);
|
|
|
|
void Tick();
|
|
|
|
// This updates mNeedsRefreshes so the caller may need to check
|
|
// for changes to values (for example, nsAnimationManager provides
|
|
// CheckNeedsRefresh to register or unregister from observing the refresh
|
|
// driver when this value changes).
|
|
void EnsureStyleRuleFor(TimeStamp aRefreshTime, EnsureStyleRuleFlags aFlags);
|
|
|
|
bool CanThrottleTransformChanges(mozilla::TimeStamp aTime);
|
|
|
|
bool CanThrottleAnimation(mozilla::TimeStamp aTime);
|
|
|
|
enum CanAnimateFlags {
|
|
// Testing for width, height, top, right, bottom, or left.
|
|
CanAnimate_HasGeometricProperty = 1,
|
|
// Allow the case where OMTA is allowed in general, but not for the
|
|
// specified property.
|
|
CanAnimate_AllowPartial = 2
|
|
};
|
|
|
|
static bool
|
|
CanAnimatePropertyOnCompositor(const dom::Element *aElement,
|
|
nsCSSProperty aProperty,
|
|
CanAnimateFlags aFlags);
|
|
|
|
static bool IsCompositorAnimationDisabledForFrame(nsIFrame* aFrame);
|
|
|
|
// True if this animation can be performed on the compositor thread.
|
|
//
|
|
// If aFlags contains CanAnimate_AllowPartial, returns whether the
|
|
// state of this element's animations at the current refresh driver
|
|
// time contains animation data that can be done on the compositor
|
|
// thread. (This is useful for determining whether a layer should be
|
|
// active, or whether to send data to the layer.)
|
|
//
|
|
// If aFlags does not contain CanAnimate_AllowPartial, returns whether
|
|
// the state of this element's animations at the current refresh driver
|
|
// time can be fully represented by data sent to the compositor.
|
|
// (This is useful for determining whether throttle the animation
|
|
// (suppress main-thread style updates).)
|
|
bool CanPerformOnCompositorThread(CanAnimateFlags aFlags) const;
|
|
bool HasAnimationOfProperty(nsCSSProperty aProperty) const;
|
|
|
|
bool IsForElement() const { // rather than for a pseudo-element
|
|
return mElementProperty == nsGkAtoms::animationsProperty ||
|
|
mElementProperty == nsGkAtoms::transitionsProperty;
|
|
}
|
|
|
|
bool IsForTransitions() const {
|
|
return mElementProperty == nsGkAtoms::transitionsProperty ||
|
|
mElementProperty == nsGkAtoms::transitionsOfBeforeProperty ||
|
|
mElementProperty == nsGkAtoms::transitionsOfAfterProperty;
|
|
}
|
|
|
|
bool IsForAnimations() const {
|
|
return mElementProperty == nsGkAtoms::animationsProperty ||
|
|
mElementProperty == nsGkAtoms::animationsOfBeforeProperty ||
|
|
mElementProperty == nsGkAtoms::animationsOfAfterProperty;
|
|
}
|
|
|
|
nsString PseudoElement()
|
|
{
|
|
if (IsForElement()) {
|
|
return EmptyString();
|
|
} else if (mElementProperty == nsGkAtoms::animationsOfBeforeProperty ||
|
|
mElementProperty == nsGkAtoms::transitionsOfBeforeProperty) {
|
|
return NS_LITERAL_STRING("::before");
|
|
} else {
|
|
return NS_LITERAL_STRING("::after");
|
|
}
|
|
}
|
|
|
|
void PostRestyleForAnimation(nsPresContext *aPresContext) {
|
|
nsRestyleHint styleHint = IsForElement() ? eRestyle_Self : eRestyle_Subtree;
|
|
aPresContext->PresShell()->RestyleForAnimation(mElement, styleHint);
|
|
}
|
|
|
|
static void LogAsyncAnimationFailure(nsCString& aMessage,
|
|
const nsIContent* aContent = nullptr);
|
|
|
|
dom::Element *mElement;
|
|
|
|
// the atom we use in mElement's prop table (must be a static atom,
|
|
// i.e., in an atom list)
|
|
nsIAtom *mElementProperty;
|
|
|
|
mozilla::css::CommonAnimationManager *mManager;
|
|
|
|
mozilla::AnimationPlayerPtrArray mPlayers;
|
|
|
|
// This style rule contains the style data for currently animating
|
|
// values. It only matches when styling with animation. When we
|
|
// style without animation, we need to not use it so that we can
|
|
// detect any new changes; if necessary we restyle immediately
|
|
// afterwards with animation.
|
|
// NOTE: If we don't need to apply any styles, mStyleRule will be
|
|
// null, but mStyleRuleRefreshTime will still be valid.
|
|
nsRefPtr<mozilla::css::AnimValuesStyleRule> mStyleRule;
|
|
|
|
// RestyleManager keeps track of the number of animation
|
|
// 'mini-flushes' (see nsTransitionManager::UpdateAllThrottledStyles()).
|
|
// mAnimationGeneration is the sequence number of the last flush where a
|
|
// transition/animation changed. We keep a similar count on the
|
|
// corresponding layer so we can check that the layer is up to date with
|
|
// the animation manager.
|
|
uint64_t mAnimationGeneration;
|
|
// Update mAnimationGeneration to nsCSSFrameConstructor's count
|
|
void UpdateAnimationGeneration(nsPresContext* aPresContext);
|
|
|
|
// Returns true if there is an animation in the before or active phase
|
|
// at the current time.
|
|
bool HasCurrentAnimations();
|
|
|
|
// The refresh time associated with mStyleRule.
|
|
TimeStamp mStyleRuleRefreshTime;
|
|
|
|
// False when we know that our current style rule is valid
|
|
// indefinitely into the future (because all of our animations are
|
|
// either completed or paused). May be invalidated by a style change.
|
|
bool mNeedsRefreshes;
|
|
|
|
#ifdef DEBUG
|
|
bool mCalledPropertyDtor;
|
|
#endif
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* !defined(mozilla_css_AnimationCommon_h) */
|