Merge 116554 - [chromium] Add impl-thread support for fill-mode and direction css animation propert…

Source/WebCore/platform/graphics/chromium/cc/CCLayerAnimationController.cpp

 /*
  * Copyright (C) 2012 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 34 matching lines @@
 
 template <>
 void appendKeyframe<TransformAnimationValue, CCTransformKeyframe, CCKeyframedTransformAnimationCurve>(CCKeyframedTransformAnimationCurve& curve, double keyTime, const TransformAnimationValue* value, PassOwnPtr<CCTimingFunction> timingFunction)
 {
     curve.addKeyframe(CCTransformKeyframe::create(keyTime, *value->value(), timingFunction));
 }
 
 template <class Value, class Keyframe, class Curve>
 PassOwnPtr<CCActiveAnimation> createActiveAnimation(const KeyframeValueList& valueList, const Animation* animation, size_t animationId, size_t groupId, double timeOffset, CCActiveAnimation::TargetProperty targetProperty)
 {
-    // FIXME: add support for different directions.
-    if (animation && animation->isDirectionSet() && animation->direction() != Animation::AnimationDirectionNormal)
-        return nullptr;
-
-    // FIXME: add support for fills forwards and fills backwards
-    if (animation && animation->isFillModeSet() && (animation->fillsForwards() || animation->fillsBackwards()))
-        return nullptr;
+    bool alternate = false;
+    bool reverse = false;
+    if (animation && animation->isDirectionSet()) {
+        Animation::AnimationDirection direction = animation->direction();
+        if (direction == Animation::AnimationDirectionAlternate || direction == Animation::AnimationDirectionAlternateReverse)
+            alternate = true;
+        if (direction == Animation::AnimationDirectionReverse || direction == Animation::AnimationDirectionAlternateReverse)
+            reverse = true;
+    }
 
     OwnPtr<Curve> curve = Curve::create();
     Vector<Keyframe> keyframes;
 
     for (size_t i = 0; i < valueList.size(); i++) {
-        const Value* originalValue = static_cast<const Value*>(valueList.at(i));
+        size_t index = reverse ? valueList.size() - i - 1 : i;
+
+        const Value* originalValue = static_cast<const Value*>(valueList.at(index));
 
         OwnPtr<CCTimingFunction> timingFunction;
         const TimingFunction* originalTimingFunction = originalValue->timingFunction();
 
         // If there hasn't been a timing function associated with this keyframe, use the
         // animation's timing function, if we have one.
         if (!originalTimingFunction && animation->isTimingFunctionSet())
             originalTimingFunction = animation->timingFunction().get();
 
         if (originalTimingFunction) {
             switch (originalTimingFunction->type()) {
             case TimingFunction::StepsFunction:
                 // FIXME: add support for steps timing function.
                 return nullptr;
             case TimingFunction::LinearFunction:
                 // Don't set the timing function. Keyframes are interpolated linearly if there is no timing function.
                 break;
             case TimingFunction::CubicBezierFunction:
                 const CubicBezierTimingFunction* originalBezierTimingFunction = static_cast<const CubicBezierTimingFunction*>(originalTimingFunction);
                 timingFunction = CCCubicBezierTimingFunction::create(originalBezierTimingFunction->x1(), originalBezierTimingFunction->y1(), originalBezierTimingFunction->x2(), originalBezierTimingFunction->y2());
                 break;
             } // switch
         } else
             timingFunction = CCEaseTimingFunction::create();
 
         double duration = (animation && animation->isDurationSet()) ? animation->duration() : 1;
-        appendKeyframe<Value, Keyframe, Curve>(*curve, originalValue->keyTime() * duration, originalValue, timingFunction.release());
+        double keyTime = originalValue->keyTime() * duration;
+        if (reverse)
+            keyTime = duration - keyTime;
+        appendKeyframe<Value, Keyframe, Curve>(*curve, keyTime, originalValue, timingFunction.release());
     }
 
     OwnPtr<CCActiveAnimation> anim = CCActiveAnimation::create(curve.release(), animationId, groupId, targetProperty);
 
     ASSERT(anim.get());
 
     if (anim.get()) {
         int iterations = (animation && animation->isIterationCountSet()) ? animation->iterationCount() : 1;
         anim->setIterations(iterations);
+        anim->setAlternatesDirection(alternate);
     }
 
     // In order to avoid skew, the main thread animation cannot tick until it has received the start time of
     // the corresponding impl thread animation.
     anim->setNeedsSynchronizedStartTime(true);
 
     // If timeOffset > 0, then the animation has started in the past.
     anim->setTimeOffset(timeOffset);
 
     return anim.release();
@@ skipping 365 matching lines @@
                 m_client->setOpacityFromAnimation(opacity);
                 break;
             }
 
             }
         }
     }
 }
 
 } // namespace WebCore