Revert "Animations: Pass animation timing function through to compositor."

Source/core/animation/CompositorAnimations.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 160 matching lines @@
             // FIXME: Remove this check when crbug.com/229405 is resolved
             if (keyframe != lastKeyframe && keyframe->easing().type() == TimingFunction::StepsFunction)
                 return false;
         }
     }
 
     CompositorAnimationsImpl::CompositorTiming out;
     if (!CompositorAnimationsImpl::convertTimingForCompositor(timing, 0, out, playerPlaybackRate))
         return false;
 
-    if (timing.timingFunction->type() == TimingFunction::StepsFunction) {
-        // FIXME: Support step timing functions in the compositor.
+    if (timing.timingFunction->type() != TimingFunction::LinearFunction) {
+        // Checks the of size of KeyframeVector instead of PropertySpecificKeyframeVector.
+        const KeyframeVector& keyframes = keyframeEffect.getFrames();
+        if (keyframes.size() == 2 && keyframes.first()->easing().type() == TimingFunction::LinearFunction && timing.timingFunction->type() != TimingFunction::StepsFunction)
+            return true;
+
+        // FIXME: Support non-linear timing functions in the compositor for
+        // more than two keyframes and step timing functions in the compositor.
         return false;
     }
 
-    if (timing.timingFunction->type() == TimingFunction::CubicBezierFunction) {
-        // FIXME: Fix compositor timing functions to accept inputs outside of
-        // [0,1].
-        const CubicBezierTimingFunction& cubic = toCubicBezierTimingFunction(*timing.timingFunction);
-        const KeyframeVector& keyframes = keyframeEffect.getFrames();
-        double startRange;
-        double endRange;
-        cubic.range(&startRange, &endRange);
-
-        ASSERT(keyframes.size() >= 2);
-        if ((startRange < 0 || endRange > 1) && (keyframes.first()->easing().type() != TimingFunction::LinearFunction || keyframes[keyframes.size()-2]->easing().type() != TimingFunction::LinearFunction))
-            return false;
-    }
-
     return true;
 }
 
 bool CompositorAnimations::canStartAnimationOnCompositor(const Element& element)
 {
     return element.renderer() && element.renderer()->compositingState() == PaintsIntoOwnBacking;
 }
 
 bool CompositorAnimations::startAnimationOnCompositor(const Element& element, double startTime, double timeOffset, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds, double playerPlaybackRate)
 {
@@ skipping 127 matching lines @@
         return;
     }
 
     case TimingFunction::StepsFunction:
     default:
         ASSERT_NOT_REACHED();
         return;
     }
 }
 
-template <typename PlatformAnimationCurveType>
-void setTimingFunctionOnCurve(PlatformAnimationCurveType& curve, const Timing& timing)
-{
-    switch (timing.timingFunction->type()) {
-    case TimingFunction::LinearFunction:
-        curve.setTimingFunction(WebCompositorAnimationCurve::TimingFunctionTypeLinear);
-        return;
-
-    case TimingFunction::CubicBezierFunction: {
-        const CubicBezierTimingFunction& cubic = toCubicBezierTimingFunction(*timing.timingFunction);
-        curve.setTimingFunction(cubic.x1(), cubic.y1(), cubic.x2(), cubic.y2());
-        return;
-    }
-
-    case TimingFunction::StepsFunction:
-    default:
-        ASSERT_NOT_REACHED();
-        return;
-    }
-}
-
 } // namespace anoymous
 
 void CompositorAnimationsImpl::addKeyframesToCurve(WebCompositorAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, const Timing& timing)
 {
     auto* lastKeyframe = keyframes.last().get();
     for (const auto& keyframe : keyframes) {
         const TimingFunction* keyframeTimingFunction = 0;
         if (keyframe != lastKeyframe) { // Ignore timing function of last frame.
-            keyframeTimingFunction = &keyframe->easing();
+            if (keyframes.size() == 2 && keyframes.first()->easing().type() == TimingFunction::LinearFunction)
+                keyframeTimingFunction = timing.timingFunction.get();
+            else
+                keyframeTimingFunction = &keyframe->easing();
         }
 
         // FIXME: This relies on StringKeyframes being eagerly evaluated, which will
         // not happen eventually. Instead we should extract the CSSValue here
         // and convert using another set of toAnimatableXXXOperations functions.
         const AnimatableValue* value = keyframe->getAnimatableValue().get();
 
         switch (curve.type()) {
         case WebCompositorAnimationCurve::AnimationCurveTypeFilter: {
             OwnPtr<WebFilterOperations> ops = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
@@ skipping 39 matching lines @@
         getKeyframeValuesForProperty(&effect, property, compositorTiming.scaledDuration, values);
 
         WebCompositorAnimation::TargetProperty targetProperty;
         OwnPtr<WebCompositorAnimationCurve> curve;
         switch (property) {
         case CSSPropertyOpacity: {
             targetProperty = WebCompositorAnimation::TargetPropertyOpacity;
 
             WebFloatAnimationCurve* floatCurve = Platform::current()->compositorSupport()->createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values, timing);
-            setTimingFunctionOnCurve(*floatCurve, timing);
             curve = adoptPtr(floatCurve);
             break;
         }
         case CSSPropertyWebkitFilter: {
             targetProperty = WebCompositorAnimation::TargetPropertyFilter;
             WebFilterAnimationCurve* filterCurve = Platform::current()->compositorSupport()->createFilterAnimationCurve();
             addKeyframesToCurve(*filterCurve, values, timing);
-            setTimingFunctionOnCurve(*filterCurve, timing);
             curve = adoptPtr(filterCurve);
             break;
         }
         case CSSPropertyTransform: {
             targetProperty = WebCompositorAnimation::TargetPropertyTransform;
             WebTransformAnimationCurve* transformCurve = Platform::current()->compositorSupport()->createTransformAnimationCurve();
             addKeyframesToCurve(*transformCurve, values, timing);
-            setTimingFunctionOnCurve(*transformCurve, timing);
             curve = adoptPtr(transformCurve);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             continue;
         }
         ASSERT(curve.get());
 
         OwnPtr<WebCompositorAnimation> animation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty));
@@ skipping 38 matching lines @@
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink