Web Animations API: Deferred computation of interpolated values

Source/core/animation/StringKeyframe.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/animation/StringKeyframe.h"
 
 #include "core/animation/Interpolation.h"
+#include "core/animation/LegacyStyleInterpolation.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/rendering/style/RenderStyle.h"
 
 namespace WebCore {
 
 StringKeyframe::StringKeyframe(const StringKeyframe& copyFrom)
     : Keyframe(copyFrom.m_offset, copyFrom.m_composite, copyFrom.m_easing)
     , m_propertySet(copyFrom.m_propertySet->mutableCopy())
 {
@@ skipping 45 matching lines @@
 
 PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::PropertySpecificKeyframe::createInterpolation(CSSPropertyID property, Keyframe::PropertySpecificKeyframe* end, Element* element) const
 {
     CSSValue* fromCSSValue = m_value.get();
     CSSValue* toCSSValue = toStringPropertySpecificKeyframe(end)->value();
 
     if (!CSSAnimations::isAnimatableProperty(property))
         return DefaultStyleInterpolation::create(fromCSSValue, toCSSValue, property);
 
     switch (property) {
+    case CSSPropertyBorderBottomWidth:
+    case CSSPropertyBorderLeftWidth:
+    case CSSPropertyBorderRightWidth:
+    case CSSPropertyBorderTopWidth:

[alancutter (OOO until 2018), 2014/05/08 12:34:13]

The border width properties can change value according to the value of the
current border style.
It's simpler to use LengthStyleInterpolation to be responsive here than to
complicate the late binding detection with this quirk.

+    case CSSPropertyHeight:
     case CSSPropertyLeft:
     case CSSPropertyRight:
     case CSSPropertyWidth:
-    case CSSPropertyHeight:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue))
             return LengthStyleInterpolation::create(fromCSSValue, toCSSValue, property);
         break;
     default:
         break;
     }
 
     // FIXME: Remove the use of AnimatableValues, RenderStyles and Elements here.
     // FIXME: Remove this cache
-    if (!m_animatableValueCache)
-        m_animatableValueCache = StyleResolver::createAnimatableValueSnapshot(*element, property, fromCSSValue);
+    if (!m_interpolableValuePromiseCache)
+        m_interpolableValuePromiseCache = InterpolableValuePromise::create(*element, property, fromCSSValue);
 
-    RefPtrWillBeRawPtr<AnimatableValue> to = StyleResolver::createAnimatableValueSnapshot(*element, property, toCSSValue);
-    toStringPropertySpecificKeyframe(end)->m_animatableValueCache = to;
+    RefPtrWillBeRawPtr<InterpolableValuePromise> to = InterpolableValuePromise::create(*element, property, toCSSValue);
+    toStringPropertySpecificKeyframe(end)->m_interpolableValuePromiseCache = to;
 
-    return LegacyStyleInterpolation::create(m_animatableValueCache.get(), to.release(), property);
+    return LegacyStyleInterpolation::create(m_interpolableValuePromiseCache, to.release(), property);
+}
+
+const PassRefPtrWillBeRawPtr<AnimatableValue> StringKeyframe::PropertySpecificKeyframe::getAnimatableValue() const
+{
+    if (m_interpolableValuePromiseCache)
+        return m_interpolableValuePromiseCache->extractAnimatableValue();
+    return nullptr;
 }
 
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::PropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
     return adoptPtrWillBeNoop(new PropertySpecificKeyframe(offset, easing, 0, AnimationEffect::CompositeAdd));
 }
 
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::PropertySpecificKeyframe::cloneWithOffset(double offset) const
 {
     Keyframe::PropertySpecificKeyframe* theClone = new PropertySpecificKeyframe(offset, m_easing, m_value.get());
-    toStringPropertySpecificKeyframe(theClone)->m_animatableValueCache = m_animatableValueCache;
+    toStringPropertySpecificKeyframe(theClone)->m_interpolableValuePromiseCache = m_interpolableValuePromiseCache;
     return adoptPtrWillBeNoop(theClone);
 }
 
 void StringKeyframe::PropertySpecificKeyframe::trace(Visitor* visitor)
 {
     visitor->trace(m_value);
-    visitor->trace(m_animatableValueCache);
+    visitor->trace(m_interpolableValuePromiseCache);
     Keyframe::PropertySpecificKeyframe::trace(visitor);
 }
 
 }