Prepare for responsive CSS animations.

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 25 matching lines @@
 #include "core/animation/AnimationPlayer.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/LegacyStyleInterpolation.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSPropertyEquality.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSPropertyMetadata.h"
+#include "core/css/RenderStyleCSSValueMapping.h"
 #include "core/css/resolver/CSSToStyleMap.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Element.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/StyleEngine.h"
 #include "core/events/TransitionEvent.h"
 #include "core/events/WebKitAnimationEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderObject.h"
@@ skipping 23 matching lines @@
     case CSSPropertyWebkitTransformOriginZ:
     case CSSPropertyWebkitTransformOrigin:
         return CSSPropertyTransformOrigin;
     default:
         break;
     }
     return property;
 }
 
 static void resolveKeyframes(StyleResolver* resolver, const Element* animatingElement, Element& element, const RenderStyle& style, RenderStyle* parentStyle, const AtomicString& name, TimingFunction* defaultTimingFunction,
-    AnimatableValueKeyframeVector& keyframes)
+    StringKeyframeVector& keyframes)
 {
     // When the animating element is null, use its parent for scoping purposes.
     const Element* elementForScoping = animatingElement ? animatingElement : &element;
     const StyleRuleKeyframes* keyframesRule = resolver->findKeyframesRule(elementForScoping, name);
     if (!keyframesRule)
         return;
 
     const WillBeHeapVector<RefPtrWillBeMember<StyleRuleKeyframe>>& styleKeyframes = keyframesRule->keyframes();
 
     // Construct and populate the style for each keyframe
     PropertySet specifiedPropertiesForUseCounter;
     for (size_t i = 0; i < styleKeyframes.size(); ++i) {
         const StyleRuleKeyframe* styleKeyframe = styleKeyframes[i].get();
         RefPtr<RenderStyle> keyframeStyle = resolver->styleForKeyframe(element, style, parentStyle, styleKeyframe, name);
-        RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframe = AnimatableValueKeyframe::create();
+        RefPtrWillBeRawPtr<StringKeyframe> keyframe = StringKeyframe::create();
         const Vector<double>& offsets = styleKeyframe->keys();
         ASSERT(!offsets.isEmpty());
         keyframe->setOffset(offsets[0]);
         keyframe->setEasing(defaultTimingFunction);
         const StylePropertySet& properties = styleKeyframe->properties();
         for (unsigned j = 0; j < properties.propertyCount(); j++) {
             specifiedPropertiesForUseCounter.add(properties.propertyAt(j).id());
             CSSPropertyID property = propertyForAnimation(properties.propertyAt(j).id());
             if (property == CSSPropertyWebkitAnimationTimingFunction || property == CSSPropertyAnimationTimingFunction) {
                 CSSValue* value = properties.propertyAt(j).value();
                 RefPtr<TimingFunction> timingFunction;
                 if (value->isInheritedValue() && parentStyle->animations()) {
                     timingFunction = parentStyle->animations()->timingFunctionList()[0];
                 } else if (value->isValueList()) {
                     timingFunction = CSSToStyleMap::mapAnimationTimingFunction(toCSSValueList(value)->item(0));
                 } else {
                     ASSERT(value->isInheritedValue() || value->isInitialValue() || value->isUnsetValue());
                     timingFunction = CSSTimingData::initialTimingFunction();
                 }
                 keyframe->setEasing(timingFunction.release());
             } else if (CSSPropertyMetadata::isAnimatableProperty(property)) {
-                keyframe->setPropertyValue(property, CSSAnimatableValueFactory::create(property, *keyframeStyle).get());
+                keyframe->setPropertyValue(property, properties.propertyAt(j).value());
+                if (property == CSSPropertyOpacity || property == CSSPropertyTransform)
+                    keyframe->setPropertyAnimatableValue(property, CSSAnimatableValueFactory::create(property, *keyframeStyle));
             }
         }
         keyframes.append(keyframe);
         // The last keyframe specified at a given offset is used.
         for (size_t j = 1; j < offsets.size(); ++j) {
-            keyframes.append(toAnimatableValueKeyframe(keyframe->cloneWithOffset(offsets[j]).get()));
+            keyframes.append(toStringKeyframe(keyframe->cloneWithOffset(offsets[j]).get()));
         }
     }
 
     for (CSSPropertyID property : specifiedPropertiesForUseCounter) {
         ASSERT(property != CSSPropertyInvalid);
         blink::Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(property));
     }
 
     // Merge duplicate keyframes.
     std::stable_sort(keyframes.begin(), keyframes.end(), Keyframe::compareOffsets);
     size_t targetIndex = 0;
     for (size_t i = 1; i < keyframes.size(); i++) {
         if (keyframes[i]->offset() == keyframes[targetIndex]->offset()) {
             for (CSSPropertyID property : keyframes[i]->properties())
                 keyframes[targetIndex]->setPropertyValue(property, keyframes[i]->propertyValue(property));
         } else {
             targetIndex++;
             keyframes[targetIndex] = keyframes[i];
         }
     }
     if (!keyframes.isEmpty())
         keyframes.shrink(targetIndex + 1);
 
     // Add 0% and 100% keyframes if absent.
-    RefPtrWillBeRawPtr<AnimatableValueKeyframe> startKeyframe = keyframes.isEmpty() ? nullptr : keyframes[0];
+    RefPtrWillBeRawPtr<StringKeyframe> startKeyframe = keyframes.isEmpty() ? nullptr : keyframes[0];
     if (!startKeyframe || keyframes[0]->offset() != 0) {
-        startKeyframe = AnimatableValueKeyframe::create();
+        startKeyframe = StringKeyframe::create();
         startKeyframe->setOffset(0);
         startKeyframe->setEasing(defaultTimingFunction);
         keyframes.prepend(startKeyframe);
     }
-    RefPtrWillBeRawPtr<AnimatableValueKeyframe> endKeyframe = keyframes[keyframes.size() - 1];
+    RefPtrWillBeRawPtr<StringKeyframe> endKeyframe = keyframes[keyframes.size() - 1];
     if (endKeyframe->offset() != 1) {
-        endKeyframe = AnimatableValueKeyframe::create();
+        endKeyframe = StringKeyframe::create();
         endKeyframe->setOffset(1);
         endKeyframe->setEasing(defaultTimingFunction);
         keyframes.append(endKeyframe);
     }
     ASSERT(keyframes.size() >= 2);
     ASSERT(!keyframes.first()->offset());
     ASSERT(keyframes.last()->offset() == 1);
 
-    // Snapshot current property values for 0% and 100% if missing.
+    // Explicitly create neutral keyframes for 0% and 100% if missing.
+    // FIXME: Remove this once neutral keyframes are implemented in StringKeyframes.
     PropertySet allProperties;
     for (const auto& keyframe : keyframes) {
         for (CSSPropertyID property : keyframe->properties())
             allProperties.add(property);
     }
     const PropertySet& startKeyframeProperties = startKeyframe->properties();
     const PropertySet& endKeyframeProperties = endKeyframe->properties();
     bool missingStartValues = startKeyframeProperties.size() < allProperties.size();
     bool missingEndValues = endKeyframeProperties.size() < allProperties.size();
     if (missingStartValues || missingEndValues) {
         for (CSSPropertyID property : allProperties) {
             bool startNeedsValue = missingStartValues && !startKeyframeProperties.contains(property);
             bool endNeedsValue = missingEndValues && !endKeyframeProperties.contains(property);
             if (!startNeedsValue && !endNeedsValue)
                 continue;
-            RefPtrWillBeRawPtr<AnimatableValue> snapshotValue = CSSAnimatableValueFactory::create(property, style);
-            if (startNeedsValue)
-                startKeyframe->setPropertyValue(property, snapshotValue.get());
-            if (endNeedsValue)
-                endKeyframe->setPropertyValue(property, snapshotValue.get());
-            if (property == CSSPropertyOpacity || property == CSSPropertyTransform)
+
+            bool isCompositableProperty = property == CSSPropertyOpacity || property == CSSPropertyTransform;
+
+            if (startNeedsValue) {
+                startKeyframe->setPropertyValue(property, nullptr);
+                if (isCompositableProperty)
+                    startKeyframe->setPropertyAnimatableValue(property, CSSAnimatableValueFactory::create(property, style));
+            }
+
+            if (endNeedsValue) {
+                endKeyframe->setPropertyValue(property, nullptr);
+                if (isCompositableProperty)
+                    endKeyframe->setPropertyAnimatableValue(property, CSSAnimatableValueFactory::create(property, style));
+            }
+
+            if (isCompositableProperty)
                 UseCounter::count(elementForScoping->document(), UseCounter::SyntheticKeyframesInCompositedCSSAnimation);
         }
     }
     ASSERT(startKeyframe->properties().size() == allProperties.size());
     ASSERT(endKeyframe->properties().size() == allProperties.size());
 }
 
 } // namespace
 
 CSSAnimations::CSSAnimations()
@@ skipping 51 matching lines @@
             RefPtr<TimingFunction> keyframeTimingFunction = timing.timingFunction;
             timing.timingFunction = Timing::defaults().timingFunction;
 
             if (cssAnimations) {
                 AnimationMap::const_iterator existing(cssAnimations->m_animations.find(animationName));
                 if (existing != cssAnimations->m_animations.end()) {
                     inactive.remove(animationName);
 
                     AnimationPlayer* player = existing->value.get();
 
+                    if (!activeAnimations || !activeAnimations->isAnimationStyleChange()) {

[Timothy Loh, 2015/01/20 05:29:32]

We refer to this so many times now, can we just put a boolean
isAnimationStyleChange at the top of the function? :)

[shend, 2015/01/20 23:13:03]

Done.

+                        if (player->source()->isAnimation()) {

[Timothy Loh, 2015/01/20 05:29:32]

Is this check is because players for CSS animations can be modified by the web
animations API?

[shend, 2015/01/20 23:13:03]

:)

+                            Animation* animation = toAnimation(player->source());

[Timothy Loh, 2015/01/20 05:29:32]

Just store the effect here?

[shend, 2015/01/20 23:13:03]

Done.

+                            if (animation->effect() && animation->effect()->isKeyframeEffectModel()) {
+                                toKeyframeEffectModelBase(animation->effect())->setDeferredInterpolationsOutdated(true);
+                            }
+                        }
+                    }
+
                     // FIXME: Should handle changes in the timing function.
                     if (timing != player->source()->specifiedTiming()) {
                         ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
 
-                        AnimatableValueKeyframeVector resolvedKeyframes;
+                        StringKeyframeVector resolvedKeyframes;
                         resolveKeyframes(resolver, animatingElement, element, style, parentStyle, animationName, keyframeTimingFunction.get(), resolvedKeyframes);
 
-                        update->updateAnimationTiming(player, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes),
-                            timing, isPaused, player->currentTimeInternal()), timing);
+                        auto effect = StringKeyframeEffectModel::create(resolvedKeyframes);
+                        effect->forceConversionsToAnimatableValues(&element); // FIXME: remove this once LegacyStyleInterpolation is removed from StringKeyframe
+                        update->updateAnimationTiming(player, InertAnimation::create(effect, timing, isPaused, player->currentTimeInternal()), timing);
                     }
 
                     if (isPaused != player->paused()) {
                         ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
                         update->toggleAnimationPaused(animationName);
                     }
 
                     continue;
                 }
             }
 
-            AnimatableValueKeyframeVector resolvedKeyframes;
+            StringKeyframeVector resolvedKeyframes;
             resolveKeyframes(resolver, animatingElement, element, style, parentStyle, animationName, keyframeTimingFunction.get(), resolvedKeyframes);
             if (!resolvedKeyframes.isEmpty()) {
                 ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
-                update->startAnimation(animationName, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes), timing, isPaused, 0));
+                auto effect = StringKeyframeEffectModel::create(resolvedKeyframes);
+                effect->forceConversionsToAnimatableValues(&element); // FIXME: remove this once LegacyStyleInterpolation is removed from StringKeyframe
+                update->startAnimation(animationName, InertAnimation::create(effect, timing, isPaused, 0));
             }
         }
     }
 
     ASSERT(inactive.isEmpty() || cssAnimations);
     for (const AtomicString& animationName : inactive) {
         ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
         update->cancelAnimation(animationName, *cssAnimations->m_animations.get(animationName));
     }
 }
@@ skipping 447 matching lines @@
     visitor->trace(m_newTransitions);
     visitor->trace(m_activeInterpolationsForAnimations);
     visitor->trace(m_activeInterpolationsForTransitions);
     visitor->trace(m_newAnimations);
     visitor->trace(m_suppressedAnimationPlayers);
     visitor->trace(m_animationsWithTimingUpdates);
 #endif
 }
 
 } // namespace blink