WIP: Implement CSS transitions on top of InterpolationTypes instead of AnimatableValues

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 19 matching lines @@
 
 #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/InterpolationEnvironment.h"
+#include "core/animation/InterpolationType.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/LegacyStyleInterpolation.h"
+#include "core/animation/PairwiseInterpolationValue.h"
+#include "core/animation/PrimitiveInterpolation.h"
+#include "core/animation/PropertyInterpolationTypesMapping.h"
+#include "core/animation/TransitionEffectModel.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"
 #include "core/dom/Element.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/StyleEngine.h"
@@ skipping 478 matching lines @@
     clearPendingUpdate();
 }
 
 void CSSAnimations::calculateTransitionUpdateForProperty(CSSPropertyID id, const CSSTransitionData& transitionData, size_t transitionIndex, const ComputedStyle& oldStyle, const ComputedStyle& style, const TransitionMap* activeTransitions, CSSAnimationUpdate& update, const Element* element)
 {
     RefPtr<AnimatableValue> to = nullptr;
     const RunningTransition* interruptedTransition = nullptr;
     if (activeTransitions) {
         TransitionMap::const_iterator activeTransitionIter = activeTransitions->find(id);
         if (activeTransitionIter != activeTransitions->end()) {
-            const RunningTransition* runningTransition = &activeTransitionIter->value;
+            const RunningTransition& runningTransition = activeTransitionIter->value;
             to = CSSAnimatableValueFactory::create(id, style);
-            const AnimatableValue* activeTo = runningTransition->to;
-            if (to->equals(activeTo))
+            if (to->equals(runningTransition.to.get()))
                 return;
             update.cancelTransition(id);
             ASSERT(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
 
-            if (to->equals(runningTransition->reversingAdjustedStartValue.get()))
-                interruptedTransition = runningTransition;
+            if (to->equals(runningTransition.reversingAdjustedStartValue.get()))
+                interruptedTransition = &runningTransition;
         }
     }
 
     if (CSSPropertyEquality::propertiesEqual(id, oldStyle, style))
         return;
+
+    RefPtr<PairwiseInterpolation> pairwiseInterpolation;
+    InterpolationEnvironment oldEnvironment(oldStyle);
+    InterpolationEnvironment newEnvironment(style);
+    for (const std::unique_ptr<const InterpolationType>& interpolationType : PropertyInterpolationTypesMapping::get(PropertyHandle(id))) {
+        InterpolationValue start = interpolationType->maybeConvertUnderlyingValue(oldEnvironment);
+        if (!start)
+            continue;
+        InterpolationValue end = interpolationType->maybeConvertUnderlyingValue(newEnvironment);
+        if (!end)
+            continue;
+        if ((pairwiseInterpolation = PairwiseInterpolation::maybeCreate(*interpolationType, std::move(start), std::move(end))))
+            break;
+    }
+
+    // No smooth interpolation exists between these values so don't start a transition.
+    if (!pairwiseInterpolation)
+        return;
+
     if (!to)
         to = CSSAnimatableValueFactory::create(id, style);
+    RefPtr<AnimatableValue> from = CSSAnimatableValueFactory::create(id, oldStyle);
 
-    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;
 
     Timing timing = transitionData.convertToTiming(transitionIndex);
     if (timing.startDelay + timing.iterationDuration <= 0)
         return;
 
     AnimatableValue* reversingAdjustedStartValue = from.get();
     double reversingShorteningFactor = 1;
     if (interruptedTransition) {
         const double interruptedProgress = interruptedTransition->animation->effect()->progress();
         if (!std::isnan(interruptedProgress)) {
             // const_cast because we need to take a ref later when passing to startTransition.
-            reversingAdjustedStartValue = const_cast<AnimatableValue*>(interruptedTransition->to);
+            reversingAdjustedStartValue = const_cast<AnimatableValue*>(interruptedTransition->to.get());
             reversingShorteningFactor = clampTo(
                 (interruptedProgress * interruptedTransition->reversingShorteningFactor) +
                 (1 - interruptedTransition->reversingShorteningFactor), 0.0, 1.0);
             timing.iterationDuration *= reversingShorteningFactor;
             if (timing.startDelay < 0) {
                 timing.startDelay *= reversingShorteningFactor;
             }
         }
     }
 
-    AnimatableValueKeyframeVector keyframes;
-    double startKeyframeOffset = 0;
-
+    double delayOffset = 0;
     if (timing.startDelay > 0) {
         timing.iterationDuration += timing.startDelay;
-        startKeyframeOffset = timing.startDelay / timing.iterationDuration;
+        delayOffset = timing.startDelay / timing.iterationDuration;
         timing.startDelay = 0;
     }
 
-    RefPtr<AnimatableValueKeyframe> delayKeyframe = AnimatableValueKeyframe::create();
-    delayKeyframe->setPropertyValue(id, from.get());
-    delayKeyframe->setOffset(0);
-    keyframes.append(delayKeyframe);
-
-    RefPtr<AnimatableValueKeyframe> startKeyframe = AnimatableValueKeyframe::create();
-    startKeyframe->setPropertyValue(id, from.get());
-    startKeyframe->setOffset(startKeyframeOffset);
-    startKeyframe->setEasing(timing.timingFunction.release());
+    TransitionEffectModel* model = TransitionEffectModel::create(pairwiseInterpolation.release(), delayOffset, timing.timingFunction.release());
     timing.timingFunction = LinearTimingFunction::shared();
-    keyframes.append(startKeyframe);
-
-    RefPtr<AnimatableValueKeyframe> endKeyframe = AnimatableValueKeyframe::create();
-    endKeyframe->setPropertyValue(id, to.get());
-    endKeyframe->setOffset(1);
-    keyframes.append(endKeyframe);
-
-    AnimatableValueKeyframeEffectModel* model = AnimatableValueKeyframeEffectModel::create(keyframes);
     update.startTransition(
-        id, from.get(), to.get(), reversingAdjustedStartValue, reversingShorteningFactor,
+        id, from.release(), to.release(), reversingAdjustedStartValue, reversingShorteningFactor,
         *InertEffect::create(model, timing, false, 0));
     ASSERT(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
 }
 
 void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate& update, const Element* animatingElement, const ComputedStyle& style)
 {
     if (!animatingElement)
         return;
 
     if (animatingElement->document().printing() || animatingElement->document().wasPrinting())
@@ skipping 273 matching lines @@
 }
 
 DEFINE_TRACE(CSSAnimations)
 {
     visitor->trace(m_transitions);
     visitor->trace(m_pendingUpdate);
     visitor->trace(m_runningAnimations);
 }
 
 } // namespace blink