Adding a reverse function to the TimingFunctions and tests to prove it works.

Source/core/platform/animation/TimingFunction.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 21 matching lines @@
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 #include <algorithm>
 #include <iosfwd>
 
 
 namespace WebCore {
 
+class TimingFunction;
+
 class TimingFunction : public RefCounted<TimingFunction> {
 public:
 
     enum Type {
         LinearFunction, CubicBezierFunction, StepsFunction, ChainedFunction
     };
 
     virtual ~TimingFunction() { }
 
     Type type() const { return m_type; }
 
     // Evaluates the timing function at the given fraction. The accuracy parameter provides a hint as to the required
     // accuracy and is not guaranteed.
     virtual double evaluate(double fraction, double accuracy) const = 0;
     virtual bool operator==(const TimingFunction& other) const = 0;
+    virtual bool operator!=(const TimingFunction& other) const { return !operator==(other); }
+
+    virtual PassRefPtr<TimingFunction> reverse() const = 0;

[Steve Block, 2013/11/03 09:52:32]

Can you add a comment describing exactly what you want this reverse() method to
do?

 
 protected:
     TimingFunction(Type type)
         : m_type(type)
     {
     }
 
 private:
     Type m_type;
 };
@@ skipping 12 matching lines @@
         ASSERT(RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1));
         RELEASE_ASSERT_WITH_MESSAGE(!RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1), "Web Animations not yet implemented: Timing function behavior outside the range [0, 1] is not yet specified");
         return fraction;
     }
 
     virtual bool operator==(const TimingFunction& other) const
     {
         return other.type() == LinearFunction;
     }
 
+    virtual PassRefPtr<TimingFunction> reverse() const
+    {
+        return const_cast<LinearTimingFunction*>(this);
+    }
+
 private:
     LinearTimingFunction()
         : TimingFunction(LinearFunction)
     {
     }
 };
 
 class CubicBezierTimingFunction : public TimingFunction {
 public:
     enum SubType {
         Ease,
         EaseIn,
         EaseOut,
         EaseInOut,
         Custom
     };
 
     static PassRefPtr<CubicBezierTimingFunction> create(double x1, double y1, double x2, double y2)
     {
+        // Prevent accidental creation of presets via this method (makes operator== easier too).
+        if (x1 == 0.25 && y1 == 0.1 && x2 == 0.25 && y2 == 1.0) {
+            return preset(Ease);
+        }
+        if (x1 == 0.42 && y1 == 0.0 && x2 == 1.0 && y2 == 1.0) {
+            return preset(EaseIn);
+        }
+        if (x1 == 0.0 && y1 == 0.0 && x2 == 0.58 && y2 == 1.0) {
+            return preset(EaseOut);
+        }
+        if (x1 == 0.42 && y1 == 0.0 && x2 == 0.58 && y2 == 1.0) {
+            return preset(EaseInOut);
+        }
+

[Steve Block, 2013/11/03 09:52:32]

This introduces a change in behavior for CSS. The operator==() methods are
currently used for comparing render styles to determine when things change.
Currently, 'animation-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1.0)' and
'animation-timing-function: ease'  are considered to be different values, but
with your change, they will be considered equal. Are you sure this is OK?

         return adoptRef(new CubicBezierTimingFunction(Custom, x1, y1, x2, y2));
     }
 
     static CubicBezierTimingFunction* preset(SubType subType)
     {
         switch (subType) {
         case Ease:
             {
                 static CubicBezierTimingFunction* ease = adoptRef(new CubicBezierTimingFunction(Ease, 0.25, 0.1, 0.25, 1.0)).leakRef();
                 return ease;
@@ skipping 25 matching lines @@
     {
         ASSERT(RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1));
         RELEASE_ASSERT_WITH_MESSAGE(!RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1), "Web Animations not yet implemented: Timing function behavior outside the range [0, 1] is not yet specified");
         if (!m_bezier)
             m_bezier = adoptPtr(new UnitBezier(m_x1, m_y1, m_x2, m_y2));
         return m_bezier->solve(fraction, accuracy);
     }
 
     virtual bool operator==(const TimingFunction& other) const
     {
-        if (other.type() == CubicBezierFunction) {
-            const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(&other);
-            if (m_subType != Custom)
-                return m_subType == ctf->m_subType;
+        if (other.type() != CubicBezierFunction) 
+            return false;
 

[Steve Block, 2013/11/03 09:52:32]

Why don't you test for 'this == &other' here, like in the other classes?

+        const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(&other);
+        if (m_subType == Custom && ctf->m_subType == Custom)
             return m_x1 == ctf->m_x1 && m_y1 == ctf->m_y1 && m_x2 == ctf->m_x2 && m_y2 == ctf->m_y2;
-        }
-        return false;
+
+        return m_subType == ctf->m_subType;
     }
 
     double x1() const { return m_x1; }
     double y1() const { return m_y1; }
     double x2() const { return m_x2; }
     double y2() const { return m_y2; }
 
     SubType subType() const { return m_subType; }
 
+    virtual PassRefPtr<TimingFunction> reverse() const
+    {
+        switch (m_subType) {
+        case Ease:
+            return const_cast<CubicBezierTimingFunction*>(this);

[Steve Block, 2013/11/03 09:52:32]

This is incorrect. 'Ease' is not symmetric about x=y.

+        case EaseIn:
+            return preset(EaseOut);
+        case EaseOut:
+            return preset(EaseIn);
+        case EaseInOut:
+            return const_cast<CubicBezierTimingFunction*>(this);
+        case Custom:
+            // Flip the timing function in x. We also have to flip it in y to
+            // maintain the invariant that it runs from (0, 0) to (1, 1).
+            return create(1 - m_x2, 1 - m_y2, 1 - m_x1, 1 - m_y1);
+        default:
+            ASSERT_NOT_REACHED();
+        }
+    }
+
 private:
     explicit CubicBezierTimingFunction(SubType subType, double x1, double y1, double x2, double y2)
         : TimingFunction(CubicBezierFunction)
         , m_x1(x1)
         , m_y1(y1)
         , m_x2(x2)
         , m_y2(y2)
         , m_subType(subType)
     {
     }
@@ skipping 31 matching lines @@
             {
                 static StepsTimingFunction* end = adoptRef(new StepsTimingFunction(End, 1, false)).leakRef();
                 return end;
             }
         default:
             ASSERT_NOT_REACHED();
             return 0;
         }
     }
 
-
     ~StepsTimingFunction() { }
 
     virtual double evaluate(double fraction, double) const
     {
         ASSERT(RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1));
         RELEASE_ASSERT_WITH_MESSAGE(!RuntimeEnabledFeatures::webAnimationsEnabled() || (fraction >= 0 && fraction <= 1), "Web Animations not yet implemented: Timing function behavior outside the range [0, 1] is not yet specified");
         return std::min(1.0, (floor(m_steps * fraction) + m_stepAtStart) / m_steps);
     }
 
     virtual bool operator==(const TimingFunction& other) const
     {
-        if (other.type() == StepsFunction) {
-            const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(&other);
-            if (m_subType != Custom)
-                return m_subType == stf->m_subType;
-            return m_steps == stf->m_steps && m_stepAtStart == stf->m_stepAtStart;
-        }
-        return false;
+        if (other.type() != StepsFunction)
+            return false;
+
+        if (this == &other)
+            return true;
+
+        const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(&other);
+        if (m_subType != Custom)
+            return m_subType == stf->m_subType;
+        return m_steps == stf->m_steps && m_stepAtStart == stf->m_stepAtStart;
     }
 
     int numberOfSteps() const { return m_steps; }
     bool stepAtStart() const { return m_stepAtStart; }
 
     SubType subType() const { return m_subType; }
 
+    virtual PassRefPtr<TimingFunction> reverse() const
+    {
+        switch (m_subType) {
+        case Start:
+            return preset(End);

[Steve Block, 2013/11/03 09:52:32]

If I'm right about how I think you intend to use reverse(), this isn't correct.
A step-start has output 0 for all inputs in [0, 1]. The 'reversed' version of
this is a timing function that has output 0 for all inputs in [0, 1]. You're
using a step-end, which has output 0 for all inputs in [0, 1), but output 1 for
input 1.

The other cases have similar problems at the points of discontinuity.

[Steve Block, 2013/11/04 04:36:08]

Sorry, should be ...
A step-start has output 1 for all inputs in [0, 1].

[Steve Block, 2013/11/04 04:40:57]

step-start has an output of 1 at input 0. See
http://www.w3.org/TR/2012/WD-css3-transitions-20120403/#transition-timing-fun...
No, you need to flip in y as well as in x. A timing function must go through (0,
0) and (1, 1).

step-end:
  [-Inf, 1) -> 0
  [1, Inf] -> 1

So reversed(step-end):
  [-Inf, 0] -> 0
  (0, Inf] -> 1

step-start:
  [-Inf, 0) -> 0
  [0, Inf] -> 1

So reversed(step-start):
  [-Inf, 1] -> 0
  (1, Inf] -> 1

+        case End:
+            return preset(Start);
+        case Custom:
+            return create(m_steps, !m_stepAtStart);
+        default:
+            ASSERT_NOT_REACHED();
+            return 0;
+        }
+    }
+
 private:
     StepsTimingFunction(SubType subType, int steps, bool stepAtStart)
         : TimingFunction(StepsFunction)
         , m_steps(steps)
         , m_stepAtStart(stepAtStart)
         , m_subType(subType)
     {
     }
 
     int m_steps;
     bool m_stepAtStart;
     SubType m_subType;
 };
 
 class ChainedTimingFunction : public TimingFunction {
 public:
     static PassRefPtr<ChainedTimingFunction> create()
     {
         return adoptRef(new ChainedTimingFunction);
     }
 
     void appendSegment(double upperBound, TimingFunction* timingFunction)
     {
         double max = m_segments.isEmpty() ? 0 : m_segments.last().max();
         ASSERT(upperBound > max);
         m_segments.append(Segment(max, upperBound, timingFunction));
     }
+
     virtual double evaluate(double fraction, double accuracy) const
     {
         RELEASE_ASSERT_WITH_MESSAGE(fraction >= 0 && fraction <= 1, "Web Animations not yet implemented: Timing function behavior outside the range [0, 1] is not yet specified");
         ASSERT(!m_segments.isEmpty());
         ASSERT(m_segments.last().max() == 1);
         size_t i = 0;
         const Segment* segment = &m_segments[i++];
         while (fraction >= segment->max() && i < m_segments.size()) {
             segment = &m_segments[i++];
         }
         return segment->evaluate(fraction, accuracy);
     }
 
     virtual bool operator==(const TimingFunction& other) const

[Steve Block, 2013/11/03 09:52:32]

What exactly do you need operator==() for? Currently it's used only for CSS.
Keep in mind that things like 'cubic-bezier(0, 0, 1, 1)' and 'linear' are
functionally equivalent, but currently considered unequal.

     {
-        // This class is not exposed to CSS, so this method is not required.
-        ASSERT_NOT_REACHED();
-        return false;
+        if (other.type() != ChainedFunction)
+            return false;
+
+        if (this == &other)
+            return true;
+
+        const ChainedTimingFunction* ctf = static_cast<const ChainedTimingFunction*>(&other);
+        if (ctf->m_segments.size() != m_segments.size())
+            return false;
+
+        for (size_t i = 0; i < m_segments.size(); i++) {
+            if (m_segments[i] != ctf->m_segments[i])
+                return false;
+        }
+        return true;
+    }
+
+    virtual PassRefPtr<TimingFunction> reverse() const
+    {
+        RefPtr<ChainedTimingFunction> reversed = create();
+        for (size_t i = 0; i < m_segments.size(); i++) {
+            size_t index = m_segments.size() - i - 1;
+
+            reversed->appendSegment(1 - m_segments[index].m_min, m_segments[index].m_timingFunction->reverse().get());
+        }
+        return reversed;
     }
 
 private:
     class Segment {
     public:
         Segment(double min, double max, TimingFunction* timingFunction)
             : m_min(min)
             , m_max(max)
             , m_timingFunction(timingFunction)
         { }
 
         double max() const { return m_max; }
         double evaluate(double fraction, double accuracy) const
         {
             return scaleFromLocal(m_timingFunction->evaluate(scaleToLocal(fraction), accuracy));
         }
 
+        bool operator==(const Segment& other) const
+        {
+            if (this == &other)
+                return true;
+
+            return m_min == other.m_min && m_max == other.m_max && m_timingFunction == other.m_timingFunction;
+        }
+        bool operator!=(const Segment& other) const
+        {
+            return !operator==(other);
+        }
     private:
         double scaleToLocal(double x) const { return (x - m_min) / (m_max - m_min); }
         double scaleFromLocal(double x) const { return blend(m_min, m_max, x); }
 
         double m_min;
         double m_max;
         RefPtr<TimingFunction> m_timingFunction;
 
+        friend class ChainedTimingFunction;
+
         // Allow printing of our segments. Can be removed once
         // ChainedTimingFunction has a public API for segments.
         friend void PrintTo(const ChainedTimingFunction&, ::std::ostream*, bool);
     };
 
     ChainedTimingFunction()
         : TimingFunction(ChainedFunction)
     {
         ASSERT(RuntimeEnabledFeatures::webAnimationsEnabled());
     }
 
     Vector<Segment> m_segments;
 
     // Allow printing of our segments. Can be removed once
     // ChainedTimingFunction has a public API for segments.
     friend void PrintTo(const ChainedTimingFunction&, ::std::ostream*, bool);
 };
 
 } // namespace WebCore
 
 #endif // TimingFunction_h