Fix the ACCELERATED_COMPOSITING code to not expose RenderLayer outside rendering
[WebKit.git] / Source / WebCore / page / animation / ImplicitAnimation.cpp
1 /*
2  * Copyright (C) 2007 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30
31 #include "AnimationControllerPrivate.h"
32 #include "CompositeAnimation.h"
33 #include "EventNames.h"
34 #include "ImplicitAnimation.h"
35 #include "KeyframeAnimation.h"
36 #include "RenderBoxModelObject.h"
37 #include <wtf/UnusedParam.h>
38
39 namespace WebCore {
40
41 ImplicitAnimation::ImplicitAnimation(const Animation* transition, CSSPropertyID animatingProperty, RenderObject* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle)
42     : AnimationBase(transition, renderer, compAnim)
43     , m_transitionProperty(transition->property())
44     , m_animatingProperty(animatingProperty)
45     , m_overridden(false)
46     , m_active(true)
47     , m_fromStyle(fromStyle)
48 {
49     ASSERT(animatingProperty != CSSPropertyInvalid);
50 }
51
52 ImplicitAnimation::~ImplicitAnimation()
53 {
54     // // Make sure to tell the renderer that we are ending. This will make sure any accelerated animations are removed.
55     if (!postActive())
56         endAnimation();
57 }
58
59 bool ImplicitAnimation::shouldSendEventForListener(Document::ListenerType inListenerType) const
60 {
61     return m_object->document()->hasListenerType(inListenerType);
62 }
63
64 void ImplicitAnimation::animate(CompositeAnimation*, RenderObject*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
65 {
66     // If we get this far and the animation is done, it means we are cleaning up a just finished animation.
67     // So just return. Everything is already all cleaned up.
68     if (postActive())
69         return;
70
71     // Reset to start the transition if we are new
72     if (isNew())
73         reset(targetStyle);
74
75     // Run a cycle of animation.
76     // We know we will need a new render style, so make one if needed
77     if (!animatedStyle)
78         animatedStyle = RenderStyle::clone(targetStyle);
79
80     bool needsAnim = blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
81     // FIXME: we also need to detect cases where we have to software animate for other reasons,
82     // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
83     if (needsAnim)
84         setAnimating();
85     else {
86 #if USE(ACCELERATED_COMPOSITING)
87         // If we are running an accelerated animation, set a flag in the style which causes the style
88         // to compare as different to any other style. This ensures that changes to the property
89         // that is animating are correctly detected during the animation (e.g. when a transition
90         // gets interrupted).
91         animatedStyle->setIsRunningAcceleratedAnimation();
92 #endif
93     }
94
95     // Fire the start timeout if needed
96     fireAnimationEventsIfNeeded();
97 }
98
99 void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle)
100 {
101     if (!animatedStyle)
102         animatedStyle = RenderStyle::clone(m_toStyle.get());
103
104     blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
105 }
106
107 bool ImplicitAnimation::startAnimation(double timeOffset)
108 {
109 #if USE(ACCELERATED_COMPOSITING)
110     if (m_object && m_object->isComposited())
111         return toRenderBoxModelObject(m_object)->startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());
112 #else
113     UNUSED_PARAM(timeOffset);
114 #endif
115     return false;
116 }
117
118 void ImplicitAnimation::pauseAnimation(double timeOffset)
119 {
120     if (!m_object)
121         return;
122
123 #if USE(ACCELERATED_COMPOSITING)
124     if (m_object->isComposited())
125         toRenderBoxModelObject(m_object)->transitionPaused(timeOffset, m_animatingProperty);
126 #else
127     UNUSED_PARAM(timeOffset);
128 #endif
129     // Restore the original (unanimated) style
130     if (!paused())
131         setNeedsStyleRecalc(m_object->node());
132 }
133
134 void ImplicitAnimation::endAnimation()
135 {
136 #if USE(ACCELERATED_COMPOSITING)
137     if (m_object && m_object->isComposited())
138         toRenderBoxModelObject(m_object)->transitionFinished(m_animatingProperty);
139 #endif
140 }
141
142 void ImplicitAnimation::onAnimationEnd(double elapsedTime)
143 {
144     // If we have a keyframe animation on this property, this transition is being overridden. The keyframe
145     // animation keeps an unanimated style in case a transition starts while the keyframe animation is
146     // running. But now that the transition has completed, we need to update this style with its new
147     // destination. If we didn't, the next time through we would think a transition had started
148     // (comparing the old unanimated style with the new final style of the transition).
149     RefPtr<KeyframeAnimation> keyframeAnim = m_compAnim->getAnimationForProperty(m_animatingProperty);
150     if (keyframeAnim)
151         keyframeAnim->setUnanimatedStyle(m_toStyle);
152     
153     sendTransitionEvent(eventNames().webkitTransitionEndEvent, elapsedTime);
154     endAnimation();
155 }
156
157 bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, double elapsedTime)
158 {
159     if (eventType == eventNames().webkitTransitionEndEvent) {
160         Document::ListenerType listenerType = Document::TRANSITIONEND_LISTENER;
161
162         if (shouldSendEventForListener(listenerType)) {
163             String propertyName = getPropertyName(m_animatingProperty);
164                 
165             // Dispatch the event
166             RefPtr<Element> element = 0;
167             if (m_object->node() && m_object->node()->isElementNode())
168                 element = static_cast<Element*>(m_object->node());
169
170             ASSERT(!element || (element->document() && !element->document()->inPageCache()));
171             if (!element)
172                 return false;
173
174             // Schedule event handling
175             m_compAnim->animationController()->addEventToDispatch(element, eventType, propertyName, elapsedTime);
176
177             // Restore the original (unanimated) style
178             if (eventType == eventNames().webkitTransitionEndEvent && element->renderer())
179                 setNeedsStyleRecalc(element.get());
180
181             return true; // Did dispatch an event
182         }
183     }
184
185     return false; // Didn't dispatch an event
186 }
187
188 void ImplicitAnimation::reset(RenderStyle* to)
189 {
190     ASSERT(to);
191     ASSERT(m_fromStyle);
192
193     m_toStyle = to;
194
195     // Restart the transition
196     if (m_fromStyle && m_toStyle)
197         updateStateMachine(AnimationStateInputRestartAnimation, -1);
198         
199     // set the transform animation list
200     validateTransformFunctionList();
201 #if ENABLE(CSS_FILTERS)
202     checkForMatchingFilterFunctionLists();
203 #endif
204 }
205
206 void ImplicitAnimation::setOverridden(bool b)
207 {
208     if (b == m_overridden)
209         return;
210
211     m_overridden = b;
212     updateStateMachine(m_overridden ? AnimationStateInputPauseOverride : AnimationStateInputResumeOverride, -1);
213 }
214
215 bool ImplicitAnimation::affectsProperty(CSSPropertyID property) const
216 {
217     return (m_animatingProperty == property);
218 }
219
220 bool ImplicitAnimation::isTargetPropertyEqual(CSSPropertyID prop, const RenderStyle* targetStyle)
221 {
222     // We can get here for a transition that has not started yet. This would make m_toStyle unset and null. 
223     // So we check that here (see <https://bugs.webkit.org/show_bug.cgi?id=26706>)
224     if (!m_toStyle)
225         return false;
226     return propertiesEqual(prop, m_toStyle.get(), targetStyle);
227 }
228
229 void ImplicitAnimation::blendPropertyValueInStyle(CSSPropertyID prop, RenderStyle* currentStyle)
230 {
231     // We should never add a transition with a 0 duration and delay. But if we ever did
232     // it would have a null toStyle. So just in case, let's check that here. (See
233     // <https://bugs.webkit.org/show_bug.cgi?id=24787>
234     if (!m_toStyle)
235         return;
236         
237     blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
238 }
239
240 void ImplicitAnimation::validateTransformFunctionList()
241 {
242     m_transformFunctionListValid = false;
243     
244     if (!m_fromStyle || !m_toStyle)
245         return;
246         
247     const TransformOperations* val = &m_fromStyle->transform();
248     const TransformOperations* toVal = &m_toStyle->transform();
249
250     if (val->operations().isEmpty())
251         val = toVal;
252
253     if (val->operations().isEmpty())
254         return;
255         
256     // An emtpy transform list matches anything.
257     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
258         return;
259
260     // Transform lists match.
261     m_transformFunctionListValid = true;
262 }
263
264 #if ENABLE(CSS_FILTERS)
265 void ImplicitAnimation::checkForMatchingFilterFunctionLists()
266 {
267     m_filterFunctionListsMatch = false;
268     
269     if (!m_fromStyle || !m_toStyle)
270         return;
271         
272     const FilterOperations* val = &m_fromStyle->filter();
273     const FilterOperations* toVal = &m_toStyle->filter();
274
275     if (val->operations().isEmpty())
276         val = toVal;
277
278     if (val->operations().isEmpty())
279         return;
280         
281     // An emtpy filter list matches anything.
282     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
283         return;
284
285     // Filter lists match.
286     m_filterFunctionListsMatch = true;
287 }
288 #endif
289
290 double ImplicitAnimation::timeToNextService()
291 {
292     double t = AnimationBase::timeToNextService();
293 #if USE(ACCELERATED_COMPOSITING)
294     if (t != 0 || preActive())
295         return t;
296         
297     // A return value of 0 means we need service. But if this is an accelerated animation we 
298     // only need service at the end of the transition.
299     if (animationOfPropertyIsAccelerated(m_animatingProperty) && isAccelerated()) {
300         bool isLooping;
301         getTimeToNextEvent(t, isLooping);
302     }
303 #endif
304     return t;
305 }
306
307 } // namespace WebCore