Revert "Handle direction control in compositor Animations"

This reverts: https://src.chromium.org/viewvc/blink?revision=170491&view=revision

Failed attempt to land two-sided patch. The chromium side broke the blink build and then this patch further broke it after the chromium side was reverted.

In the future, please do a three-step commit if that's required to ensure no build breakage.

TBR=a.renevier@samsung.com
BUG=348071

Review URL: https://codereview.chromium.org/220503002

git-svn-id: svn://svn.chromium.org/blink/trunk@170503 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/animation/CompositorAnimations.cpp

@@ -58,19 +58,73 @@ namespace WebCore {
 
 namespace {
 
-void getKeyframeValuesForProperty(const KeyframeEffectModel* effect, CSSPropertyID id, double scale, KeyframeVector& values)
+void getKeyframeValuesForProperty(const KeyframeEffectModel* effect, CSSPropertyID id, double scale, bool reverse, KeyframeVector& values)
 {
     ASSERT(values.isEmpty());
     const KeyframeVector& group = effect->getPropertySpecificKeyframes(id);
 
-    for (size_t i = 0; i < group.size(); ++i) {
-        double offset = group[i]->offset() * scale;
-        values.append(group[i]->cloneWithOffset(offset));
+    if (reverse) {
+        for (size_t i = group.size(); i--;) {
+            double offset = (1 - group[i]->offset()) * scale;
+            values.append(group[i]->cloneWithOffset(offset));
+        }
+    } else {
+        for (size_t i = 0; i < group.size(); ++i) {
+            double offset = group[i]->offset() * scale;
+            values.append(group[i]->cloneWithOffset(offset));
+        }
     }
 }
 
 }
 
+// -----------------------------------------------------------------------
+// TimingFunctionReverser methods
+// -----------------------------------------------------------------------
+
+PassRefPtr<TimingFunction> CompositorAnimationsTimingFunctionReverser::reverse(const LinearTimingFunction* timefunc)
+{
+    return const_cast<LinearTimingFunction*>(timefunc);
+}
+
+PassRefPtr<TimingFunction> CompositorAnimationsTimingFunctionReverser::reverse(const CubicBezierTimingFunction* timefunc)
+{
+    switch (timefunc->subType()) {
+    case CubicBezierTimingFunction::EaseIn:
+        return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
+    case CubicBezierTimingFunction::EaseOut:
+        return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
+    case CubicBezierTimingFunction::EaseInOut:
+        return const_cast<CubicBezierTimingFunction*>(timefunc);
+    case CubicBezierTimingFunction::Ease: // Ease is not symmetrical
+    case CubicBezierTimingFunction::Custom:
+        return CubicBezierTimingFunction::create(1 - timefunc->x2(), 1 - timefunc->y2(), 1 - timefunc->x1(), 1 - timefunc->y1());
+    default:
+        ASSERT_NOT_REACHED();
+        return PassRefPtr<TimingFunction>();
+    }
+}
+
+PassRefPtr<TimingFunction> CompositorAnimationsTimingFunctionReverser::reverse(const TimingFunction* timefunc)
+{
+    switch (timefunc->type()) {
+    case TimingFunction::LinearFunction: {
+        const LinearTimingFunction* linear = toLinearTimingFunction(timefunc);
+        return reverse(linear);
+    }
+    case TimingFunction::CubicBezierFunction: {
+        const CubicBezierTimingFunction* cubic = toCubicBezierTimingFunction(timefunc);
+        return reverse(cubic);
+    }
+
+    // Steps function can not be reversed.
+    case TimingFunction::StepsFunction:
+    default:
+        ASSERT_NOT_REACHED();
+        return PassRefPtr<TimingFunction>();
+    }
+}
+
 // -----------------------------------------------------------------------
 // CompositorAnimations public API
 // -----------------------------------------------------------------------
@@ -262,7 +316,10 @@ bool CompositorAnimationsImpl::convertTimingForCompositor(const Timing& timing,
     if (scaledStartDelay > 0 && scaledStartDelay > out.scaledDuration * timing.iterationCount)
         return false;
 
-    out.direction = timing.direction;
+    out.reverse = (timing.direction == Timing::PlaybackDirectionReverse
+        || timing.direction == Timing::PlaybackDirectionAlternateReverse);
+    out.alternate = (timing.direction == Timing::PlaybackDirectionAlternate
+        || timing.direction == Timing::PlaybackDirectionAlternateReverse);
 
     if (!std::isfinite(timing.iterationCount)) {
         out.adjustedIterationCount = -1;
@@ -334,12 +391,18 @@ void addKeyframeWithTimingFunction(PlatformAnimationCurveType& curve, const Plat
 
 } // namespace anoymous
 
-void CompositorAnimationsImpl::addKeyframesToCurve(blink::WebAnimationCurve& curve, const KeyframeVector& keyframes)
+void CompositorAnimationsImpl::addKeyframesToCurve(blink::WebAnimationCurve& curve, const KeyframeVector& keyframes, bool reverse)
 {
     for (size_t i = 0; i < keyframes.size(); i++) {
+        RefPtr<TimingFunction> reversedTimingFunction;
         const TimingFunction* keyframeTimingFunction = 0;
         if (i < keyframes.size() - 1) { // Ignore timing function of last frame.
-            keyframeTimingFunction = keyframes[i]->easing();
+            if (reverse) {
+                reversedTimingFunction = CompositorAnimationsTimingFunctionReverser::reverse(keyframes[i + 1]->easing());
+                keyframeTimingFunction = reversedTimingFunction.get();
+            } else {
+                keyframeTimingFunction = keyframes[i]->easing();
+            }
         }
 
         const AnimatableValue* value = keyframes[i]->value();
@@ -384,13 +447,15 @@ void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, co
     ASSERT_UNUSED(timingValid, timingValid);
 
     RefPtr<TimingFunction> timingFunction = timing.timingFunction;
+    if (compositorTiming.reverse)
+        timingFunction = CompositorAnimationsTimingFunctionReverser::reverse(timingFunction.get());
 
     PropertySet properties = effect.properties();
     ASSERT(!properties.isEmpty());
     for (PropertySet::iterator it = properties.begin(); it != properties.end(); ++it) {
 
         KeyframeVector values;
-        getKeyframeValuesForProperty(&effect, *it, compositorTiming.scaledDuration, values);
+        getKeyframeValuesForProperty(&effect, *it, compositorTiming.scaledDuration, compositorTiming.reverse, values);
 
         blink::WebAnimation::TargetProperty targetProperty;
         OwnPtr<blink::WebAnimationCurve> curve;
@@ -399,21 +464,21 @@ void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, co
             targetProperty = blink::WebAnimation::TargetPropertyOpacity;
 
             blink::WebFloatAnimationCurve* floatCurve = blink::Platform::current()->compositorSupport()->createFloatAnimationCurve();
-            addKeyframesToCurve(*floatCurve, values);
+            addKeyframesToCurve(*floatCurve, values, compositorTiming.reverse);
             curve = adoptPtr(floatCurve);
             break;
         }
         case CSSPropertyWebkitFilter: {
             targetProperty = blink::WebAnimation::TargetPropertyFilter;
             blink::WebFilterAnimationCurve* filterCurve = blink::Platform::current()->compositorSupport()->createFilterAnimationCurve();
-            addKeyframesToCurve(*filterCurve, values);
+            addKeyframesToCurve(*filterCurve, values, compositorTiming.reverse);
             curve = adoptPtr(filterCurve);
             break;
         }
         case CSSPropertyWebkitTransform: {
             targetProperty = blink::WebAnimation::TargetPropertyTransform;
             blink::WebTransformAnimationCurve* transformCurve = blink::Platform::current()->compositorSupport()->createTransformAnimationCurve();
-            addKeyframesToCurve(*transformCurve, values);
+            addKeyframesToCurve(*transformCurve, values, compositorTiming.reverse);
             curve = adoptPtr(transformCurve);
             break;
         }
@@ -427,23 +492,7 @@ void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, co
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
-
-        switch (compositorTiming.direction) {
-        case Timing::PlaybackDirectionNormal:
-            animation->setDirection(blink::WebAnimation::DirectionNormal);
-            break;
-        case Timing::PlaybackDirectionReverse:
-            animation->setDirection(blink::WebAnimation::DirectionReverse);
-            break;
-        case Timing::PlaybackDirectionAlternate:
-            animation->setDirection(blink::WebAnimation::DirectionAlternate);
-            break;
-        case Timing::PlaybackDirectionAlternateReverse:
-            animation->setDirection(blink::WebAnimation::DirectionAlternateReverse);
-            break;
-        default:
-            ASSERT_NOT_REACHED();
-        }
+        animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }

third_party/WebKit/Source/core/animation/CompositorAnimations.h

@@ -40,6 +40,18 @@ namespace WebCore {
 
 class Element;
 
+// Given an input timing function between keyframe at 0 and keyframe at 1.0, we
+// need a timing function such that the behavior with the keyframes swapped is
+// equivalent to reversing time with the input timing function and keyframes.
+// This means flipping the timing function about x=0.5 and about y=0.5.
+// FIXME: Remove once the Compositor natively understands reversing time.
+class CompositorAnimationsTimingFunctionReverser {
+public:
+    static PassRefPtr<TimingFunction> reverse(const LinearTimingFunction* timefunc);
+    static PassRefPtr<TimingFunction> reverse(const CubicBezierTimingFunction* timefunc);
+    static PassRefPtr<TimingFunction> reverse(const TimingFunction* timefunc);
+};
+
 class CompositorAnimations {
 public:
     static CompositorAnimations* instance() { return instance(0); }

third_party/WebKit/Source/core/animation/CompositorAnimationsImpl.h

@@ -41,7 +41,8 @@ typedef KeyframeEffectModel::PropertySpecificKeyframeVector KeyframeVector;
 class CompositorAnimationsImpl {
 private:
     struct CompositorTiming {
-        Timing::PlaybackDirection direction;
+        bool reverse;
+        bool alternate;
         double scaledDuration;
         double scaledTimeOffset;
         int adjustedIterationCount;
@@ -51,7 +52,7 @@ private:
 
     static void getAnimationOnCompositor(const Timing&, const KeyframeEffectModel&, Vector<OwnPtr<blink::WebAnimation> >& animations);
 
-    static void addKeyframesToCurve(blink::WebAnimationCurve&, const KeyframeVector&);
+    static void addKeyframesToCurve(blink::WebAnimationCurve&, const KeyframeVector&, bool reverse);
 
     friend class CompositorAnimations;
     friend class AnimationCompositorAnimationsTest;

third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp

@@ -359,21 +359,20 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorPlaybackRate
 
 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirection)
 {
-    m_timing.direction = Timing::PlaybackDirectionNormal;
-    EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionNormal);
-
     m_timing.direction = Timing::PlaybackDirectionAlternate;
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_FALSE(m_compositorTiming.reverse);
 
     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_TRUE(m_compositorTiming.reverse);
 
     m_timing.direction = Timing::PlaybackDirectionReverse;
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionReverse);
+    EXPECT_FALSE(m_compositorTiming.alternate);
+    EXPECT_TRUE(m_compositorTiming.reverse);
 }
 
 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIterationsAndStartDelay)
@@ -385,7 +384,8 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIte
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_FALSE(m_compositorTiming.reverse);
 
     m_timing.direction = Timing::PlaybackDirectionAlternate;
     m_timing.iterationCount = 4.0;
@@ -394,7 +394,8 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIte
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_FALSE(m_compositorTiming.reverse);
 
     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
     m_timing.iterationCount = 4.0;
@@ -403,7 +404,8 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIte
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
     EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset);
     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_TRUE(m_compositorTiming.reverse);
 
     m_timing.direction = Timing::PlaybackDirectionAlternateReverse;
     m_timing.iterationCount = 4.0;
@@ -412,7 +414,8 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIte
     EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming));
     EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset);
     EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount);
-    EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse);
+    EXPECT_TRUE(m_compositorTiming.alternate);
+    EXPECT_TRUE(m_compositorTiming.reverse);
 }
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingTimingFunctionPassThru)
@@ -567,7 +570,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation)
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionNormal));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -614,7 +617,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration)
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionNormal));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -667,7 +670,7 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionAlternate));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -716,7 +719,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-3.25));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionNormal));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -775,7 +778,7 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionAlternate));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -821,10 +824,10 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation)
     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
         .WillOnce(Return(mockCurvePtr));
 
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeEaseIn));
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.25, -1.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), 0.0, 0.0, 0.0, 1.0));
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0)));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 5.0), 1.0, 0.0, 1.0, 1.0));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.75, -1.0), blink::WebAnimationCurve::TimingFunctionTypeEaseOut));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 2.0)));
 
     // Create the animation
     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
@@ -835,7 +838,7 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation)
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionAlternateReverse));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
@@ -873,8 +876,8 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegative
     EXPECT_CALL(mockCompositor, createFloatAnimationCurve())
         .WillOnce(Return(mockCurvePtr));
 
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
-    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 5.0)));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 5.0), blink::WebAnimationCurve::TimingFunctionTypeLinear));
+    usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 2.0)));
 
     // Create animation
     blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity);
@@ -885,7 +888,7 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegative
 
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5));
     usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(3.0));
-    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebAnimation::DirectionAlternateReverse));
+    usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true));
 
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)

third_party/WebKit/Source/core/animation/CompositorAnimationsTestHelper.h

@@ -85,8 +85,8 @@ public:
     MOCK_CONST_METHOD0(timeOffset, double());
     MOCK_METHOD1(setTimeOffset, void(double));
 
-    MOCK_CONST_METHOD0(direction, Direction());
-    MOCK_METHOD1(setDirection, void(Direction));
+    MOCK_CONST_METHOD0(alternatesDirection, bool());
+    MOCK_METHOD1(setAlternatesDirection, void(bool));
 
     MOCK_METHOD0(delete_, void());
     ~WebAnimationMock() { delete_(); }

third_party/WebKit/Source/core/animation/CompositorAnimationsTimingFunctionReverserTest.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
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * 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/CompositorAnimations.h"
+
+#include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+// FIXME: Remove once https://codereview.chromium.org/50603011/ lands.
+#define EXPECT_REFV_EQ(a, b) EXPECT_EQ(*(a.get()), *(b.get()))
+#define EXPECT_REFV_NE(a, b) EXPECT_NE(*(a.get()), *(b.get()))
+
+namespace {
+
+using namespace WebCore;
+
+class AnimationCompositorAnimationsTimingFunctionReverserTest : public ::testing::Test {
+protected:
+
+public:
+    PassRefPtr<TimingFunction> reverse(const RefPtr<TimingFunction>& timefunc)
+    {
+        return CompositorAnimationsTimingFunctionReverser::reverse(timefunc.get());
+    }
+};
+
+TEST_F(AnimationCompositorAnimationsTimingFunctionReverserTest, LinearReverse)
+{
+    RefPtr<TimingFunction> linearTiming = LinearTimingFunction::preset();
+    EXPECT_REFV_EQ(linearTiming, reverse(linearTiming));
+}
+
+TEST_F(AnimationCompositorAnimationsTimingFunctionReverserTest, CubicReverse)
+{
+    RefPtr<TimingFunction> cubicEaseInTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
+    RefPtr<TimingFunction> cubicEaseOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
+    RefPtr<TimingFunction> cubicEaseInOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
+
+    EXPECT_REFV_EQ(cubicEaseOutTiming, reverse(cubicEaseInTiming));
+    EXPECT_REFV_EQ(cubicEaseInTiming, reverse(cubicEaseOutTiming));
+    EXPECT_REFV_EQ(cubicEaseInOutTiming, reverse(cubicEaseInOutTiming));
+
+    RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73);
+    // Due to floating point, 1.0-(-1.73) != 2.73
+    RefPtr<TimingFunction> cubicCustomTimingReversed = CubicBezierTimingFunction::create(0, 1.0 - (-1.73), 1.0 - 0.17, 1.0 - 0.67);
+    EXPECT_REFV_EQ(cubicCustomTimingReversed, reverse(cubicCustomTiming));
+
+    RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
+    RefPtr<TimingFunction> cubicEaseTimingReversed = CubicBezierTimingFunction::create(1.0 - 0.25, 0.0, 1.0 - 0.25, 1.0 - 0.1);
+    EXPECT_REFV_EQ(cubicEaseTimingReversed, reverse(cubicEaseTiming));
+}
+
+} // namespace

third_party/WebKit/Source/core/core.gypi

@@ -3279,6 +3279,7 @@
             'animation/AnimationTranslationUtilTest.cpp',
             'animation/CompositorAnimationsTest.cpp',
             'animation/CompositorAnimationsTestHelper.h',
+            'animation/CompositorAnimationsTimingFunctionReverserTest.cpp',
             'animation/DocumentTimelineTest.cpp',
             'animation/InterpolableValueTest.cpp',
             'animation/InterpolationEffectTest.cpp',

third_party/WebKit/public/platform/WebAnimation.h

@@ -33,8 +33,6 @@
 #include "wtf/Forward.h"
 #endif
 
-#define WEB_ANIMATION_SUPPORTS_FULL_DIRECTION 1
-
 namespace WebCore {
 class CCActiveAnimation;
 }
@@ -52,13 +50,6 @@ public:
         TargetPropertyFilter
     };
 
-    enum Direction {
-        DirectionNormal = 0,
-        DirectionReverse,
-        DirectionAlternate,
-        DirectionAlternateReverse
-    };
-
     virtual ~WebAnimation() { }
 
     // An id is effectively the animation's name, and it is not unique.
@@ -79,8 +70,8 @@ public:
     virtual void setTimeOffset(double monotonicTime) = 0;
 
     // If alternatesDirection is true, on odd numbered iterations we reverse the curve.
-    virtual Direction direction() const = 0;
-    virtual void setDirection(Direction) = 0;
+    virtual bool alternatesDirection() const = 0;
+    virtual void setAlternatesDirection(bool) = 0;
 };
 
 } // namespace blink