85609812603bf730058553ffca300117bf7bfd9d
[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 "CSSPropertyBlendingClient.h"
30 #include "CompositeOperation.h"
31 #include "CompositeOperationOrAuto.h"
32 #include "EffectTiming.h"
33 #include "Element.h"
34 #include "IterationCompositeOperation.h"
35 #include "KeyframeEffectOptions.h"
36 #include "KeyframeList.h"
37 #include "RenderStyle.h"
38 #include "StyleProperties.h"
39 #include "WebAnimationUtilities.h"
40 #include <wtf/Ref.h>
41
42 namespace WebCore {
43
44 class Element;
45 class FilterOperations;
46
47 class KeyframeEffect : public AnimationEffect
48     , public CSSPropertyBlendingClient {
49 public:
50     static ExceptionOr<Ref<KeyframeEffect>> create(JSC::JSGlobalObject&, Element*, JSC::Strong<JSC::JSObject>&&, Optional<Variant<double, KeyframeEffectOptions>>&&);
51     static ExceptionOr<Ref<KeyframeEffect>> create(JSC::JSGlobalObject&, Ref<KeyframeEffect>&&);
52     static Ref<KeyframeEffect> create(const Element&);
53     ~KeyframeEffect() { }
54
55     bool isKeyframeEffect() const final { return true; }
56
57     struct BasePropertyIndexedKeyframe {
58         Variant<std::nullptr_t, Vector<Optional<double>>, double> offset = Vector<Optional<double>>();
59         Variant<Vector<String>, String> easing = Vector<String>();
60         Variant<Vector<CompositeOperationOrAuto>, CompositeOperationOrAuto> composite = Vector<CompositeOperationOrAuto>();
61     };
62
63     struct BaseKeyframe {
64         MarkableDouble offset;
65         String easing { "linear" };
66         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
67     };
68
69     struct PropertyAndValues {
70         CSSPropertyID property;
71         Vector<String> values;
72     };
73
74     struct KeyframeLikeObject {
75         BasePropertyIndexedKeyframe baseProperties;
76         Vector<PropertyAndValues> propertiesAndValues;
77     };
78
79     struct ParsedKeyframe {
80         MarkableDouble offset;
81         double computedOffset;
82         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
83         String easing;
84         RefPtr<TimingFunction> timingFunction;
85         Ref<MutableStyleProperties> style;
86         HashMap<CSSPropertyID, String> unparsedStyle;
87
88         ParsedKeyframe()
89             : style(MutableStyleProperties::create())
90         {
91         }
92     };
93
94     struct BaseComputedKeyframe {
95         MarkableDouble offset;
96         double computedOffset;
97         String easing { "linear" };
98         CompositeOperationOrAuto composite { CompositeOperationOrAuto::Auto };
99     };
100
101     Element* target() const { return m_target.get(); }
102     void setTarget(RefPtr<Element>&&);
103
104     Vector<JSC::Strong<JSC::JSObject>> getKeyframes(JSC::JSGlobalObject&);
105     ExceptionOr<void> setKeyframes(JSC::JSGlobalObject&, JSC::Strong<JSC::JSObject>&&);
106
107     IterationCompositeOperation iterationComposite() const { return m_iterationCompositeOperation; }
108     void setIterationComposite(IterationCompositeOperation iterationCompositeOperation) { m_iterationCompositeOperation = iterationCompositeOperation; }
109     CompositeOperation composite() const { return m_compositeOperation; }
110     void setComposite(CompositeOperation compositeOperation) { m_compositeOperation = compositeOperation; }
111
112     void getAnimatedStyle(std::unique_ptr<RenderStyle>& animatedStyle);
113     void apply(RenderStyle&) override;
114     void invalidate() override;
115     void animationDidSeek() final;
116     void animationWasCanceled() final;
117     void animationSuspensionStateDidChange(bool) final;
118     void animationTimelineDidChange(AnimationTimeline*) final;
119     void animationTimingDidChange();
120     void applyPendingAcceleratedActions();
121     bool isRunningAccelerated() const { return m_lastRecordedAcceleratedAction != AcceleratedAction::Stop; }
122     bool hasPendingAcceleratedAction() const { return !m_pendingAcceleratedActions.isEmpty() && isRunningAccelerated(); }
123
124     void setAnimation(WebAnimation*) final;
125
126     RenderElement* renderer() const override;
127     const RenderStyle& currentStyle() const override;
128     bool isAccelerated() const { return m_shouldRunAccelerated; }
129     bool triggersStackingContext() const { return m_triggersStackingContext; }
130     bool filterFunctionListsMatch() const override { return m_filterFunctionListsMatch; }
131     bool transformFunctionListsMatch() const override { return m_transformFunctionListsMatch; }
132 #if ENABLE(FILTERS_LEVEL_2)
133     bool backdropFilterFunctionListsMatch() const override { return m_backdropFilterFunctionListsMatch; }
134 #endif
135     bool colorFilterFunctionListsMatch() const override { return m_colorFilterFunctionListsMatch; }
136
137     void computeDeclarativeAnimationBlendingKeyframes(const RenderStyle* oldStyle, const RenderStyle& newStyle);
138     bool hasBlendingKeyframes() const { return m_blendingKeyframes.size(); }
139     const HashSet<CSSPropertyID>& animatedProperties() const { return m_blendingKeyframes.properties(); }
140
141     bool computeExtentOfTransformAnimation(LayoutRect&) const;
142     bool computeTransformedExtentViaTransformList(const FloatRect&, const RenderStyle&, LayoutRect&) const;
143     bool computeTransformedExtentViaMatrix(const FloatRect&, const RenderStyle&, LayoutRect&) const;
144     bool forceLayoutIfNeeded();
145
146 private:
147     KeyframeEffect(Element*);
148
149     enum class AcceleratedAction : uint8_t { Play, Pause, Seek, Stop };
150     enum class BlendingKeyframesSource : uint8_t { CSSAnimation, CSSTransition, WebAnimation };
151
152     void updateEffectStackMembership();
153     void copyPropertiesFromSource(Ref<KeyframeEffect>&&);
154     ExceptionOr<void> processKeyframes(JSC::JSGlobalObject&, JSC::Strong<JSC::JSObject>&&);
155     void addPendingAcceleratedAction(AcceleratedAction);
156     void updateAcceleratedAnimationState(ComputedEffectTiming);
157     void setAnimatedPropertiesInStyle(RenderStyle&, double);
158     TimingFunction* timingFunctionForKeyframeAtIndex(size_t);
159     Ref<const Animation> backingAnimationForCompositedRenderer() const;
160     void computedNeedsForcedLayout();
161     void computeStackingContextImpact();
162     void clearBlendingKeyframes();
163     void updateBlendingKeyframes(RenderStyle&);
164     void computeCSSAnimationBlendingKeyframes();
165     void computeCSSTransitionBlendingKeyframes(const RenderStyle* oldStyle, const RenderStyle& newStyle);
166     void computeShouldRunAccelerated();
167     void setBlendingKeyframes(KeyframeList&);
168     void checkForMatchingTransformFunctionLists();
169     void checkForMatchingFilterFunctionLists();
170     void checkForMatchingColorFilterFunctionLists();
171     bool checkForMatchingFilterFunctionLists(CSSPropertyID, const std::function<const FilterOperations& (const RenderStyle&)>&) const;
172 #if ENABLE(FILTERS_LEVEL_2)
173     void checkForMatchingBackdropFilterFunctionLists();
174 #endif
175
176     KeyframeList m_blendingKeyframes { emptyString() };
177     Vector<ParsedKeyframe> m_parsedKeyframes;
178     Vector<AcceleratedAction> m_pendingAcceleratedActions;
179     RefPtr<Element> m_target;
180
181     AcceleratedAction m_lastRecordedAcceleratedAction { AcceleratedAction::Stop };
182     BlendingKeyframesSource m_blendingKeyframesSource { BlendingKeyframesSource::WebAnimation };
183     IterationCompositeOperation m_iterationCompositeOperation { IterationCompositeOperation::Replace };
184     CompositeOperation m_compositeOperation { CompositeOperation::Replace };
185     bool m_shouldRunAccelerated { false };
186     bool m_needsForcedLayout { false };
187     bool m_triggersStackingContext { false };
188     bool m_transformFunctionListsMatch { false };
189     bool m_filterFunctionListsMatch { false };
190 #if ENABLE(FILTERS_LEVEL_2)
191     bool m_backdropFilterFunctionListsMatch { false };
192 #endif
193     bool m_colorFilterFunctionListsMatch { false };
194     bool m_inTargetEffectStack { false };
195 };
196
197 } // namespace WebCore
198
199 SPECIALIZE_TYPE_TRAITS_ANIMATION_EFFECT(KeyframeEffect, isKeyframeEffect());