Web Animations CSS: Record if style recalc is for animation

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 501 matching lines @@
         RefPtr<Player> player = element->document().transitionTimeline()->createPlayer(transition.get());
         player->update();
         element->document().cssPendingAnimations().add(player.get());
         runningTransition.transition = transition.get();
         m_transitions.set(id, runningTransition);
         ASSERT(id != CSSPropertyInvalid);
         blink::Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
     }
 }
 
-void CSSAnimations::calculateTransitionUpdateForProperty(CSSPropertyID id, const CSSAnimationData* anim, const RenderStyle& oldStyle, const RenderStyle& style, const TransitionMap* activeTransitions, CSSAnimationUpdate* update)
+void CSSAnimations::calculateTransitionUpdateForProperty(CSSPropertyID id, const CSSAnimationData* anim, const RenderStyle& oldStyle, const RenderStyle& style, const TransitionMap* activeTransitions, CSSAnimationUpdate* update, const Element* element)
 {
-    if (CSSPropertyAnimation::propertiesEqual(id, &oldStyle, &style))
-        return;
-
-    RefPtr<AnimatableValue> to = CSSAnimatableValueFactory::create(id, style);
-
+    RefPtr<AnimatableValue> to;
     if (activeTransitions) {
         TransitionMap::const_iterator activeTransitionIter = activeTransitions->find(id);
         if (activeTransitionIter != activeTransitions->end()) {
+            to = CSSAnimatableValueFactory::create(id, style);
             const AnimatableValue* activeTo = activeTransitionIter->value.to;
             if (to->equals(activeTo))
                 return;
             update->cancelTransition(id);
+            ASSERT(!element->activeAnimations() || !element->activeAnimations()->isAnimationStyleChange());
         }
     }
+    if (CSSPropertyAnimation::propertiesEqual(id, &oldStyle, &style))
+        return;
+    if (!to)
+        to = CSSAnimatableValueFactory::create(id, style);
 
     RefPtr<AnimatableValue> from = CSSAnimatableValueFactory::create(id, oldStyle);
     // If we have multiple transitions on the same property, we will use the
     // last one since we iterate over them in order.
     if (AnimatableValue::usesDefaultInterpolation(to.get(), from.get()))
         return;
 
     KeyframeAnimationEffect::KeyframeVector keyframes;
 
     RefPtr<Keyframe> startKeyframe = Keyframe::create();
@@ skipping 10 matching lines @@
 
     Timing timing;
     bool isPaused;
     RefPtr<TimingFunction> timingFunction = timingFromAnimationData(anim, timing, isPaused);
     ASSERT(!isPaused);
     timing.timingFunction = timingFunction;
     // Note that the backwards part is required for delay to work.
     timing.fillMode = Timing::FillModeBoth;
 
     update->startTransition(id, from.get(), to.get(), InertAnimation::create(effect, timing, isPaused));
+    ASSERT(!element->activeAnimations() || !element->activeAnimations()->isAnimationStyleChange());
 }
 
 void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate* update, const Element* element, const RenderStyle& style)
 {
     ActiveAnimations* activeAnimations = element->activeAnimations();
     const TransitionMap* activeTransitions = activeAnimations ? &activeAnimations->cssAnimations().m_transitions : 0;
 
+#if ASSERT_DISABLED
+    // In release builds we avoid the cost of checking for new and interrupted transitions if the style recalc is due to animation.
+    const bool animationStyleRecalc = activeAnimations && activeAnimations->isAnimationStyleChange();
+#else
+    // In debug builds we verify that it would have been safe to avoid populating and testing listedProperties if the style recalc is due to animation.
+    const bool animationStyleRecalc = false;
+#endif
+
     BitArray<numCSSProperties> listedProperties;
     bool anyTransitionHadAnimateAll = false;
     const RenderObject* renderer = element->renderer();
-    if (style.display() != NONE && renderer && renderer->style() && style.transitions()) {
+    if (!animationStyleRecalc && style.display() != NONE && renderer && renderer->style() && style.transitions()) {
         const RenderStyle& oldStyle = *renderer->style();
 
         for (size_t i = 0; i < style.transitions()->size(); ++i) {
             const CSSAnimationData* anim = style.transitions()->animation(i);
             CSSAnimationData::AnimationMode mode = anim->animationMode();
             if (anim->duration() + anim->delay() <= 0 || mode == CSSAnimationData::AnimateNone)
                 continue;
 
             bool animateAll = mode == CSSAnimationData::AnimateAll;
             ASSERT(animateAll || mode == CSSAnimationData::AnimateSingleProperty);
             if (animateAll)
                 anyTransitionHadAnimateAll = true;
             const StylePropertyShorthand& propertyList = animateAll ? CSSAnimations::animatableProperties() : shorthandForProperty(anim->property());
             // If not a shorthand we only execute one iteration of this loop, and refer to the property directly.
             for (unsigned j = 0; !j || j < propertyList.length(); ++j) {
                 CSSPropertyID id = propertyList.length() ? propertyList.properties()[j] : anim->property();
 
                 if (!animateAll) {
                     if (CSSAnimations::isAnimatableProperty(id))
                         listedProperties.set(id);
                     else
                         continue;
                 }
 
                 // FIXME: We should transition if an !important property changes even when an animation is running,
                 // but this is a bit hard to do with the current applyMatchedProperties system.
                 if (!update->compositableValuesForAnimations().contains(id)
                     && (!activeAnimations || !activeAnimations->cssAnimations().m_previousCompositableValuesForAnimations.contains(id))) {
-                    calculateTransitionUpdateForProperty(id, anim, oldStyle, style, activeTransitions, update);
+                    calculateTransitionUpdateForProperty(id, anim, oldStyle, style, activeTransitions, update, element);
                 }
             }
         }
     }
 
     if (activeTransitions) {
         for (TransitionMap::const_iterator iter = activeTransitions->begin(); iter != activeTransitions->end(); ++iter) {
             const TimedItem* timedItem = iter->value.transition;
             CSSPropertyID id = iter->key;
-            if (timedItem->phase() == TimedItem::PhaseAfter || (!anyTransitionHadAnimateAll && !listedProperties.get(id)))
+            if (timedItem->phase() == TimedItem::PhaseAfter || (!anyTransitionHadAnimateAll && !animationStyleRecalc && !listedProperties.get(id))) {
+                ASSERT(timedItem->phase() == TimedItem::PhaseAfter || !(activeAnimations && activeAnimations->isAnimationStyleChange()));
                 update->cancelTransition(id);
+            }
         }
     }
 }
 
 void CSSAnimations::cancel()
 {
     for (AnimationMap::iterator iter = m_animations.begin(); iter != m_animations.end(); ++iter) {
         const HashSet<RefPtr<Player> >& players = iter->value;
         for (HashSet<RefPtr<Player> >::const_iterator animationsIter = players.begin(); animationsIter != players.end(); ++animationsIter)
             (*animationsIter)->cancel();
@@ skipping 251 matching lines @@
             CSSPropertyID id = convertToCSSPropertyID(i);
             if (isAnimatableProperty(id))
                 properties.append(id);
         }
         propertyShorthand = StylePropertyShorthand(CSSPropertyInvalid, properties.begin(), properties.size());
     }
     return propertyShorthand;
 }
 
 } // namespace WebCore