X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fthird_party%2FWebKit%2FSource%2Fcore%2Fanimation%2FCompositorAnimationsTest.cpp;h=fa62b15f477f9ae0489851cb7cfcc27581161b14;hb=3545e9f2671f595d2a2f3ee75ca0393b01e35ef6;hp=b6470f01e982688478c6c44b382a34400d17656f;hpb=7d210d4c7e9ba36e635eabc5b5780495f8a63292;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp b/src/third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp index b6470f0..fa62b15 100644 --- a/src/third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp +++ b/src/third_party/WebKit/Source/core/animation/CompositorAnimationsTest.cpp @@ -43,7 +43,7 @@ #include "platform/graphics/filters/FilterOperations.h" #include "platform/transforms/TransformOperations.h" #include "platform/transforms/TranslateTransformOperation.h" -#include "public/platform/WebAnimation.h" +#include "public/platform/WebCompositorAnimation.h" #include "wtf/HashFunctions.h" #include "wtf/OwnPtr.h" #include "wtf/PassOwnPtr.h" @@ -82,7 +82,7 @@ protected: m_linearTimingFunction = LinearTimingFunction::shared(); m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4); - m_stepTimingFunction = StepsTimingFunction::create(1, StepsTimingFunction::StepAtEnd); + m_stepTimingFunction = StepsTimingFunction::create(1, StepsTimingFunction::End); m_timing = createCompositableTiming(); m_compositorTiming = CompositorAnimationsImpl::CompositorTiming(); @@ -101,15 +101,19 @@ public: bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::CompositorTiming& out) { - return CompositorAnimationsImpl::convertTimingForCompositor(t, out); + return CompositorAnimationsImpl::convertTimingForCompositor(t, 0, out, 1); } bool isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect) { - return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect); + return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect, 1); } - void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector >& animations) + void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector >& animations) { - return CompositorAnimationsImpl::getAnimationOnCompositor(timing, std::numeric_limits::quiet_NaN(), effect, animations); + return getAnimationOnCompositor(timing, effect, animations, 1); + } + void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector >& animations, double playerPlaybackRate) + { + return CompositorAnimationsImpl::getAnimationOnCompositor(timing, std::numeric_limits::quiet_NaN(), 0, effect, animations, playerPlaybackRate); } bool getAnimationBounds(FloatBox& boundingBox, const AnimationEffect& effect, double minValue, double maxValue) { @@ -246,17 +250,17 @@ TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKey TEST_F(AnimationCompositorAnimationsTest, isNotCandidateForCompositorAnimationTransformDependsOnBoxSize) { TransformOperations ops; - ops.operations().append(TranslateTransformOperation::create(Length(2, blink::Fixed), Length(2, blink::Fixed), TransformOperation::TranslateX)); + ops.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(2, Fixed), TransformOperation::TranslateX)); RefPtrWillBeRawPtr goodKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get()); EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(goodKeyframe.get())); - ops.operations().append(TranslateTransformOperation::create(Length(50, blink::Percent), Length(2, blink::Fixed), TransformOperation::TranslateX)); + ops.operations().append(TranslateTransformOperation::create(Length(50, Percent), Length(2, Fixed), TransformOperation::TranslateX)); RefPtrWillBeRawPtr badKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get()); EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe.get())); TransformOperations ops2; - Length calcLength = Length(100, blink::Percent).blend(Length(100, blink::Fixed), 0.5, blink::ValueRangeAll); - ops2.operations().append(TranslateTransformOperation::create(calcLength, Length(0, blink::Fixed), TransformOperation::TranslateX)); + Length calcLength = Length(100, Percent).blend(Length(100, Fixed), 0.5, ValueRangeAll); + ops2.operations().append(TranslateTransformOperation::create(calcLength, Length(0, Fixed), TransformOperation::TranslateX)); RefPtrWillBeRawPtr badKeyframe2 = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops2).get()); EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe2.get())); } @@ -291,9 +295,9 @@ TEST_F(AnimationCompositorAnimationsTest, AnimatedBoundingBox) { Vector transformVector; transformVector.append(TransformOperations()); - transformVector.last().operations().append(TranslateTransformOperation::create(Length(0, blink::Fixed), Length(0, blink::Fixed), 0.0, TransformOperation::Translate3D)); + transformVector.last().operations().append(TranslateTransformOperation::create(Length(0, Fixed), Length(0, Fixed), 0.0, TransformOperation::Translate3D)); transformVector.append(TransformOperations()); - transformVector.last().operations().append(TranslateTransformOperation::create(Length(200, blink::Fixed), Length(200, blink::Fixed), 0.0, TransformOperation::Translate3D)); + transformVector.last().operations().append(TranslateTransformOperation::create(Length(200, Fixed), Length(200, Fixed), 0.0, TransformOperation::Translate3D)); OwnPtrWillBePersistent frames = createCompositableTransformKeyframeVector(transformVector); FloatBox bounds; EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1)); @@ -302,7 +306,7 @@ TEST_F(AnimationCompositorAnimationsTest, AnimatedBoundingBox) EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), -1, 1)); EXPECT_EQ(FloatBox(-200.0f, -200.0, 0.0, 400.0f, 400.0f, 0.0f), bounds); transformVector.append(TransformOperations()); - transformVector.last().operations().append(TranslateTransformOperation::create(Length(-300, blink::Fixed), Length(-400, blink::Fixed), 1.0f, TransformOperation::Translate3D)); + transformVector.last().operations().append(TranslateTransformOperation::create(Length(-300, Fixed), Length(-400, Fixed), 1.0f, TransformOperation::Translate3D)); bounds = FloatBox(); frames = createCompositableTransformKeyframeVector(transformVector); EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1)); @@ -328,7 +332,7 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorStartDelay) TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationStart) { m_timing.iterationStart = 2.2; - EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); } TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationCount) @@ -338,7 +342,8 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationCou EXPECT_EQ(5, m_compositorTiming.adjustedIterationCount); m_timing.iterationCount = 5.5; - EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_EQ(5.5, m_compositorTiming.adjustedIterationCount); // EXPECT_DEATH tests are flaky on Android. #if ENABLE(ASSERT) && !OS(ANDROID) @@ -379,32 +384,36 @@ TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationsAn TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorPlaybackRate) { - m_timing.playbackRate = 2.0; - EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); + m_timing.playbackRate = 1.0; + EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_DOUBLE_EQ(1.0, m_compositorTiming.playbackRate); - m_timing.playbackRate = 0.0; - EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); + m_timing.playbackRate = -2.3; + EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_DOUBLE_EQ(-2.3, m_compositorTiming.playbackRate); - m_timing.playbackRate = -2.0; - EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); + m_timing.playbackRate = 1.6; + EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); + EXPECT_DOUBLE_EQ(1.6, m_compositorTiming.playbackRate); } 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_TRUE(m_compositorTiming.alternate); - EXPECT_FALSE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); m_timing.direction = Timing::PlaybackDirectionAlternateReverse; EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); - EXPECT_TRUE(m_compositorTiming.alternate); - EXPECT_TRUE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); m_timing.direction = Timing::PlaybackDirectionReverse; EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); - EXPECT_FALSE(m_compositorTiming.alternate); - EXPECT_TRUE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionReverse); } TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIterationsAndStartDelay) @@ -416,8 +425,7 @@ 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_TRUE(m_compositorTiming.alternate); - EXPECT_FALSE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); m_timing.direction = Timing::PlaybackDirectionAlternate; m_timing.iterationCount = 4.0; @@ -426,8 +434,7 @@ 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_TRUE(m_compositorTiming.alternate); - EXPECT_FALSE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); m_timing.direction = Timing::PlaybackDirectionAlternateReverse; m_timing.iterationCount = 4.0; @@ -436,8 +443,7 @@ 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_TRUE(m_compositorTiming.alternate); - EXPECT_TRUE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); m_timing.direction = Timing::PlaybackDirectionAlternateReverse; m_timing.iterationCount = 4.0; @@ -446,8 +452,7 @@ 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_TRUE(m_compositorTiming.alternate); - EXPECT_TRUE(m_compositorTiming.reverse); + EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); } TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingTimingFunctionPassThru) @@ -466,11 +471,11 @@ TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTim TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionCubic) { m_timing.timingFunction = m_cubicEaseTimingFunction; - EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); + EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); m_timing.timingFunction = m_cubicCustomTimingFunction; - EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); + EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); } @@ -487,6 +492,17 @@ TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTim EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); } +TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorNonLinearTimingFunctionOnFirstFrame) +{ + m_timing.timingFunction = m_cubicEaseTimingFunction; + + EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); + + (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get()); + m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); + EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); +} + TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedCubicMatchingOffsets) { (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get()); @@ -567,7 +583,7 @@ TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor) nonBasicFramesVector[0]->setEasing(m_linearTimingFunction.get()); nonBasicFramesVector[1]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn)); RefPtrWillBeRawPtr nonBasicFrames = AnimatableValueKeyframeEffectModel::create(nonBasicFramesVector).get(); - EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get())); + EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get(), 1)); } // ----------------------------------------------------------------------- @@ -584,24 +600,25 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation) WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock; + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; ExpectationSet usesMockCurve; 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.0, 5.0))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); // Create animation - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -612,7 +629,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation) // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -631,24 +648,25 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration) WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock; + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; ExpectationSet usesMockCurve; 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(10.0, 5.0))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(10.0, 5.0))); // Create animation - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -659,7 +677,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration) // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -676,32 +694,34 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation m_timing.iterationCount = 5; m_timing.direction = Timing::PlaybackDirectionAlternate; + m_timing.playbackRate = 2.0; // -- WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock(); + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); ExpectationSet usesMockCurve; 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(0.25, -1.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.25, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, 20.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); // Animation is created - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(2.0)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -712,7 +732,7 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -733,24 +753,25 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock; + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; ExpectationSet usesMockCurve; 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.75, 5.0))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.75, 5.0))); // Create animation - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-3.25)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(false)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -761,7 +782,7 @@ TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -789,27 +810,28 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock(); + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); ExpectationSet usesMockCurve; EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) .WillOnce(Return(mockCurvePtr)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeEase)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, -1.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 20.0), 1.0, 2.0, 3.0, 4.0)); - usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(2.0, 5.0))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeEase)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 20.0), 1.0, 2.0, 3.0, 4.0)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(2.0, 5.0))); // Animation is created - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -820,7 +842,7 @@ TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimation // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -849,27 +871,28 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation) WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock(); + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); ExpectationSet usesMockCurve; EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) .WillOnce(Return(mockCurvePtr)); - 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))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeEaseIn)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.25, -1.0), blink::WebCompositorAnimationCurve::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))); // Create the animation - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -880,7 +903,7 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation) // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); @@ -902,24 +925,25 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegative WebCompositorSupportMock mockCompositor; // Curve is created - blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimationCurveMock; + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; ExpectationSet usesMockCurve; EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) .WillOnce(Return(mockCurvePtr)); - 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))); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 5.0))); // Create animation - blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blink::WebAnimation::TargetPropertyOpacity); + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); ExpectationSet usesMockAnimation; - usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), blink::WebAnimation::TargetPropertyOpacity, _)) + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) .WillOnce(Return(mockAnimationPtr)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(3.0)); - usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(true)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); EXPECT_CALL(*mockAnimationPtr, delete_()) .Times(1) @@ -930,11 +954,155 @@ TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegative // Go! setCompositorForTesting(mockCompositor); - Vector > result; + Vector > result; getAnimationOnCompositor(m_timing, *effect.get(), result); EXPECT_EQ(1U, result.size()); result[0].clear(); } +TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationPlaybackRates) +{ + // Animation to convert + RefPtrWillBeRawPtr effect = createKeyframeEffectModel( + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); + + m_timing.playbackRate = 2; + // -- + + WebCompositorSupportMock mockCompositor; + + // Curve is created + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; + ExpectationSet usesMockCurve; + EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) + .WillOnce(Return(mockCurvePtr)); + + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); + + // Create animation + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); + ExpectationSet usesMockAnimation; + + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) + .WillOnce(Return(mockAnimationPtr)); + + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(-3)); + + EXPECT_CALL(*mockAnimationPtr, delete_()) + .Times(1) + .After(usesMockAnimation); + EXPECT_CALL(*mockCurvePtr, delete_()) + .Times(1) + .After(usesMockCurve); + + // Go! + setCompositorForTesting(mockCompositor); + Vector > result; + // Set player plaback rate also + getAnimationOnCompositor(m_timing, *effect.get(), result, -1.5); + EXPECT_EQ(1U, result.size()); + result[0].clear(); +} + +TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeNone) +{ + // Animation to convert + RefPtrWillBeRawPtr effect = createKeyframeEffectModel( + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); + + m_timing.fillMode = Timing::FillModeNone; + + WebCompositorSupportMock mockCompositor; + + // Curve is created + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; + ExpectationSet usesMockCurve; + EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) + .WillOnce(Return(mockCurvePtr)); + + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); + + // Create animation + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); + ExpectationSet usesMockAnimation; + + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) + .WillOnce(Return(mockAnimationPtr)); + + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone)); + + EXPECT_CALL(*mockAnimationPtr, delete_()) + .Times(1) + .After(usesMockAnimation); + EXPECT_CALL(*mockCurvePtr, delete_()) + .Times(1) + .After(usesMockCurve); + + // Go! + setCompositorForTesting(mockCompositor); + Vector > result; + getAnimationOnCompositor(m_timing, *effect.get(), result); + EXPECT_EQ(1U, result.size()); + result[0].clear(); +} + +TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeAuto) +{ + // Animation to convert + RefPtrWillBeRawPtr effect = createKeyframeEffectModel( + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), + createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); + + m_timing.fillMode = Timing::FillModeAuto; + + WebCompositorSupportMock mockCompositor; + + // Curve is created + WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; + ExpectationSet usesMockCurve; + EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) + .WillOnce(Return(mockCurvePtr)); + + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); + usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); + + // Create animation + WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); + ExpectationSet usesMockAnimation; + + usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) + .WillOnce(Return(mockAnimationPtr)); + + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); + usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone)); + + EXPECT_CALL(*mockAnimationPtr, delete_()) + .Times(1) + .After(usesMockAnimation); + EXPECT_CALL(*mockCurvePtr, delete_()) + .Times(1) + .After(usesMockCurve); + + // Go! + setCompositorForTesting(mockCompositor); + Vector > result; + getAnimationOnCompositor(m_timing, *effect.get(), result); + EXPECT_EQ(1U, result.size()); + result[0].clear(); +} } // namespace blink