Blink Compositor Animation: Make Animation and Curve methods non-virtual.

third_party/WebKit/Source/platform/animation/CompositorFloatAnimationCurve.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/animation/CompositorFloatAnimationCurve.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/timing_function.h"
 
 using blink::CompositorFloatKeyframe;
 
 namespace blink {
 
 CompositorFloatAnimationCurve::CompositorFloatAnimationCurve()
     : m_curve(cc::KeyframedFloatAnimationCurve::Create())
 {
 }
 
+CompositorFloatAnimationCurve::CompositorFloatAnimationCurve(std::unique_ptr<cc::KeyframedFloatAnimationCurve> curve)
+    : m_curve(std::move(curve))
+{
+}
+
 CompositorFloatAnimationCurve::~CompositorFloatAnimationCurve()
 {
 }
 
+PassOwnPtr<CompositorFloatAnimationCurve> CompositorFloatAnimationCurve::CreateForTesting(std::unique_ptr<cc::KeyframedFloatAnimationCurve> curve)
+{
+    return adoptPtr(new CompositorFloatAnimationCurve(std::move(curve)));
+}
+
+Vector<CompositorFloatKeyframe> CompositorFloatAnimationCurve::keyframesForTesting() const
+{
+    Vector<CompositorFloatKeyframe> keyframes;
+    for (auto& ccKeyframe : m_curve->keyframes_for_testing()) {
+        CompositorFloatKeyframe keyframe(ccKeyframe->Time().InSecondsF(), ccKeyframe->Value());
+        keyframes.append(keyframe);
+    }
+    return keyframes;
+}
+
+CubicBezierTimingFunction::EaseType CompositorFloatAnimationCurve::getCurveEaseTypeForTesting() const
+{
+    auto timingFunction = static_cast<const cc::CubicBezierTimingFunction*>(m_curve->timing_function_for_testing());
+    DCHECK(timingFunction);
+    return timingFunction->ease_type();
+}
+
+bool CompositorFloatAnimationCurve::curveHasLinearTimingFunctionForTesting() const
+{
+    return !m_curve->timing_function_for_testing();
+}
+
+CubicBezierTimingFunction::EaseType CompositorFloatAnimationCurve::getKeyframeEaseTypeForTesting(unsigned long index) const
+{
+    DCHECK_LT(index, m_curve->keyframes_for_testing().size());
+    const cc::TimingFunction* timingFunction = m_curve->keyframes_for_testing()[index]->timing_function();
+    DCHECK(timingFunction);
+    auto cubicTimingFunction = static_cast<const cc::CubicBezierTimingFunction*>(timingFunction);

[alancutter (OOO until 2018), 2016/06/01 02:20:55]

Need a check that this static_cast is correct.

[loyso (OOO), 2016/06/01 02:36:47]

This would require an extra data member in cc::TimingFunction type_ to store the
enum class { LINEAR, CUBIC_BEZIER, STEPS }; (we don't have it now)
That's an overhead of 4 bytes (?) pee curve and per keyframe.
ajuma@ is it ok? what do you think?

[ajuma, 2016/06/01 13:16:06]

Yeah, that sounds fine.

[loyso (OOO), 2016/06/02 02:16:46]

Done. Without overhead. :)

+    return cubicTimingFunction->ease_type();
+}
+
+bool CompositorFloatAnimationCurve::keyframeHasLinearTimingFunctionForTesting(unsigned long index) const
+{
+    DCHECK_LT(index, m_curve->keyframes_for_testing().size());
+    return !m_curve->keyframes_for_testing()[index]->timing_function();
+}
+
 void CompositorFloatAnimationCurve::addLinearKeyframe(const CompositorFloatKeyframe& keyframe)
 {
     m_curve->AddKeyframe(
         cc::FloatKeyframe::Create(base::TimeDelta::FromSecondsD(keyframe.time),
             keyframe.value, nullptr));
 }
 
 void CompositorFloatAnimationCurve::addCubicBezierKeyframe(const CompositorFloatKeyframe& keyframe,
     CubicBezierTimingFunction::EaseType easeType)
 {
@@ skipping 40 matching lines @@
 {
     return m_curve->GetValue(base::TimeDelta::FromSecondsD(time));
 }
 
 std::unique_ptr<cc::AnimationCurve> CompositorFloatAnimationCurve::cloneToAnimationCurve() const
 {
     return m_curve->Clone();
 }
 
 } // namespace blink