Eliminate styleDidChange with StyleDifferenceEqual when updates are actually necessary
[WebKit-https.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 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 "CSSPropertyAnimation.h"
33 #include "CompositeAnimation.h"
34 #include "EventNames.h"
35 #include "GeometryUtilities.h"
36 #include "ImplicitAnimation.h"
37 #include "KeyframeAnimation.h"
38 #include "RenderBox.h"
39
40 namespace WebCore {
41
42 ImplicitAnimation::ImplicitAnimation(Animation& transition, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle)
43     : AnimationBase(transition, renderer, compAnim)
44     , m_fromStyle(fromStyle)
45     , m_transitionProperty(transition.property())
46     , m_animatingProperty(animatingProperty)
47 {
48     ASSERT(animatingProperty != CSSPropertyInvalid);
49 }
50
51 ImplicitAnimation::~ImplicitAnimation()
52 {
53     // // Make sure to tell the renderer that we are ending. This will make sure any accelerated animations are removed.
54     if (!postActive())
55         endAnimation();
56 }
57
58 bool ImplicitAnimation::shouldSendEventForListener(Document::ListenerType inListenerType) const
59 {
60     return m_object->document().hasListenerType(inListenerType);
61 }
62
63 bool ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
64 {
65     // If we get this far and the animation is done, it means we are cleaning up a just finished animation.
66     // So just return. Everything is already all cleaned up.
67     if (postActive())
68         return false;
69
70     AnimationState oldState = state();
71
72     // Reset to start the transition if we are new
73     if (isNew())
74         reset(targetStyle);
75
76     // Run a cycle of animation.
77     // We know we will need a new render style, so make one if needed
78     if (!animatedStyle)
79         animatedStyle = RenderStyle::clone(targetStyle);
80
81     bool needsAnim = CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
82     // FIXME: we also need to detect cases where we have to software animate for other reasons,
83     // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
84     if (!needsAnim) {
85         // If we are running an accelerated animation, set a flag in the style which causes the style
86         // to compare as different to any other style. This ensures that changes to the property
87         // that is animating are correctly detected during the animation (e.g. when a transition
88         // gets interrupted).
89         // FIXME: still need this hack?
90         animatedStyle->setIsRunningAcceleratedAnimation();
91     }
92
93     // Fire the start timeout if needed
94     fireAnimationEventsIfNeeded();
95     return state() != oldState;
96 }
97
98 void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle)
99 {
100     if (!animatedStyle)
101         animatedStyle = RenderStyle::clone(m_toStyle.get());
102
103     CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
104 }
105
106 bool ImplicitAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const
107 {
108     ASSERT(hasStyle());
109
110     if (!is<RenderBox>(m_object))
111         return true; // Non-boxes don't get transformed;
112
113     ASSERT(m_animatingProperty == CSSPropertyTransform);
114
115     RenderBox& box = downcast<RenderBox>(*m_object);
116     FloatRect rendererBox = snapRectToDevicePixels(box.borderBoxRect(), box.document().deviceScaleFactor());
117
118     LayoutRect startBounds = bounds;
119     LayoutRect endBounds = bounds;
120
121     if (isTransformFunctionListValid()) {
122         if (!computeTransformedExtentViaTransformList(rendererBox, *m_fromStyle, startBounds))
123             return false;
124
125         if (!computeTransformedExtentViaTransformList(rendererBox, *m_toStyle, endBounds))
126             return false;
127     } else {
128         if (!computeTransformedExtentViaMatrix(rendererBox, *m_fromStyle, startBounds))
129             return false;
130
131         if (!computeTransformedExtentViaMatrix(rendererBox, *m_toStyle, endBounds))
132             return false;
133     }
134
135     bounds = unionRect(startBounds, endBounds);
136     return true;
137 }
138
139 bool ImplicitAnimation::startAnimation(double timeOffset)
140 {
141     if (m_object && m_object->isComposited())
142         return downcast<RenderBoxModelObject>(*m_object).startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());
143     return false;
144 }
145
146 void ImplicitAnimation::pauseAnimation(double timeOffset)
147 {
148     if (!m_object)
149         return;
150
151     if (m_object->isComposited())
152         downcast<RenderBoxModelObject>(*m_object).transitionPaused(timeOffset, m_animatingProperty);
153     // Restore the original (unanimated) style
154     if (!paused())
155         setNeedsStyleRecalc(m_object->element());
156 }
157
158 void ImplicitAnimation::endAnimation()
159 {
160     if (m_object && m_object->isComposited())
161         downcast<RenderBoxModelObject>(*m_object).transitionFinished(m_animatingProperty);
162 }
163
164 void ImplicitAnimation::onAnimationEnd(double elapsedTime)
165 {
166     // If we have a keyframe animation on this property, this transition is being overridden. The keyframe
167     // animation keeps an unanimated style in case a transition starts while the keyframe animation is
168     // running. But now that the transition has completed, we need to update this style with its new
169     // destination. If we didn't, the next time through we would think a transition had started
170     // (comparing the old unanimated style with the new final style of the transition).
171     RefPtr<KeyframeAnimation> keyframeAnim = m_compositeAnimation->getAnimationForProperty(m_animatingProperty);
172     if (keyframeAnim)
173         keyframeAnim->setUnanimatedStyle(m_toStyle);
174     
175     sendTransitionEvent(eventNames().transitionendEvent, elapsedTime);
176     endAnimation();
177 }
178
179 bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, double elapsedTime)
180 {
181     if (eventType == eventNames().transitionendEvent) {
182         Document::ListenerType listenerType = Document::TRANSITIONEND_LISTENER;
183
184         if (shouldSendEventForListener(listenerType)) {
185             String propertyName = getPropertyNameString(m_animatingProperty);
186                 
187             // Dispatch the event
188             RefPtr<Element> element = m_object->element();
189
190             ASSERT(!element || !element->document().inPageCache());
191             if (!element)
192                 return false;
193
194             // Schedule event handling
195             m_compositeAnimation->animationController().addEventToDispatch(element, eventType, propertyName, elapsedTime);
196
197             // Restore the original (unanimated) style
198             if (eventType == eventNames().transitionendEvent && element->renderer())
199                 setNeedsStyleRecalc(element.get());
200
201             return true; // Did dispatch an event
202         }
203     }
204
205     return false; // Didn't dispatch an event
206 }
207
208 void ImplicitAnimation::reset(RenderStyle* to)
209 {
210     ASSERT(to);
211     ASSERT(m_fromStyle);
212
213     m_toStyle = to;
214
215     // Restart the transition
216     if (m_fromStyle && m_toStyle)
217         updateStateMachine(AnimationStateInput::RestartAnimation, -1);
218         
219     // set the transform animation list
220     validateTransformFunctionList();
221     checkForMatchingFilterFunctionLists();
222 }
223
224 void ImplicitAnimation::setOverridden(bool b)
225 {
226     if (b == m_overridden)
227         return;
228
229     m_overridden = b;
230     updateStateMachine(m_overridden ? AnimationStateInput::PauseOverride : AnimationStateInput::ResumeOverride, -1);
231 }
232
233 bool ImplicitAnimation::affectsProperty(CSSPropertyID property) const
234 {
235     return (m_animatingProperty == property);
236 }
237
238 bool ImplicitAnimation::isTargetPropertyEqual(CSSPropertyID prop, const RenderStyle* targetStyle)
239 {
240     // We can get here for a transition that has not started yet. This would make m_toStyle unset and null. 
241     // So we check that here (see <https://bugs.webkit.org/show_bug.cgi?id=26706>)
242     if (!m_toStyle)
243         return false;
244     return CSSPropertyAnimation::propertiesEqual(prop, m_toStyle.get(), targetStyle);
245 }
246
247 void ImplicitAnimation::blendPropertyValueInStyle(CSSPropertyID prop, RenderStyle* currentStyle)
248 {
249     // We should never add a transition with a 0 duration and delay. But if we ever did
250     // it would have a null toStyle. So just in case, let's check that here. (See
251     // <https://bugs.webkit.org/show_bug.cgi?id=24787>
252     if (!m_toStyle)
253         return;
254         
255     CSSPropertyAnimation::blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
256 }
257
258 void ImplicitAnimation::validateTransformFunctionList()
259 {
260     m_transformFunctionListValid = false;
261     
262     if (!m_fromStyle || !m_toStyle)
263         return;
264         
265     const TransformOperations* val = &m_fromStyle->transform();
266     const TransformOperations* toVal = &m_toStyle->transform();
267
268     if (val->operations().isEmpty())
269         val = toVal;
270
271     if (val->operations().isEmpty())
272         return;
273         
274     // An emtpy transform list matches anything.
275     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
276         return;
277
278     // Transform lists match.
279     m_transformFunctionListValid = true;
280 }
281
282 void ImplicitAnimation::checkForMatchingFilterFunctionLists()
283 {
284     m_filterFunctionListsMatch = false;
285     
286     if (!m_fromStyle || !m_toStyle)
287         return;
288         
289     const FilterOperations* val = &m_fromStyle->filter();
290     const FilterOperations* toVal = &m_toStyle->filter();
291
292     if (val->operations().isEmpty())
293         val = toVal;
294
295     if (val->operations().isEmpty())
296         return;
297         
298     // An emtpy filter list matches anything.
299     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
300         return;
301
302     // Filter lists match.
303     m_filterFunctionListsMatch = true;
304 }
305
306 double ImplicitAnimation::timeToNextService()
307 {
308     double t = AnimationBase::timeToNextService();
309     if (t != 0 || preActive())
310         return t;
311         
312     // A return value of 0 means we need service. But if this is an accelerated animation we 
313     // only need service at the end of the transition.
314     if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(m_animatingProperty) && isAccelerated()) {
315         bool isLooping;
316         getTimeToNextEvent(t, isLooping);
317     }
318     return t;
319 }
320
321 } // namespace WebCore