Defer compositor keyframe snapshots until the next style resolve

third_party/WebKit/Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/css/CSSAnimations.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/ElementAnimations.h"
+#include "core/animation/InertEffect.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/LegacyStyleInterpolation.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSPropertyEquality.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/CSSToStyleMap.h"
 #include "core/css/resolver/StyleResolver.h"
@@ skipping 119 matching lines @@
             bool startNeedsValue = missingStartValues && !startKeyframeProperties.contains(PropertyHandle(property));
             bool endNeedsValue = missingEndValues && !endKeyframeProperties.contains(PropertyHandle(property));
             if (!startNeedsValue && !endNeedsValue)
                 continue;
             if (CompositorAnimations::isCompositableProperty(property))
                 UseCounter::count(elementForScoping->document(), UseCounter::SyntheticKeyframesInCompositedCSSAnimation);
         }
     }
 
     StringKeyframeEffectModel* model = StringKeyframeEffectModel::create(keyframes, &keyframes[0]->easing());
-    model->forceConversionsToAnimatableValues(element, style);
     if (animationIndex > 0 && model->hasSyntheticKeyframes())
         UseCounter::count(elementForScoping->document(), UseCounter::CSSAnimationsStackedNeutralKeyframe);
     return model;
 }
 
 } // namespace
 
 CSSAnimations::CSSAnimations()
 {
 }
@@ skipping 11 matching lines @@
 {
     for (const auto& it : m_transitions) {
         if (it.value.animation->sequenceNumber() == animation.sequenceNumber())
             return true;
     }
     return false;
 }
 
 void CSSAnimations::calculateUpdate(const Element* animatingElement, Element& element, const ComputedStyle& style, ComputedStyle* parentStyle, CSSAnimationUpdate& animationUpdate, StyleResolver* resolver)
 {
-    calculateCompositorAnimationUpdate(animationUpdate, animatingElement, element, style);
+    calculateCompositorAnimationUpdate(animationUpdate, animatingElement, element, style, parentStyle);
     calculateAnimationUpdate(animationUpdate, animatingElement, element, style, parentStyle, resolver);
     calculateAnimationActiveInterpolations(animationUpdate, animatingElement);
     calculateTransitionUpdate(animationUpdate, animatingElement, style);
     calculateTransitionActiveInterpolations(animationUpdate, animatingElement);
 }
 
-void CSSAnimations::calculateCompositorAnimationUpdate(CSSAnimationUpdate& update, const Element* animatingElement, Element& element, const ComputedStyle& style)
+static const KeyframeEffectModelBase* getKeyframeEffectModelBase(const AnimationEffect* effect)
+{
+    if (!effect)
+        return nullptr;
+    const EffectModel* model = nullptr;
+    if (effect->isKeyframeEffect())
+        model = toKeyframeEffect(effect)->model();
+    else if (effect->isInertEffect())
+        model = toInertEffect(effect)->model();
+    if (!model || !model->isKeyframeEffectModel())
+        return nullptr;
+    return toKeyframeEffectModelBase(model);
+}
+
+void CSSAnimations::calculateCompositorAnimationUpdate(CSSAnimationUpdate& update, const Element* animatingElement, Element& element, const ComputedStyle& style, const ComputedStyle* parentStyle)
 {
     ElementAnimations* elementAnimations = animatingElement ? animatingElement->elementAnimations() : nullptr;
 
     // We only update compositor animations in response to changes in the base style.
     if (!elementAnimations || elementAnimations->isAnimationStyleChange())
         return;
 
     if (!animatingElement->layoutObject() || !animatingElement->layoutObject()->style())
         return;
 
     const ComputedStyle& oldStyle = *animatingElement->layoutObject()->style();
     if (!oldStyle.shouldCompositeForCurrentAnimations())
         return;
 
     bool transformZoomChanged = oldStyle.hasCurrentTransformAnimation() && oldStyle.effectiveZoom() != style.effectiveZoom();
     for (auto& entry : elementAnimations->animations()) {
         Animation& animation = *entry.key;
-        if (!animation.effect() || !animation.effect()->isKeyframeEffect())
+        const KeyframeEffectModelBase* keyframeEffect = getKeyframeEffectModelBase(animation.effect());
+        if (!keyframeEffect)
             continue;
-        EffectModel* model = toKeyframeEffect(animation.effect())->model();
-        if (!model || !model->isKeyframeEffectModel())
-            continue;
-        KeyframeEffectModelBase& keyframeEffect = toKeyframeEffectModelBase(*model);
 
         bool updateCompositorKeyframes = false;
-        if (transformZoomChanged && keyframeEffect.affects(PropertyHandle(CSSPropertyTransform))
-            && keyframeEffect.snapshotAllCompositorKeyframes(element, &style)) {
+        if (transformZoomChanged && keyframeEffect->affects(PropertyHandle(CSSPropertyTransform))
+            && keyframeEffect->snapshotAllCompositorKeyframes(element, style, parentStyle)) {
             updateCompositorKeyframes = true;
-        } else if (keyframeEffect.hasSyntheticKeyframes()
-            && keyframeEffect.snapshotNeutralCompositorKeyframes(element, oldStyle, style)) {
+        } else if (keyframeEffect->hasSyntheticKeyframes()
+            && keyframeEffect->snapshotNeutralCompositorKeyframes(element, oldStyle, style, parentStyle)) {
             updateCompositorKeyframes = true;
         }
 
         if (updateCompositorKeyframes)
             update.updateCompositorKeyframes(&animation);
     }
 }
 
 void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate& update, const Element* animatingElement, Element& element, const ComputedStyle& style, ComputedStyle* parentStyle, StyleResolver* resolver)
 {
@@ skipping 83 matching lines @@
     }
 
     for (size_t i = 0; i < cancelRunningAnimationFlags.size(); i++) {
         if (cancelRunningAnimationFlags[i]) {
             ASSERT(cssAnimations && !isAnimationStyleChange);
             update.cancelAnimation(i, *cssAnimations->m_runningAnimations[i]->animation);
         }
     }
 }
 
+void CSSAnimations::snapshotCompositorKeyframes(Element& element, CSSAnimationUpdate& update, const ComputedStyle& style, const ComputedStyle* parentStyle)
+{
+    const auto& snapshot = [&element, &style, parentStyle](const AnimationEffect* effect)
+    {
+        const KeyframeEffectModelBase* keyframeEffect = getKeyframeEffectModelBase(effect);
+        if (keyframeEffect && keyframeEffect->needsCompositorKeyframesSnapshot())
+            keyframeEffect->snapshotAllCompositorKeyframes(element, style, parentStyle);
+    };
+
+    ElementAnimations* elementAnimations = element.elementAnimations();
+    if (elementAnimations) {
+        for (auto& entry : elementAnimations->animations())
+            snapshot(entry.key->effect());
+    }
+
+    for (const auto& newAnimation : update.newAnimations())
+        snapshot(newAnimation.effect.get());
+
+    for (const auto& updatedAnimation : update.animationsWithUpdates())
+        snapshot(updatedAnimation.effect.get());
+
+    for (const auto& newTransition : update.newTransitions())
+        snapshot(newTransition.value.effect.get());
+}
+
 void CSSAnimations::maybeApplyPendingUpdate(Element* element)
 {
     m_previousActiveInterpolationsForAnimations.clear();
     if (m_pendingUpdate.isEmpty())
         return;
 
     m_previousActiveInterpolationsForAnimations.swap(m_pendingUpdate.activeInterpolationsForAnimations());
 
     // FIXME: cancelling, pausing, unpausing animations all query compositingState, which is not necessarily up to date here
     // since we call this from recalc style.
@@ skipping 501 matching lines @@
 }
 
 DEFINE_TRACE(CSSAnimations)
 {
     visitor->trace(m_transitions);
     visitor->trace(m_pendingUpdate);
     visitor->trace(m_runningAnimations);
 }
 
 } // namespace blink