Web Animations CSS: Start running animations on the compositor

Source/core/animation/CompositorAnimationsTest.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
@@ skipping 97 matching lines @@
         return CompositorAnimationsImpl::isCandidateForCompositor(t, frames);
     }
     bool isCandidateForCompositor(const Keyframe& k)
     {
         return CompositorAnimationsImpl::isCandidateForCompositor(k);
     }
     bool isCandidateForCompositor(const KeyframeAnimationEffect& k)
     {
         return CompositorAnimationsImpl::isCandidateForCompositor(k);
     }
-    void getCompositorAnimations(Timing& timing, KeyframeAnimationEffect& effect, Vector<OwnPtr<blink::WebAnimation> >& animations, const IntSize& size = empty)
+    void getAnimationOnCompositor(Timing& timing, KeyframeAnimationEffect& effect, Vector<OwnPtr<blink::WebAnimation> >& animations, const IntSize& size = empty)
     {
-        return CompositorAnimationsImpl::getCompositorAnimations(timing, effect, animations, size);
+        return CompositorAnimationsImpl::getAnimationOnCompositor(timing, effect, animations, size);
     }
 
     static IntSize empty;
 
     // -------------------------------------------------------------------
 
     Timing createCompositableTiming()
     {
         Timing timing;
         timing.startDelay = 0;
@@ skipping 573 matching lines @@
     chainedTimingFunc->appendSegment(0.5, m_linearTimingFunction.get());
     chainedTimingFunc->appendSegment(1.0, cubicTimingFunc.get());
     Timing chainedTiming(createCompositableTiming());
     chainedTiming.timingFunction = chainedTimingFunc;
 
     KeyframeAnimationEffect::KeyframeVector basicFramesVector;
     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
     basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
     RefPtr<KeyframeAnimationEffect> basicFrames = KeyframeAnimationEffect::create(basicFramesVector).get();
 
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(linearTiming, *basicFrames.get()));
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(cubicTiming, *basicFrames.get()));
+    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get()));
+    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(cubicTiming, *basicFrames.get()));
     // number of timing function and keyframes don't match
-    EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(chainedTiming, *basicFrames.get()));
+    EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(chainedTiming, *basicFrames.get()));
 
     KeyframeAnimationEffect::KeyframeVector nonBasicFramesVector;
     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.5).get());
     nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
     RefPtr<KeyframeAnimationEffect> nonBasicFrames = KeyframeAnimationEffect::create(nonBasicFramesVector).get();
 
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(linearTiming, *nonBasicFrames.get()));
-    EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(cubicTiming, *nonBasicFrames.get()));
-    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForCompositorAnimation(chainedTiming, *nonBasicFrames.get()));
+    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get()));
+    EXPECT_FALSE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(cubicTiming, *nonBasicFrames.get()));
+    EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(chainedTiming, *nonBasicFrames.get()));
 }
 
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 
 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
@@ skipping 25 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
@@ skipping 26 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationLinear)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
@@ skipping 32 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationNegativeStartDelay)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
@@ skipping 28 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationChained)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
@@ skipping 39 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25),
@@ skipping 39 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegativeStartDelay)
 {
     // Animation to convert
     RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect(
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0),
         createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
@@ skipping 29 matching lines @@
     EXPECT_CALL(*mockAnimationPtr, delete_())
         .Times(1)
         .After(usesMockAnimation);
     EXPECT_CALL(*mockCurvePtr, delete_())
         .Times(1)
         .After(usesMockCurve);
 
     // Go!
     setCompositorForTesting(mockCompositor);
     Vector<OwnPtr<blink::WebAnimation> > result;
-    getCompositorAnimations(m_timing, *effect.get(), result);
+    getAnimationOnCompositor(m_timing, *effect.get(), result);
     EXPECT_EQ(1U, result.size());
     result[0].clear();
 }
 
 
 } // namespace WebCore