Adding operator== for ChainedTimingFunction

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 273 matching lines @@
         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
     {
-        // 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;
     }
 
 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;
+
+            bool minMaxEq = m_min == other.m_min && m_max == other.m_max;
+            if (!minMaxEq)
+                return false;
+
+            if (m_timingFunction == other.m_timingFunction)
+                return true;
+
+            if (!m_timingFunction || !other.m_timingFunction)
+                return false;
+
+            return (*m_timingFunction.get()) == (*other.m_timingFunction.get());
+        }
+        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;
 
         // Allow printing of our segments. Can be removed once
         // ChainedTimingFunction has a public API for segments.
         friend class ChainedTimingFunctionPrintTo;
     };
 
     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 class ChainedTimingFunctionPrintTo;
 };
 
 } // namespace WebCore
 
 #endif // TimingFunction_h