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 for property %s duration %.2f delay %.2f", implicitAnimation.get(), 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 for property %s", transition.get(), 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 with keyframes %s, duration %.2f, delay %.2f, iterations %.2f", keyframeAnim.get(), 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", animation.get());
 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