[Web Animations] Animations should run accelerated even if other animations targeting...
[WebKit-https.git] / Source / WebCore / animation / KeyframeEffect.h
1 /*
2  * Copyright (C) 2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "AnimationEffect.h"
29 #include "AnimationEffectPhase.h"
30 #include "CSSPropertyBlendingClient.h"
31 #include "CompositeOperation.h"
32 #include "CompositeOperationOrAuto.h"
33 #include "EffectTiming.h"
34 #include "Element.h"
35 #include "IterationCompositeOperation.h"
36 #include "KeyframeEffectOptions.h"
37 #include "KeyframeList.h"
38 #include "RenderStyle.h"
39 #include "StyleProperties.h"
40 #include "WebAnimationUtilities.h"
41 #include <wtf/Ref.h>
42
43 namespace WebCore {
44
45 class Element;
46 class FilterOperations;
47
48 class KeyframeEffect : public AnimationEffect
49     , public CSSPropertyBlendingClient {
50 public:
51     static ExceptionOr<Ref<KeyframeEffect>> create(JSC::JSGlobalObject&, Element*, JSC::Strong<JSC::JSObject>&&, Optional<Variant<double, KeyframeEffectOptions>>&&);
52     static ExceptionOr<Ref<KeyframeEffect>> create(JSC::JSGlobalObject&, Ref<KeyframeEffect>&&);
53     static Ref<KeyframeEffect> create(const Element&);
54     ~KeyframeEffect() { }
55
56     bool isKeyframeEffect() const final { return true; }
57
58     struct BasePropertyIndexedKeyframe {
59         Variant<std::nullptr_t, Vector<Optional<double>>, double> offset = Vector<Optional<double>>();
60         Variant<Vector<String>, String> easing = Vector<String>();
61         Variant<Vector<CompositeOperationOrAuto>, CompositeOperationOrAuto> composite = Vector<CompositeOperationOrAuto>();
62     };
63
64     struct BaseKeyframe {
65         MarkableDouble offset;
66         String easing { "linear" };
67         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
68     };
69
70     struct PropertyAndValues {
71         CSSPropertyID property;
72         Vector<String> values;
73     };
74
75     struct KeyframeLikeObject {
76         BasePropertyIndexedKeyframe baseProperties;
77         Vector<PropertyAndValues> propertiesAndValues;
78     };
79
80     struct ParsedKeyframe {
81         MarkableDouble offset;
82         double computedOffset;
83         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
84         String easing;
85         RefPtr<TimingFunction> timingFunction;
86         Ref<MutableStyleProperties> style;
87         HashMap<CSSPropertyID, String> unparsedStyle;
88
89         ParsedKeyframe()
90             : style(MutableStyleProperties::create())
91         {
92         }
93     };
94
95     struct BaseComputedKeyframe {
96         MarkableDouble offset;
97         double computedOffset;
98         String easing { "linear" };
99         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
100     };
101
102     Element* target() const { return m_target.get(); }
103     void setTarget(RefPtr<Element>&&);
104
105     Vector<JSC::Strong<JSC::JSObject>> getKeyframes(JSC::JSGlobalObject&);
106     ExceptionOr<void> setKeyframes(JSC::JSGlobalObject&, JSC::Strong<JSC::JSObject>&&);
107
108     IterationCompositeOperation iterationComposite() const { return m_iterationCompositeOperation; }
109     void setIterationComposite(IterationCompositeOperation iterationCompositeOperation) { m_iterationCompositeOperation = iterationCompositeOperation; }
110     CompositeOperation composite() const { return m_compositeOperation; }
111     void setComposite(CompositeOperation compositeOperation) { m_compositeOperation = compositeOperation; }
112
113     void getAnimatedStyle(std::unique_ptr<RenderStyle>& animatedStyle);
114     void apply(RenderStyle&) override;
115     void invalidate() override;
116     void animationDidSeek() final;
117     void animationWasCanceled() final;
118     void animationSuspensionStateDidChange(bool) final;
119     void animationTimelineDidChange(AnimationTimeline*) final;
120     void animationTimingDidChange();
121     void applyPendingAcceleratedActions();
122
123     void setAnimation(WebAnimation*) final;
124
125     RenderElement* renderer() const override;
126     const RenderStyle& currentStyle() const override;
127     bool triggersStackingContext() const { return m_triggersStackingContext; }
128     bool isRunningAccelerated() const { return m_isRunningAccelerated; }
129     bool isAboutToRunAccelerated() const { return m_acceleratedPropertiesState != AcceleratedProperties::None && m_lastRecordedAcceleratedAction != AcceleratedAction::Stop; }
130     bool isCompletelyAccelerated() const { return m_acceleratedPropertiesState == AcceleratedProperties::All; }
131     bool filterFunctionListsMatch() const override { return m_filterFunctionListsMatch; }
132     bool transformFunctionListsMatch() const override { return m_transformFunctionListsMatch; }
133 #if ENABLE(FILTERS_LEVEL_2)
134     bool backdropFilterFunctionListsMatch() const override { return m_backdropFilterFunctionListsMatch; }
135 #endif
136     bool colorFilterFunctionListsMatch() const override { return m_colorFilterFunctionListsMatch; }
137
138     void computeDeclarativeAnimationBlendingKeyframes(const RenderStyle* oldStyle, const RenderStyle& newStyle);
139     bool hasBlendingKeyframes() const { return m_blendingKeyframes.size(); }
140     const HashSet<CSSPropertyID>& animatedProperties() const { return m_blendingKeyframes.properties(); }
141
142     bool computeExtentOfTransformAnimation(LayoutRect&) const;
143     bool computeTransformedExtentViaTransformList(const FloatRect&, const RenderStyle&, LayoutRect&) const;
144     bool computeTransformedExtentViaMatrix(const FloatRect&, const RenderStyle&, LayoutRect&) const;
145     bool forceLayoutIfNeeded();
146
147     enum class Accelerated : uint8_t { Yes, No };
148     bool isCurrentlyAffectingProperty(CSSPropertyID, Accelerated = Accelerated::No) const;
149
150 private:
151     KeyframeEffect(Element*);
152
153     enum class AcceleratedAction : uint8_t { Play, Pause, Seek, Stop };
154     enum class BlendingKeyframesSource : uint8_t { CSSAnimation, CSSTransition, WebAnimation };
155     enum class AcceleratedProperties : uint8_t { None, Some, All };
156
157     void updateEffectStackMembership();
158     void copyPropertiesFromSource(Ref<KeyframeEffect>&&);
159     ExceptionOr<void> processKeyframes(JSC::JSGlobalObject&, JSC::Strong<JSC::JSObject>&&);
160     void addPendingAcceleratedAction(AcceleratedAction);
161     void updateAcceleratedActions(ComputedEffectTiming);
162     void setAnimatedPropertiesInStyle(RenderStyle&, double);
163     TimingFunction* timingFunctionForKeyframeAtIndex(size_t);
164     Ref<const Animation> backingAnimationForCompositedRenderer() const;
165     void computedNeedsForcedLayout();
166     void computeStackingContextImpact();
167     void clearBlendingKeyframes();
168     void updateBlendingKeyframes(RenderStyle&);
169     void computeCSSAnimationBlendingKeyframes();
170     void computeCSSTransitionBlendingKeyframes(const RenderStyle* oldStyle, const RenderStyle& newStyle);
171     void computeAcceleratedPropertiesState();
172     void setBlendingKeyframes(KeyframeList&);
173     void checkForMatchingTransformFunctionLists();
174     void checkForMatchingFilterFunctionLists();
175     void checkForMatchingColorFilterFunctionLists();
176     bool checkForMatchingFilterFunctionLists(CSSPropertyID, const std::function<const FilterOperations& (const RenderStyle&)>&) const;
177 #if ENABLE(FILTERS_LEVEL_2)
178     void checkForMatchingBackdropFilterFunctionLists();
179 #endif
180
181     KeyframeList m_blendingKeyframes { emptyString() };
182     Vector<ParsedKeyframe> m_parsedKeyframes;
183     Vector<AcceleratedAction> m_pendingAcceleratedActions;
184     RefPtr<Element> m_target;
185
186     AcceleratedAction m_lastRecordedAcceleratedAction { AcceleratedAction::Stop };
187     BlendingKeyframesSource m_blendingKeyframesSource { BlendingKeyframesSource::WebAnimation };
188     IterationCompositeOperation m_iterationCompositeOperation { IterationCompositeOperation::Replace };
189     CompositeOperation m_compositeOperation { CompositeOperation::Replace };
190     AcceleratedProperties m_acceleratedPropertiesState { AcceleratedProperties::None };
191     AnimationEffectPhase m_phaseAtLastApplication { AnimationEffectPhase::Idle };
192     bool m_isRunningAccelerated { false };
193     bool m_needsForcedLayout { false };
194     bool m_triggersStackingContext { false };
195     bool m_transformFunctionListsMatch { false };
196     bool m_filterFunctionListsMatch { false };
197 #if ENABLE(FILTERS_LEVEL_2)
198     bool m_backdropFilterFunctionListsMatch { false };
199 #endif
200     bool m_colorFilterFunctionListsMatch { false };
201     bool m_inTargetEffectStack { false };
202 };
203
204 } // namespace WebCore
205
206 SPECIALIZE_TYPE_TRAITS_ANIMATION_EFFECT(KeyframeEffect, isKeyframeEffect());