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 Ref<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
 301 {
 302     RefPtr<RenderStyle> resultStyle;
 303
 304     // We don't do any transitions if we don't have a currentStyle (on startup).
 305     updateTransitions(&renderer, currentStyle, &targetStyle);
 306     updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
 307     m_keyframeAnimations.checkConsistency();
 308
 309     if (currentStyle) {
 310         // Now that we have transition objects ready, let them know about the new goal state.  We want them
 311         // to fill in a RenderStyle*& only if needed.
 312         if (!m_transitions.isEmpty()) {
 313             for (auto& transition : m_transitions.values())
 314                 transition->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
 315         }
 316     }
 317
 318     // Now that we have animation objects ready, let them know about the new goal state.  We want them
 319     // to fill in a RenderStyle*& only if needed.
 320     for (auto& name : m_keyframeAnimationOrderMap) {
 321         RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
 322         if (keyframeAnim)
 323             keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
 324     }
 325
 326     if (resultStyle)
 327         return resultStyle.releaseNonNull();
 328
 329     return targetStyle;
 330 }
 331
 332 PassRefPtr<RenderStyle> CompositeAnimation::getAnimatedStyle() const
 333 {
 334     RefPtr<RenderStyle> resultStyle;
 335     for (auto& transition : m_transitions.values())
 336         transition->getAnimatedStyle(resultStyle);
 337
 338     m_keyframeAnimations.checkConsistency();
 339
 340     for (auto& name : m_keyframeAnimationOrderMap) {
 341         RefPtr<KeyframeAnimation> keyframeAnimation = m_keyframeAnimations.get(name);
 342         if (keyframeAnimation)
 343             keyframeAnimation->getAnimatedStyle(resultStyle);
 344     }
 345
 346     return resultStyle;
 347 }
 348
 349 double CompositeAnimation::timeToNextService() const
 350 {
 351     // Returns the time at which next service is required. -1 means no service is required. 0 means
 352     // service is required now, and > 0 means service is required that many seconds in the future.
 353     double minT = -1;
 354
 355     if (!m_transitions.isEmpty()) {
 356         for (auto& transition : m_transitions.values()) {
 357             double t = transition->timeToNextService();
 358             if (t < minT || minT == -1)
 359                 minT = t;
 360             if (minT == 0)
 361                 return 0;
 362         }
 363     }
 364     if (!m_keyframeAnimations.isEmpty()) {
 365         m_keyframeAnimations.checkConsistency();
 366         for (auto& animation : m_keyframeAnimations.values()) {
 367             double t = animation->timeToNextService();
 368             if (t < minT || minT == -1)
 369                 minT = t;
 370             if (minT == 0)
 371                 return 0;
 372         }
 373     }
 374
 375     return minT;
 376 }
 377
 378 PassRefPtr<KeyframeAnimation> CompositeAnimation::getAnimationForProperty(CSSPropertyID property) const
 379 {
 380     RefPtr<KeyframeAnimation> retval;
 381
 382     // We want to send back the last animation with the property if there are multiples.
 383     // So we need to iterate through all animations
 384     if (!m_keyframeAnimations.isEmpty()) {
 385         m_keyframeAnimations.checkConsistency();
 386         for (auto& animation : m_keyframeAnimations.values()) {
 387             if (animation->hasAnimationForProperty(property))
 388                 retval = animation;
 389         }
 390     }
 391
 392     return retval;
 393 }
 394
 395 bool CompositeAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const
 396 {
 397     // If more than one transition and animation affect transform, give up.
 398     bool seenTransformAnimation = false;
 399
 400     for (auto& animation : m_keyframeAnimations.values()) {
 401         if (!animation->hasAnimationForProperty(CSSPropertyTransform))
 402             continue;
 403
 404         if (seenTransformAnimation)
 405             return false;
 406
 407         seenTransformAnimation = true;
 408
 409         if (!animation->computeExtentOfTransformAnimation(bounds))
 410             return false;
 411     }
 412
 413     for (auto& transition : m_transitions.values()) {
 414         if (transition->animatingProperty() != CSSPropertyTransform || !transition->hasStyle())
 415             continue;
 416
 417         if (seenTransformAnimation)
 418             return false;
 419
 420         if (!transition->computeExtentOfTransformAnimation(bounds))
 421             return false;
 422     }
 423
 424     return true;
 425 }
 426
 427 void CompositeAnimation::suspendAnimations()
 428 {
 429     if (m_suspended)
 430         return;
 431
 432     m_suspended = true;
 433
 434     if (!m_keyframeAnimations.isEmpty()) {
 435         m_keyframeAnimations.checkConsistency();
 436         for (auto& animation : m_keyframeAnimations.values())
 437             animation->updatePlayState(AnimPlayStatePaused);
 438     }
 439
 440     if (!m_transitions.isEmpty()) {
 441         for (auto& transition : m_transitions.values()) {
 442             if (transition->hasStyle())
 443                 transition->updatePlayState(AnimPlayStatePaused);
 444         }
 445     }
 446 }
 447
 448 void CompositeAnimation::resumeAnimations()
 449 {
 450     if (!m_suspended)
 451         return;
 452
 453     m_suspended = false;
 454
 455     if (!m_keyframeAnimations.isEmpty()) {
 456         m_keyframeAnimations.checkConsistency();
 457         for (auto& animation : m_keyframeAnimations.values()) {
 458             if (animation->playStatePlaying())
 459                 animation->updatePlayState(AnimPlayStatePlaying);
 460         }
 461     }
 462
 463     if (!m_transitions.isEmpty()) {
 464         for (auto& transition : m_transitions.values()) {
 465             if (transition->hasStyle())
 466                 transition->updatePlayState(AnimPlayStatePlaying);
 467         }
 468     }
 469 }
 470
 471 void CompositeAnimation::overrideImplicitAnimations(CSSPropertyID property)
 472 {
 473     if (!m_transitions.isEmpty()) {
 474         for (auto& transition : m_transitions.values()) {
 475             if (transition->animatingProperty() == property)
 476                 transition->setOverridden(true);
 477         }
 478     }
 479 }
 480
 481 void CompositeAnimation::resumeOverriddenImplicitAnimations(CSSPropertyID property)
 482 {
 483     if (!m_transitions.isEmpty()) {
 484         for (auto& transition : m_transitions.values()) {
 485             if (transition->animatingProperty() == property)
 486                 transition->setOverridden(false);
 487         }
 488     }
 489 }
 490
 491 bool CompositeAnimation::isAnimatingProperty(CSSPropertyID property, bool acceleratedOnly, AnimationBase::RunningState runningState) const
 492 {
 493     if (!m_keyframeAnimations.isEmpty()) {
 494         m_keyframeAnimations.checkConsistency();
 495         for (auto& animation : m_keyframeAnimations.values()) {
 496             if (animation->isAnimatingProperty(property, acceleratedOnly, runningState))
 497                 return true;
 498         }
 499     }
 500
 501     if (!m_transitions.isEmpty()) {
 502         for (auto& transition : m_transitions.values()) {
 503             if (transition->isAnimatingProperty(property, acceleratedOnly, runningState))
 504                 return true;
 505         }
 506     }
 507     return false;
 508 }
 509
 510 bool CompositeAnimation::pauseAnimationAtTime(const AtomicString& name, double t)
 511 {
 512     m_keyframeAnimations.checkConsistency();
 513
 514     RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name.impl());
 515     if (!keyframeAnim || !keyframeAnim->running())
 516         return false;
 517
 518     double count = keyframeAnim->m_animation->iterationCount();
 519     if ((t >= 0.0) && ((count == Animation::IterationCountInfinite) || (t <= count * keyframeAnim->duration()))) {
 520         keyframeAnim->freezeAtTime(t);
 521         return true;
 522     }
 523
 524     return false;
 525 }
 526
 527 bool CompositeAnimation::pauseTransitionAtTime(CSSPropertyID property, double t)
 528 {
 529     if ((property < firstCSSProperty) || (property >= firstCSSProperty + numCSSProperties))
 530         return false;
 531
 532     ImplicitAnimation* implAnim = m_transitions.get(property);
 533     if (!implAnim) {
 534         // Check to see if this property is being animated via a shorthand.
 535         // This code is only used for testing, so performance is not critical here.
 536         HashSet<CSSPropertyID> shorthandProperties = CSSPropertyAnimation::animatableShorthandsAffectingProperty(property);
 537         bool anyPaused = false;
 538         for (auto propertyID : shorthandProperties) {
 539             if (pauseTransitionAtTime(propertyID, t))
 540                 anyPaused = true;
 541         }
 542         return anyPaused;
 543     }
 544
 545     if (!implAnim->running())
 546         return false;
 547
 548     if ((t >= 0.0) && (t <= implAnim->duration())) {
 549         implAnim->freezeAtTime(t);
 550         return true;
 551     }
 552
 553     return false;
 554 }
 555
 556 unsigned CompositeAnimation::numberOfActiveAnimations() const
 557 {
 558     unsigned count = 0;
 559
 560     m_keyframeAnimations.checkConsistency();
 561     for (auto& animation : m_keyframeAnimations.values()) {
 562         if (animation->running())
 563             ++count;
 564     }
 565
 566     for (auto& transition : m_transitions.values()) {
 567         if (transition->running())
 568             ++count;
 569     }
 570
 571     return count;
 572 }
 573
 574 } // namespace WebCore