Animations sometimes fail to start
[WebKit-https.git] / Source / WebCore / page / animation / CompositeAnimation.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 #include "CompositeAnimation.h"
31
32 #include "AnimationControllerPrivate.h"
33 #include "CSSPropertyAnimation.h"
34 #include "CSSPropertyNames.h"
35 #include "ImplicitAnimation.h"
36 #include "KeyframeAnimation.h"
37 #include "Logging.h"
38 #include "RenderElement.h"
39 #include "RenderStyle.h"
40 #include <wtf/text/CString.h>
41
42 namespace WebCore {
43
44 CompositeAnimation::CompositeAnimation(AnimationControllerPrivate& animationController)
45     : m_animationController(animationController)
46 {
47     m_suspended = m_animationController.isSuspended() && !m_animationController.allowsNewAnimationsWhileSuspended();
48 }
49
50 CompositeAnimation::~CompositeAnimation()
51 {
52     // Toss the refs to all animations, but make sure we remove them from
53     // any waiting lists first.
54
55     clearRenderer();
56     m_transitions.clear();
57     m_keyframeAnimations.clear();
58 }
59
60 void CompositeAnimation::clearRenderer()
61 {
62     if (!m_transitions.isEmpty()) {
63         // Clear the renderers from all running animations, in case we are in the middle of
64         // an animation callback (see https://bugs.webkit.org/show_bug.cgi?id=22052)
65         for (auto& transition : m_transitions.values()) {
66             animationController().animationWillBeRemoved(transition.get());
67             transition->clear();
68         }
69     }
70     if (!m_keyframeAnimations.isEmpty()) {
71         m_keyframeAnimations.checkConsistency();
72         for (auto& animation : m_keyframeAnimations.values()) {
73             animationController().animationWillBeRemoved(animation.get());
74             animation->clear();
75         }
76     }
77 }
78
79 void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
80 {
81     // If currentStyle is null or there are no old or new transitions, just skip it
82     if (!currentStyle || (!targetStyle->transitions() && m_transitions.isEmpty()))
83         return;
84
85     // Mark all existing transitions as no longer active. We will mark the still active ones
86     // in the next loop and then toss the ones that didn't get marked.
87     for (auto& transition : m_transitions.values())
88         transition->setActive(false);
89         
90     RefPtr<RenderStyle> modifiedCurrentStyle;
91     
92     // Check to see if we need to update the active transitions
93     if (targetStyle->transitions()) {
94         for (size_t i = 0; i < targetStyle->transitions()->size(); ++i) {
95             Animation& animation = targetStyle->transitions()->animation(i);
96             bool isActiveTransition = !m_suspended && (animation.duration() || animation.delay() > 0);
97
98             Animation::AnimationMode mode = animation.animationMode();
99             if (mode == Animation::AnimateNone)
100                 continue;
101
102             CSSPropertyID prop = animation.property();
103
104             bool all = mode == Animation::AnimateAll;
105
106             // Handle both the 'all' and single property cases. For the single prop case, we make only one pass
107             // through the loop.
108             for (int propertyIndex = 0; propertyIndex < CSSPropertyAnimation::getNumProperties(); ++propertyIndex) {
109                 if (all) {
110                     // Get the next property which is not a shorthand.
111                     bool isShorthand;
112                     prop = CSSPropertyAnimation::getPropertyAtIndex(propertyIndex, isShorthand);
113                     if (isShorthand)
114                         continue;
115                 }
116
117                 // ImplicitAnimations are always hashed by actual properties, never animateAll.
118                 ASSERT(prop >= firstCSSProperty && prop < (firstCSSProperty + numCSSProperties));
119
120                 // If there is a running animation for this property, the transition is overridden
121                 // and we have to use the unanimatedStyle from the animation. We do the test
122                 // against the unanimated style here, but we "override" the transition later.
123                 RefPtr<KeyframeAnimation> keyframeAnim = getAnimationForProperty(prop);
124                 RenderStyle* fromStyle = keyframeAnim ? keyframeAnim->unanimatedStyle() : currentStyle;
125
126                 // See if there is a current transition for this prop
127                 ImplicitAnimation* implAnim = m_transitions.get(prop);
128                 bool equal = true;
129
130                 if (implAnim) {
131                     // If we are post active don't bother setting the active flag. This will cause
132                     // this animation to get removed at the end of this function.
133                     if (!implAnim->postActive())
134                         implAnim->setActive(true);
135                     
136                     // This might be a transition that is just finishing. That would be the case
137                     // if it were postActive. But we still need to check for equality because
138                     // it could be just finishing AND changing to a new goal state.
139                     //
140                     // This implAnim might also not be an already running transition. It might be
141                     // newly added to the list in a previous iteration. This would happen if
142                     // you have both an explicit transition-property and 'all' in the same
143                     // list. In this case, the latter one overrides the earlier one, so we
144                     // behave as though this is a running animation being replaced.
145                     if (!implAnim->isTargetPropertyEqual(prop, targetStyle)) {
146                         // For accelerated animations we need to return a new RenderStyle with the _current_ value
147                         // of the property, so that restarted transitions use the correct starting point.
148                         if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
149                             if (!modifiedCurrentStyle)
150                                 modifiedCurrentStyle = RenderStyle::clone(currentStyle);
151
152                             implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get());
153                         }
154                         LOG(Animations, "Removing existing ImplicitAnimation %p for property %s", implAnim, getPropertyName(prop));
155                         animationController().animationWillBeRemoved(implAnim);
156                         m_transitions.remove(prop);
157                         equal = false;
158                     }
159                 } else {
160                     // We need to start a transition if it is active and the properties don't match
161                     equal = !isActiveTransition || CSSPropertyAnimation::propertiesEqual(prop, fromStyle, targetStyle);
162                 }
163
164                 // We can be in this loop with an inactive transition (!isActiveTransition). We need
165                 // to do that to check to see if we are canceling a transition. But we don't want to
166                 // start one of the inactive transitions. So short circuit that here. (See
167                 // <https://bugs.webkit.org/show_bug.cgi?id=24787>
168                 if (!equal && isActiveTransition) {
169                     // Add the new transition
170                     RefPtr<ImplicitAnimation> implicitAnimation = ImplicitAnimation::create(animation, prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle);
171                     LOG(Animations, "Created ImplicitAnimation %p on renderer %p for property %s duration %.2f delay %.2f", implicitAnimation.get(), renderer, getPropertyName(prop), animation.duration(), animation.delay());
172                     m_transitions.set(prop, implicitAnimation.release());
173                 }
174                 
175                 // We only need one pass for the single prop case
176                 if (!all)
177                     break;
178             }
179         }
180     }
181
182     // Make a list of transitions to be removed
183     Vector<int> toBeRemoved;
184     for (auto& transition : m_transitions.values()) {
185         if (!transition->active()) {
186             animationController().animationWillBeRemoved(transition.get());
187             toBeRemoved.append(transition->animatingProperty());
188             LOG(Animations, "Removing ImplicitAnimation %p from renderer %p for property %s", transition.get(), renderer, getPropertyName(transition->animatingProperty()));
189         }
190     }
191
192     // Now remove the transitions from the list
193     for (auto propertyToRemove : toBeRemoved)
194         m_transitions.remove(propertyToRemove);
195 }
196
197 void CompositeAnimation::updateKeyframeAnimations(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
198 {
199     // Nothing to do if we don't have any animations, and didn't have any before
200     if (m_keyframeAnimations.isEmpty() && !targetStyle->hasAnimations())
201         return;
202
203     m_keyframeAnimations.checkConsistency();
204     
205     if (currentStyle && currentStyle->hasAnimations() && targetStyle->hasAnimations() && *(currentStyle->animations()) == *(targetStyle->animations())) {
206         // The current and target animations are the same so we just need to toss any 
207         // animation which is finished (postActive).
208         for (auto& animation : m_keyframeAnimations.values()) {
209             if (animation->postActive())
210                 animation->setIndex(-1);
211         }
212     } else {
213         // Mark all existing animations as no longer active.
214         for (auto& animation : m_keyframeAnimations.values())
215             animation->setIndex(-1);
216
217 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
218         m_hasScrollTriggeredAnimation = false;
219 #endif
220
221         // Toss the animation order map.
222         m_keyframeAnimationOrderMap.clear();
223
224         DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, none, ("none", AtomicString::ConstructFromLiteral));
225         
226         // Now mark any still active animations as active and add any new animations.
227         if (targetStyle->animations()) {
228             int numAnims = targetStyle->animations()->size();
229             for (int i = 0; i < numAnims; ++i) {
230                 Animation& animation = targetStyle->animations()->animation(i);
231                 AtomicString animationName(animation.name());
232
233                 if (!animation.isValidAnimation())
234                     continue;
235                 
236                 // See if there is a current animation for this name.
237                 RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl());
238                 
239                 if (keyframeAnim) {
240                     // If this animation is postActive, skip it so it gets removed at the end of this function.
241                     if (keyframeAnim->postActive())
242                         continue;
243
244 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
245                     if (animation.trigger()->isScrollAnimationTrigger())
246                         m_hasScrollTriggeredAnimation = true;
247 #endif
248
249                     // This one is still active.
250
251                     // Animations match, but play states may differ. Update if needed.
252                     keyframeAnim->updatePlayState(animation.playState());
253                                 
254                     // Set the saved animation to this new one, just in case the play state has changed.
255                     keyframeAnim->setAnimation(animation);
256                     keyframeAnim->setIndex(i);
257                 } else if ((animation.duration() || animation.delay()) && animation.iterationCount() && animationName != none) {
258                     keyframeAnim = KeyframeAnimation::create(animation, renderer, i, this, targetStyle);
259                     LOG(Animations, "Creating KeyframeAnimation %p on renderer %p with keyframes %s, duration %.2f, delay %.2f, iterations %.2f", keyframeAnim.get(), renderer, animation.name().utf8().data(), animation.duration(), animation.delay(), animation.iterationCount());
260                     if (m_suspended) {
261                         keyframeAnim->updatePlayState(AnimPlayStatePaused);
262                         LOG(Animations, "  (created in suspended/paused state)");
263                     }
264 #if !LOG_DISABLED
265                     for (auto propertyID : keyframeAnim->keyframes().properties())
266                         LOG(Animations, "  property %s", getPropertyName(propertyID));
267 #endif
268
269 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
270                     if (animation.trigger()->isScrollAnimationTrigger())
271                         m_hasScrollTriggeredAnimation = true;
272 #endif
273
274                     m_keyframeAnimations.set(keyframeAnim->name().impl(), keyframeAnim);
275                 }
276                 
277                 // Add this to the animation order map.
278                 if (keyframeAnim)
279                     m_keyframeAnimationOrderMap.append(keyframeAnim->name().impl());
280             }
281         }
282     }
283     
284     // Make a list of animations to be removed.
285     Vector<AtomicStringImpl*> animsToBeRemoved;
286     for (auto& animation : m_keyframeAnimations.values()) {
287         if (animation->index() < 0) {
288             animsToBeRemoved.append(animation->name().impl());
289             animationController().animationWillBeRemoved(animation.get());
290             animation->clear();
291             LOG(Animations, "Removing KeyframeAnimation %p from renderer %p", animation.get(), renderer);
292         }
293     }
294     
295     // Now remove the animations from the list.
296     for (auto nameForRemoval : animsToBeRemoved)
297         m_keyframeAnimations.remove(nameForRemoval);
298 }
299
300 bool CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle, Ref<RenderStyle>& blendedStyle)
301 {
302     // We don't do any transitions if we don't have a currentStyle (on startup).
303     updateTransitions(&renderer, currentStyle, &targetStyle);
304     updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
305     m_keyframeAnimations.checkConsistency();
306
307     RefPtr<RenderStyle> animatedStyle;
308     bool animationStateChanged = false;
309
310     if (currentStyle) {
311         // Now that we have transition objects ready, let them know about the new goal state.  We want them
312         // to fill in a RenderStyle*& only if needed.
313         for (auto& transition : m_transitions.values()) {
314             if (transition->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
315                 animationStateChanged = true;
316         }
317     }
318
319     // Now that we have animation objects ready, let them know about the new goal state.  We want them
320     // to fill in a RenderStyle*& only if needed.
321     for (auto& name : m_keyframeAnimationOrderMap) {
322         RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
323         if (keyframeAnim && keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
324             animationStateChanged = true;
325     }
326
327     if (animatedStyle)
328         blendedStyle = animatedStyle.releaseNonNull();
329     else
330         blendedStyle = targetStyle;
331
332     return animationStateChanged;
333 }
334
335 PassRefPtr<RenderStyle> CompositeAnimation::getAnimatedStyle() const
336 {
337     RefPtr<RenderStyle> resultStyle;
338     for (auto& transition : m_transitions.values())
339         transition->getAnimatedStyle(resultStyle);
340
341     m_keyframeAnimations.checkConsistency();
342
343     for (auto& name : m_keyframeAnimationOrderMap) {
344         RefPtr<KeyframeAnimation> keyframeAnimation = m_keyframeAnimations.get(name);
345         if (keyframeAnimation)
346             keyframeAnimation->getAnimatedStyle(resultStyle);
347     }
348     
349     return resultStyle;
350 }
351
352 double CompositeAnimation::timeToNextService() const
353 {
354     // Returns the time at which next service is required. -1 means no service is required. 0 means 
355     // service is required now, and > 0 means service is required that many seconds in the future.
356     double minT = -1;
357     
358     if (!m_transitions.isEmpty()) {
359         for (auto& transition : m_transitions.values()) {
360             double t = transition->timeToNextService();
361             if (t < minT || minT == -1)
362                 minT = t;
363             if (minT == 0)
364                 return 0;
365         }
366     }
367     if (!m_keyframeAnimations.isEmpty()) {
368         m_keyframeAnimations.checkConsistency();
369         for (auto& animation : m_keyframeAnimations.values()) {
370             double t = animation->timeToNextService();
371             if (t < minT || minT == -1)
372                 minT = t;
373             if (minT == 0)
374                 return 0;
375         }
376     }
377
378     return minT;
379 }
380
381 PassRefPtr<KeyframeAnimation> CompositeAnimation::getAnimationForProperty(CSSPropertyID property) const
382 {
383     RefPtr<KeyframeAnimation> retval;
384     
385     // We want to send back the last animation with the property if there are multiples.
386     // So we need to iterate through all animations
387     if (!m_keyframeAnimations.isEmpty()) {
388         m_keyframeAnimations.checkConsistency();
389         for (auto& animation : m_keyframeAnimations.values()) {
390             if (animation->hasAnimationForProperty(property))
391                 retval = animation;
392         }
393     }
394     
395     return retval;
396 }
397
398 bool CompositeAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const
399 {
400     // If more than one transition and animation affect transform, give up.
401     bool seenTransformAnimation = false;
402     
403     for (auto& animation : m_keyframeAnimations.values()) {
404         if (!animation->hasAnimationForProperty(CSSPropertyTransform))
405             continue;
406
407         if (seenTransformAnimation)
408             return false;
409
410         seenTransformAnimation = true;
411
412         if (!animation->computeExtentOfTransformAnimation(bounds))
413             return false;
414     }
415
416     for (auto& transition : m_transitions.values()) {
417         if (transition->animatingProperty() != CSSPropertyTransform || !transition->hasStyle())
418             continue;
419
420         if (seenTransformAnimation)
421             return false;
422
423         if (!transition->computeExtentOfTransformAnimation(bounds))
424             return false;
425     }
426     
427     return true;
428 }
429
430 void CompositeAnimation::suspendAnimations()
431 {
432     if (m_suspended)
433         return;
434
435     m_suspended = true;
436
437     if (!m_keyframeAnimations.isEmpty()) {
438         m_keyframeAnimations.checkConsistency();
439         for (auto& animation : m_keyframeAnimations.values())
440             animation->updatePlayState(AnimPlayStatePaused);
441     }
442
443     if (!m_transitions.isEmpty()) {
444         for (auto& transition : m_transitions.values()) {
445             if (transition->hasStyle())
446                 transition->updatePlayState(AnimPlayStatePaused);
447         }
448     }
449 }
450
451 void CompositeAnimation::resumeAnimations()
452 {
453     if (!m_suspended)
454         return;
455
456     m_suspended = false;
457
458     if (!m_keyframeAnimations.isEmpty()) {
459         m_keyframeAnimations.checkConsistency();
460         for (auto& animation : m_keyframeAnimations.values()) {
461             if (animation->playStatePlaying())
462                 animation->updatePlayState(AnimPlayStatePlaying);
463         }
464     }
465
466     if (!m_transitions.isEmpty()) {
467         for (auto& transition : m_transitions.values()) {
468             if (transition->hasStyle())
469                 transition->updatePlayState(AnimPlayStatePlaying);
470         }
471     }
472 }
473
474 void CompositeAnimation::overrideImplicitAnimations(CSSPropertyID property)
475 {
476     if (!m_transitions.isEmpty()) {
477         for (auto& transition : m_transitions.values()) {
478             if (transition->animatingProperty() == property)
479                 transition->setOverridden(true);
480         }
481     }
482 }
483
484 void CompositeAnimation::resumeOverriddenImplicitAnimations(CSSPropertyID property)
485 {
486     if (!m_transitions.isEmpty()) {
487         for (auto& transition : m_transitions.values()) {
488             if (transition->animatingProperty() == property)
489                 transition->setOverridden(false);
490         }
491     }
492 }
493
494 bool CompositeAnimation::isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, AnimationBase::RunningState runningState) const
495 {
496     if (!m_keyframeAnimations.isEmpty()) {
497         m_keyframeAnimations.checkConsistency();
498         for (auto& animation : m_keyframeAnimations.values()) {
499             if (animation->isAnimatingProperty(property, acceleratedOnly, runningState))
500                 return true;
501         }
502     }
503
504     if (!m_transitions.isEmpty()) {
505         for (auto& transition : m_transitions.values()) {
506             if (transition->isAnimatingProperty(property, acceleratedOnly, runningState))
507                 return true;
508         }
509     }
510     return false;
511 }
512
513 bool CompositeAnimation::pauseAnimationAtTime(const AtomicString& name, double t)
514 {
515     m_keyframeAnimations.checkConsistency();
516
517     RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name.impl());
518     if (!keyframeAnim || !keyframeAnim->running())
519         return false;
520
521     double count = keyframeAnim->m_animation->iterationCount();
522     if ((t >= 0.0) && ((count == Animation::IterationCountInfinite) || (t <= count * keyframeAnim->duration()))) {
523         keyframeAnim->freezeAtTime(t);
524         return true;
525     }
526
527     return false;
528 }
529
530 bool CompositeAnimation::pauseTransitionAtTime(CSSPropertyID property, double t)
531 {
532     if ((property < firstCSSProperty) || (property >= firstCSSProperty + numCSSProperties))
533         return false;
534
535     ImplicitAnimation* implAnim = m_transitions.get(property);
536     if (!implAnim) {
537         // Check to see if this property is being animated via a shorthand.
538         // This code is only used for testing, so performance is not critical here.
539         HashSet<CSSPropertyID> shorthandProperties = CSSPropertyAnimation::animatableShorthandsAffectingProperty(property);
540         bool anyPaused = false;
541         for (auto propertyID : shorthandProperties) {
542             if (pauseTransitionAtTime(propertyID, t))
543                 anyPaused = true;
544         }
545         return anyPaused;
546     }
547
548     if (!implAnim->running())
549         return false;
550
551     if ((t >= 0.0) && (t <= implAnim->duration())) {
552         implAnim->freezeAtTime(t);
553         return true;
554     }
555
556     return false;
557 }
558
559 unsigned CompositeAnimation::numberOfActiveAnimations() const
560 {
561     unsigned count = 0;
562     
563     m_keyframeAnimations.checkConsistency();
564     for (auto& animation : m_keyframeAnimations.values()) {
565         if (animation->running())
566             ++count;
567     }
568
569     for (auto& transition : m_transitions.values()) {
570         if (transition->running())
571             ++count;
572     }
573     
574     return count;
575 }
576
577 } // namespace WebCore