[BlackBerry] Upstream LayerAnimation.{cpp, h}
[WebKit-https.git] / Source / WebCore / platform / graphics / blackberry / LayerAnimation.h
1 /*
2  * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  *
19  */
20
21 #ifndef LayerAnimation_h
22 #define LayerAnimation_h
23
24 #include "GraphicsLayer.h"
25
26 #include <wtf/PassRefPtr.h>
27 #include <wtf/RefCounted.h>
28
29 #define DEBUG_LAYER_ANIMATION 0
30
31 namespace WebCore {
32
33 class Animation;
34 class LayerCompositingThread;
35 class TransformationMatrix;
36
37 // This class uses non-threadsafe refcounting in the WebCore::Animation and
38 // WebCore::String members, so using threadsafe refcounting here would be a big
39 // cover-up. Instead, you must be careful to use ref/deref this class only on
40 // the WebKit thread, or when the WebKit and compositing threads are in sync.
41 class LayerAnimation : public RefCounted<LayerAnimation> {
42 public:
43     // WebKit thread only
44     // Because the refcounting done in constructor and destructor is not thread safe,
45     // the LayerAnimation must be created or destroyed on the WebKit thread, or when
46     // the WebKit and compositing threads are in sync.
47     // Also, the name property is using a String which has non-threadsafe refcounting.
48     // The setStartTime method is not threadsafe and must only be called on a newly
49     // created LayerAnimation before sending it off to the compositing thread.
50     static PassRefPtr<LayerAnimation> create(const KeyframeValueList& values, const IntSize& boxSize, const Animation* animation, const String& name, double timeOffset)
51     {
52         return adoptRef(new LayerAnimation(values, boxSize, animation, name, timeOffset));
53     }
54
55     PassRefPtr<LayerAnimation> clone(double timeOffset)
56     {
57         LayerAnimation* animation = new LayerAnimation(*this);
58         // The cloned animation should get a different timeOffset if it's paused.
59         animation->m_timeOffset = timeOffset;
60
61         return adoptRef(animation);
62     }
63
64     ~LayerAnimation()
65     {
66     }
67
68     const String& name() const { return m_name; }
69     void setStartTime(double time) { m_startTime = time; }
70
71     // These functions are thread safe (immutable state).
72     static int idFromAnimation(const Animation* animation) { return reinterpret_cast<int>(animation); }
73     bool isEqualToAnimation(const Animation* animation) const { return idFromAnimation(animation) == id(); }
74     int id() const { return m_id; }
75     AnimatedPropertyID property() const { return m_values.property(); }
76     IntSize boxSize() const { return m_boxSize; }
77     double timeOffset() const { return m_timeOffset; }
78     double startTime() const { return m_startTime; }
79     size_t valueCount() const { return m_values.size(); }
80
81     // NOTE: Don't try to ref a TimingFunction, that's not a threadsafe operation.
82     const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
83     double duration() const { return m_duration; }
84     int iterationCount() const { return m_iterationCount; }
85     Animation::AnimationDirection direction() const { return m_direction; }
86
87     // NOTE: Don't try to clone() an AnimationValue, that's not a threadsafe operation since it mutates refcounts.
88     const AnimationValue* valueAt(size_t i) const { return m_values.at(i); }
89
90     TransformationMatrix blendTransform(const TransformOperations* from, const TransformOperations*, double progress) const;
91     float blendOpacity(float from, float to, double progress) const;
92     void apply(LayerCompositingThread*, double elapsedTime);
93
94 private:
95     LayerAnimation(const KeyframeValueList& values, const IntSize& boxSize, const Animation* animation, const String& name, double timeOffset)
96         : m_id(reinterpret_cast<int>(animation))
97         , m_values(values)
98         , m_boxSize(boxSize)
99         , m_name(name)
100         , m_timeOffset(timeOffset)
101         , m_startTime(0)
102         , m_timingFunction(0)
103         , m_duration(animation->duration())
104         , m_iterationCount(animation->iterationCount())
105         , m_direction(animation->direction())
106     {
107         if (animation->isTimingFunctionSet())
108             m_timingFunction = animation->timingFunction();
109
110         validateTransformLists();
111     }
112
113     LayerAnimation(const LayerAnimation& other)
114         :  RefCounted<LayerAnimation>()
115         , m_id(other.m_id)
116         , m_values(other.m_values)
117         , m_boxSize(other.m_boxSize)
118         , m_name(other.m_name)
119         , m_timeOffset(other.m_timeOffset)
120         , m_startTime(other.m_startTime)
121         , m_transformFunctionListValid(other.m_transformFunctionListValid)
122         , m_timingFunction(other.m_timingFunction)
123         , m_duration(other.m_duration)
124         , m_iterationCount(other.m_iterationCount)
125         , m_direction(other.m_direction)
126     {
127     }
128
129     void validateTransformLists();
130
131     int m_id;
132
133     // NOTE: Don't expose the KeyframeValueList directly, since its copy
134     // constructor mutates refcounts and thus is not thread safe.
135     KeyframeValueList m_values;
136     IntSize m_boxSize;
137     String m_name;
138     double m_timeOffset;
139     double m_startTime;
140     bool m_transformFunctionListValid;
141
142     RefPtr<TimingFunction> m_timingFunction;
143     double m_duration;
144     int m_iterationCount;
145     Animation::AnimationDirection m_direction;
146 };
147
148 }
149
150 #endif // LayerAnimation_h