Prepare for responsive CSS animations.

Source/core/animation/KeyframeEffectModel.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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/animation/KeyframeEffectModel.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/AnimationNode.h"
+#include "core/animation/CompositorAnimations.h"
+#include "core/animation/css/CSSAnimatableValueFactory.h"
+#include "core/animation/css/CSSPropertyEquality.h"
+#include "core/css/resolver/StyleResolver.h"
 #include "platform/animation/AnimationUtilities.h"
 #include "platform/geometry/FloatBox.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "wtf/text/StringHash.h"
 
 namespace blink {
 
 PropertySet KeyframeEffectModelBase::properties() const
 {
     PropertySet result;
     for (const auto& keyframe : m_keyframes) {
         for (const auto& property : keyframe->properties())
             result.add(property);
     }
     return result;
 }
 
 void KeyframeEffectModelBase::sample(int iteration, double fraction, double iterationDuration, OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<Interpolation>>>& result) const
 {
     ASSERT(iteration >= 0);
     ASSERT(!isNull(fraction));
     ensureKeyframeGroups();
     ensureInterpolationEffect();
 
     return m_interpolationEffect->getActiveInterpolations(fraction, iterationDuration, result);
 }
 
+void KeyframeEffectModelBase::snapshotCompositableProperties(const Element* element, const LayoutStyle& style)
+{
+    ASSERT(isStringKeyframeEffectModel());
+
+    ensureKeyframeGroups();
+    for (CSSPropertyID property : CompositorAnimations::CompositableProperties) {
+        if (affects(property)) {
+            for (auto& keyframe : m_keyframeGroups->get(property)->m_keyframes) {
+                auto& stringKeyframe = toStringPropertySpecificKeyframe(*keyframe);
+                if (!stringKeyframe.value()) {
+                    stringKeyframe.setAnimatableValue(CSSAnimatableValueFactory::create(property, style));
+                } else {
+                    ASSERT(!stringKeyframe.getAnimatableValue());
+                    stringKeyframe.setAnimatableValue(StyleResolver::createAnimatableValueSnapshot(const_cast<Element&>(*element), property, *stringKeyframe.value()));
+                }
+            }
+        }
+    }
+}
+
+void KeyframeEffectModelBase::updateNeutralKeyframeAnimatableValues(CSSPropertyID property, PassRefPtrWillBeRawPtr<AnimatableValue> value)
+{
+    ASSERT(CompositorAnimations::isCompositableProperty(property));
+
+    if (!value)
+        return;
+
+    ensureKeyframeGroups();
+    auto& keyframes = m_keyframeGroups->get(property)->m_keyframes;
+
+    ASSERT(keyframes.size() >= 2);
+    ASSERT(!toStringPropertySpecificKeyframe(*keyframes[0]).value() || !toStringPropertySpecificKeyframe(*keyframes[keyframes.size() - 1]).value());
+
+    if (!toStringPropertySpecificKeyframe(*keyframes.first()).value())
+        toStringPropertySpecificKeyframe(*keyframes.first()).setAnimatableValue(value);
+    if (!toStringPropertySpecificKeyframe(*keyframes.last()).value())
+        toStringPropertySpecificKeyframe(*keyframes.last()).setAnimatableValue(value);
+
+    // FIXME: Handle neutral keyframes that are not at 0% or 100%.

[dstockwell, 2015/02/18 02:27:03]

Just ASSERT this, should not happen.

+}
+
 KeyframeEffectModelBase::KeyframeVector KeyframeEffectModelBase::normalizedKeyframes(const KeyframeVector& keyframes)
 {
     double lastOffset = 0;
     KeyframeVector result;
     result.reserveCapacity(keyframes.size());
 
     for (const auto& keyframe : keyframes) {
         double offset = keyframe->offset();
         if (!isNull(offset)) {
             ASSERT(offset >= 0);
@@ skipping 45 matching lines @@
             else
                 group = groupIter->value.get();
 
             group->appendKeyframe(keyframe->createPropertySpecificKeyframe(property));
         }
     }
 
     // Add synthetic keyframes.
     m_hasSyntheticKeyframes = false;
     for (const auto& entry : *m_keyframeGroups) {
-        if (entry.value->addSyntheticKeyframeIfRequired())
+        if (entry.value->addSyntheticKeyframeIfRequired(m_neutralKeyframeEasing))
             m_hasSyntheticKeyframes = true;
 
         entry.value->removeRedundantKeyframes();
     }
 }
 
 void KeyframeEffectModelBase::ensureInterpolationEffect(Element* element) const
 {
     if (m_interpolationEffect)
         return;
     m_interpolationEffect = InterpolationEffect::create();
 
     for (const auto& entry : *m_keyframeGroups) {
         const PropertySpecificKeyframeVector& keyframes = entry.value->keyframes();
-        ASSERT(keyframes[0]->composite() == AnimationEffect::CompositeReplace);
         for (size_t i = 0; i < keyframes.size() - 1; i++) {
-            ASSERT(keyframes[i + 1]->composite() == AnimationEffect::CompositeReplace);
             double applyFrom = i ? keyframes[i]->offset() : (-std::numeric_limits<double>::infinity());
             double applyTo = i == keyframes.size() - 2 ? std::numeric_limits<double>::infinity() : keyframes[i + 1]->offset();
             if (applyTo == 1)
                 applyTo = std::numeric_limits<double>::infinity();
 
             m_interpolationEffect->addInterpolationsFromKeyframes(entry.key, element, *keyframes[i], *keyframes[i + 1], applyFrom, applyTo);
         }
     }
 }
 
@@ skipping 44 matching lines @@
     for (int i = m_keyframes.size() - 1; i >= 0; --i) {
         double offset = m_keyframes[i]->offset();
         bool hasSameOffsetAsPreviousNeighbor = !i || m_keyframes[i - 1]->offset() == offset;
         bool hasSameOffsetAsNextNeighbor = i == static_cast<int>(m_keyframes.size() - 1) || m_keyframes[i + 1]->offset() == offset;
         if (hasSameOffsetAsPreviousNeighbor && hasSameOffsetAsNextNeighbor)
             m_keyframes.remove(i);
     }
     ASSERT(m_keyframes.size() >= 2);
 }
 
-bool KeyframeEffectModelBase::PropertySpecificKeyframeGroup::addSyntheticKeyframeIfRequired()
+bool KeyframeEffectModelBase::PropertySpecificKeyframeGroup::addSyntheticKeyframeIfRequired(PassRefPtrWillBeRawPtr<TimingFunction> easing)
 {
     ASSERT(!m_keyframes.isEmpty());
 
     bool addedSyntheticKeyframe = false;
 
     if (m_keyframes.first()->offset() != 0.0) {
-        m_keyframes.insert(0, m_keyframes.first()->neutralKeyframe(0, nullptr));
+        m_keyframes.insert(0, m_keyframes.first()->neutralKeyframe(0, easing));
         addedSyntheticKeyframe = true;
     }
     if (m_keyframes.last()->offset() != 1.0) {
-        appendKeyframe(m_keyframes.last()->neutralKeyframe(1, nullptr));
+        appendKeyframe(m_keyframes.last()->neutralKeyframe(1, easing));
         addedSyntheticKeyframe = true;
     }
 
     return addedSyntheticKeyframe;
 }
 
 void KeyframeEffectModelBase::PropertySpecificKeyframeGroup::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_keyframes);
 #endif
 }
 
 } // namespace