Stop using PassRefPtr in platform/graphics
[WebKit-https.git] / Source / WebKit2 / WebProcess / WebPage / mac / PlatformCAAnimationRemote.h
1 /*
2  * Copyright (C) 2014 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 #ifndef PlatformCAAnimationRemote_h
27 #define PlatformCAAnimationRemote_h
28
29 #include <WebCore/PlatformCAAnimation.h>
30 #include <wtf/HashMap.h>
31 #include <wtf/HashSet.h>
32
33 namespace IPC {
34 class Encoder;
35 class Decoder;
36 };
37
38 namespace WebCore {
39 class TextStream;
40 };
41
42 OBJC_CLASS CALayer;
43
44 namespace WebKit {
45
46 class RemoteLayerTreeHost;
47
48 class PlatformCAAnimationRemote final : public WebCore::PlatformCAAnimation {
49 public:
50     static Ref<PlatformCAAnimation> create(AnimationType, const String& keyPath);
51
52     virtual ~PlatformCAAnimationRemote() { }
53
54     bool isPlatformCAAnimationRemote() const override { return true; }
55
56     Ref<PlatformCAAnimation> copy() const override;
57
58     String keyPath() const override;
59
60     CFTimeInterval beginTime() const override;
61     void setBeginTime(CFTimeInterval) override;
62
63     CFTimeInterval duration() const override;
64     void setDuration(CFTimeInterval) override;
65
66     float speed() const override;
67     void setSpeed(float) override;
68
69     CFTimeInterval timeOffset() const override;
70     void setTimeOffset(CFTimeInterval) override;
71
72     float repeatCount() const override;
73     void setRepeatCount(float) override;
74
75     bool autoreverses() const override;
76     void setAutoreverses(bool) override;
77
78     FillModeType fillMode() const override;
79     void setFillMode(FillModeType) override;
80
81     void setTimingFunction(const WebCore::TimingFunction*, bool reverse = false) override;
82     void copyTimingFunctionFrom(const WebCore::PlatformCAAnimation&) override;
83
84     bool isRemovedOnCompletion() const override;
85     void setRemovedOnCompletion(bool) override;
86
87     bool isAdditive() const override;
88     void setAdditive(bool) override;
89
90     ValueFunctionType valueFunction() const override;
91     void setValueFunction(ValueFunctionType) override;
92
93     // Basic-animation properties.
94     void setFromValue(float) override;
95     void setFromValue(const WebCore::TransformationMatrix&) override;
96     void setFromValue(const WebCore::FloatPoint3D&) override;
97     void setFromValue(const WebCore::Color&) override;
98     void setFromValue(const WebCore::FilterOperation*, int internalFilterPropertyIndex) override;
99     void copyFromValueFrom(const WebCore::PlatformCAAnimation&) override;
100
101     void setToValue(float) override;
102     void setToValue(const WebCore::TransformationMatrix&) override;
103     void setToValue(const WebCore::FloatPoint3D&) override;
104     void setToValue(const WebCore::Color&) override;
105     void setToValue(const WebCore::FilterOperation*, int internalFilterPropertyIndex) override;
106     void copyToValueFrom(const WebCore::PlatformCAAnimation&) override;
107
108     // Keyframe-animation properties.
109     void setValues(const Vector<float>&) override;
110     void setValues(const Vector<WebCore::TransformationMatrix>&) override;
111     void setValues(const Vector<WebCore::FloatPoint3D>&) override;
112     void setValues(const Vector<WebCore::Color>&) override;
113     void setValues(const Vector<RefPtr<WebCore::FilterOperation>>&, int internalFilterPropertyIndex) override;
114     void copyValuesFrom(const WebCore::PlatformCAAnimation&) override;
115
116     void setKeyTimes(const Vector<float>&) override;
117     void copyKeyTimesFrom(const WebCore::PlatformCAAnimation&) override;
118
119     void setTimingFunctions(const Vector<const WebCore::TimingFunction*>&, bool reverse = false) override;
120     void copyTimingFunctionsFrom(const WebCore::PlatformCAAnimation&) override;
121
122     AnimationType animationType() const { return m_properties.animationType; }
123     void setHasExplicitBeginTime(bool hasExplicitBeginTime) { m_properties.hasExplicitBeginTime = hasExplicitBeginTime; }
124     bool hasExplicitBeginTime() const { return m_properties.hasExplicitBeginTime; }
125
126     void didStart(CFTimeInterval beginTime) { m_properties.beginTime = beginTime; }
127
128     class KeyframeValue {
129     public:
130         enum KeyframeType {
131             NumberKeyType,
132             ColorKeyType,
133             PointKeyType,
134             TransformKeyType,
135             FilterKeyType,
136         };
137
138         ~KeyframeValue()
139         {
140         }
141
142         KeyframeValue(float value = 0)
143             : keyType(NumberKeyType)
144             , number(value)
145         {
146         }
147
148         KeyframeValue(WebCore::Color value)
149             : keyType(ColorKeyType)
150             , color(value)
151         {
152         }
153
154         KeyframeValue(const WebCore::FloatPoint3D& value)
155             : keyType(PointKeyType)
156             , point(value)
157         {
158         }
159
160         KeyframeValue(const WebCore::TransformationMatrix& value)
161             : keyType(TransformKeyType)
162             , transform(value)
163         {
164         }
165
166         KeyframeValue(PassRefPtr<WebCore::FilterOperation> value)
167             : keyType(FilterKeyType)
168             , filter(value)
169         {
170         }
171
172         KeyframeValue(const KeyframeValue& other)
173         {
174             *this = other;
175         }
176
177         KeyframeValue& operator=(const KeyframeValue& other)
178         {
179             keyType = other.keyType;
180             switch (keyType) {
181             case NumberKeyType:
182                 number = other.number;
183                 break;
184             case ColorKeyType:
185                 color = other.color;
186                 break;
187             case PointKeyType:
188                 point = other.point;
189                 break;
190             case TransformKeyType:
191                 transform = other.transform;
192                 break;
193             case FilterKeyType:
194                 filter = other.filter;
195                 break;
196             }
197
198             return *this;
199         }
200
201         KeyframeType keyframeType() const { return keyType; }
202
203         float numberValue() const
204         {
205             ASSERT(keyType == NumberKeyType);
206             return number;
207         }
208
209         WebCore::Color colorValue() const
210         {
211             ASSERT(keyType == ColorKeyType);
212             return color;
213         }
214
215         const WebCore::FloatPoint3D& pointValue() const
216         {
217             ASSERT(keyType == PointKeyType);
218             return point;
219         }
220
221         const WebCore::TransformationMatrix& transformValue() const
222         {
223             ASSERT(keyType == TransformKeyType);
224             return transform;
225         }
226
227         const WebCore::FilterOperation* filterValue() const
228         {
229             ASSERT(keyType == FilterKeyType);
230             return filter.get();
231         }
232
233         void encode(IPC::Encoder&) const;
234         static bool decode(IPC::Decoder&, KeyframeValue&);
235
236     private:
237         KeyframeType keyType;
238         union {
239             float number;
240             WebCore::Color color;
241             WebCore::FloatPoint3D point;
242             WebCore::TransformationMatrix transform;
243         };
244         RefPtr<WebCore::FilterOperation> filter;
245     };
246
247     struct Properties {
248         Properties()
249             : animationType(Basic)
250             , beginTime(0)
251             , duration(0)
252             , timeOffset(0)
253             , repeatCount(1)
254             , speed(1)
255             , fillMode(NoFillMode)
256             , valueFunction(NoValueFunction)
257             , autoReverses(false)
258             , removedOnCompletion(true)
259             , additive(false)
260             , reverseTimingFunctions(false)
261             , hasExplicitBeginTime(false)
262         {
263         }
264
265         void encode(IPC::Encoder&) const;
266         static bool decode(IPC::Decoder&, Properties&);
267
268         String keyPath;
269         PlatformCAAnimation::AnimationType animationType;
270
271         double beginTime;
272         double duration;
273         double timeOffset;
274         float repeatCount;
275         float speed;
276
277         PlatformCAAnimation::FillModeType fillMode;
278         PlatformCAAnimation::ValueFunctionType valueFunction;
279
280         bool autoReverses;
281         bool removedOnCompletion;
282         bool additive;
283         bool reverseTimingFunctions;
284         bool hasExplicitBeginTime;
285
286         // For basic animations, these vectors have two entries. For keyframe animations, two or more.
287         // timingFunctions has n-1 entries.
288         Vector<KeyframeValue> keyValues;
289         Vector<float> keyTimes;
290         Vector<RefPtr<WebCore::TimingFunction>> timingFunctions;
291     };
292
293     const Properties& properties() const { return m_properties; }
294
295     typedef Vector<std::pair<String, Properties>> AnimationsList;
296     static void updateLayerAnimations(CALayer *, RemoteLayerTreeHost*, const AnimationsList& animationsToAdd, const HashSet<String>& animationsToRemove);
297
298 private:
299     PlatformCAAnimationRemote(AnimationType, const String& keyPath);
300
301     Properties m_properties;
302 };
303
304 WebCore::TextStream& operator<<(WebCore::TextStream&, const PlatformCAAnimationRemote::KeyframeValue&);
305 WebCore::TextStream& operator<<(WebCore::TextStream&, const PlatformCAAnimationRemote::Properties&);
306
307 } // namespace WebKit
308
309 SPECIALIZE_TYPE_TRAITS_CAANIMATION(WebKit::PlatformCAAnimationRemote, isPlatformCAAnimationRemote())
310
311 #endif // PlatformCAAnimationRemote_h