1 /* 2 * Copyright (c) 2013, Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include "config.h" 32 33 #include "core/animation/CompositorAnimations.h" 34 35 #include "core/animation/CompositorAnimationsImpl.h" 36 #include "core/animation/CompositorAnimationsTestHelper.h" 37 #include "core/animation/animatable/AnimatableDouble.h" 38 #include "core/animation/animatable/AnimatableFilterOperations.h" 39 #include "core/animation/animatable/AnimatableTransform.h" 40 #include "core/animation/animatable/AnimatableValueTestHelper.h" 41 #include "platform/geometry/FloatBox.h" 42 #include "platform/geometry/IntSize.h" 43 #include "platform/graphics/filters/FilterOperations.h" 44 #include "platform/transforms/TransformOperations.h" 45 #include "platform/transforms/TranslateTransformOperation.h" 46 #include "public/platform/WebCompositorAnimation.h" 47 #include "wtf/HashFunctions.h" 48 #include "wtf/OwnPtr.h" 49 #include "wtf/PassOwnPtr.h" 50 #include "wtf/PassRefPtr.h" 51 #include "wtf/RefPtr.h" 52 53 #include <gmock/gmock.h> 54 #include <gtest/gtest.h> 55 56 namespace blink { 57 58 using ::testing::CloneToPassOwnPtr; 59 using ::testing::ExpectationSet; 60 using ::testing::Ref; 61 using ::testing::Return; 62 using ::testing::_; 63 64 class AnimationCompositorAnimationsTest : public AnimationCompositorAnimationsTestBase { 65 protected: 66 RefPtr<TimingFunction> m_linearTimingFunction; 67 RefPtr<TimingFunction> m_cubicEaseTimingFunction; 68 RefPtr<TimingFunction> m_cubicCustomTimingFunction; 69 RefPtr<TimingFunction> m_stepTimingFunction; 70 71 Timing m_timing; 72 CompositorAnimationsImpl::CompositorTiming m_compositorTiming; 73 OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector2; 74 RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect2; 75 OwnPtrWillBePersistent<AnimatableValueKeyframeVector> m_keyframeVector5; 76 RefPtrWillBePersistent<AnimatableValueKeyframeEffectModel> m_keyframeAnimationEffect5; 77 78 virtual void SetUp() 79 { 80 AnimationCompositorAnimationsTestBase::SetUp(); 81 82 m_linearTimingFunction = LinearTimingFunction::shared(); 83 m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); 84 m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3, 4); 85 m_stepTimingFunction = StepsTimingFunction::create(1, StepsTimingFunction::End); 86 87 m_timing = createCompositableTiming(); 88 m_compositorTiming = CompositorAnimationsImpl::CompositorTiming(); 89 // Make sure the CompositableTiming is really compositable, otherwise 90 // most other tests will fail. 91 ASSERT(convertTimingForCompositor(m_timing, m_compositorTiming)); 92 93 m_keyframeVector2 = createCompositableFloatKeyframeVector(2); 94 m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); 95 96 m_keyframeVector5 = createCompositableFloatKeyframeVector(5); 97 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 98 } 99 100 public: 101 102 bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::CompositorTiming& out) 103 { 104 return CompositorAnimationsImpl::convertTimingForCompositor(t, 0, out, 1); 105 } 106 bool isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect) 107 { 108 return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(timing, effect, 1); 109 } 110 void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations) 111 { 112 return getAnimationOnCompositor(timing, effect, animations, 1); 113 } 114 void getAnimationOnCompositor(Timing& timing, AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<WebCompositorAnimation> >& animations, double playerPlaybackRate) 115 { 116 return CompositorAnimationsImpl::getAnimationOnCompositor(timing, std::numeric_limits<double>::quiet_NaN(), 0, effect, animations, playerPlaybackRate); 117 } 118 bool getAnimationBounds(FloatBox& boundingBox, const AnimationEffect& effect, double minValue, double maxValue) 119 { 120 return CompositorAnimations::instance()->getAnimatedBoundingBox(boundingBox, effect, minValue, maxValue); 121 } 122 123 bool duplicateSingleKeyframeAndTestIsCandidateOnResult(AnimatableValueKeyframe* frame) 124 { 125 EXPECT_EQ(frame->offset(), 0); 126 AnimatableValueKeyframeVector frames; 127 RefPtrWillBeRawPtr<Keyframe> second = frame->cloneWithOffset(1); 128 129 frames.append(frame); 130 frames.append(toAnimatableValueKeyframe(second.get())); 131 return isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(frames).get()); 132 } 133 134 // ------------------------------------------------------------------- 135 136 Timing createCompositableTiming() 137 { 138 Timing timing; 139 timing.startDelay = 0; 140 timing.fillMode = Timing::FillModeNone; 141 timing.iterationStart = 0; 142 timing.iterationCount = 1; 143 timing.iterationDuration = 1.0; 144 timing.playbackRate = 1.0; 145 timing.direction = Timing::PlaybackDirectionNormal; 146 ASSERT(m_linearTimingFunction); 147 timing.timingFunction = m_linearTimingFunction; 148 return timing; 149 } 150 151 PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> createReplaceOpKeyframe(CSSPropertyID id, AnimatableValue* value, double offset = 0) 152 { 153 RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframe = AnimatableValueKeyframe::create(); 154 keyframe->setPropertyValue(id, value); 155 keyframe->setComposite(AnimationEffect::CompositeReplace); 156 keyframe->setOffset(offset); 157 keyframe->setEasing(LinearTimingFunction::shared()); 158 return keyframe; 159 } 160 161 PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> createDefaultKeyframe(CSSPropertyID id, AnimationEffect::CompositeOperation op, double offset = 0) 162 { 163 RefPtrWillBeRawPtr<AnimatableValue> value = nullptr; 164 if (id == CSSPropertyTransform) 165 value = AnimatableTransform::create(TransformOperations()); 166 else 167 value = AnimatableDouble::create(10.0); 168 169 RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframe = createReplaceOpKeyframe(id, value.get(), offset); 170 keyframe->setComposite(op); 171 return keyframe; 172 } 173 174 PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableFloatKeyframeVector(size_t n) 175 { 176 Vector<double> values; 177 for (size_t i = 0; i < n; i++) { 178 values.append(static_cast<double>(i)); 179 } 180 return createCompositableFloatKeyframeVector(values); 181 } 182 183 PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableFloatKeyframeVector(Vector<double>& values) 184 { 185 OwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> frames = adoptPtrWillBeNoop(new AnimatableValueKeyframeVector); 186 for (size_t i = 0; i < values.size(); i++) { 187 double offset = 1.0 / (values.size() - 1) * i; 188 RefPtrWillBeRawPtr<AnimatableDouble> value = AnimatableDouble::create(values[i]); 189 frames->append(createReplaceOpKeyframe(CSSPropertyOpacity, value.get(), offset).get()); 190 } 191 return frames.release(); 192 } 193 194 PassOwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> createCompositableTransformKeyframeVector(const Vector<TransformOperations>& values) 195 { 196 OwnPtrWillBeRawPtr<AnimatableValueKeyframeVector> frames = adoptPtrWillBeNoop(new AnimatableValueKeyframeVector); 197 for (size_t i = 0; i < values.size(); ++i) { 198 double offset = 1.0f / (values.size() - 1) * i; 199 RefPtrWillBeRawPtr<AnimatableTransform> value = AnimatableTransform::create(values[i]); 200 frames->append(createReplaceOpKeyframe(CSSPropertyTransform, value.get(), offset).get()); 201 } 202 return frames.release(); 203 } 204 205 PassRefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> createKeyframeEffectModel(PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpFrom, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpTo, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpC = nullptr, PassRefPtrWillBeRawPtr<AnimatableValueKeyframe> prpD = nullptr) 206 { 207 RefPtrWillBeRawPtr<AnimatableValueKeyframe> from = prpFrom; 208 RefPtrWillBeRawPtr<AnimatableValueKeyframe> to = prpTo; 209 RefPtrWillBeRawPtr<AnimatableValueKeyframe> c = prpC; 210 RefPtrWillBeRawPtr<AnimatableValueKeyframe> d = prpD; 211 212 EXPECT_EQ(from->offset(), 0); 213 AnimatableValueKeyframeVector frames; 214 frames.append(from); 215 EXPECT_LE(from->offset(), to->offset()); 216 frames.append(to); 217 if (c) { 218 EXPECT_LE(to->offset(), c->offset()); 219 frames.append(c); 220 } 221 if (d) { 222 frames.append(d); 223 EXPECT_LE(c->offset(), d->offset()); 224 EXPECT_EQ(d->offset(), 1.0); 225 } else { 226 EXPECT_EQ(to->offset(), 1.0); 227 } 228 if (!HasFatalFailure()) { 229 return AnimatableValueKeyframeEffectModel::create(frames); 230 } 231 return nullptr; 232 } 233 234 }; 235 236 // ----------------------------------------------------------------------- 237 // ----------------------------------------------------------------------- 238 239 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties) 240 { 241 RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace); 242 keyframeGoodMultiple->setPropertyValue(CSSPropertyTransform, AnimatableTransform::create(TransformOperations()).get()); 243 EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeGoodMultiple.get())); 244 245 RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeBadMultipleID = createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace); 246 keyframeBadMultipleID->setPropertyValue(CSSPropertyOpacity, AnimatableDouble::create(10.0).get()); 247 EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(keyframeBadMultipleID.get())); 248 } 249 250 TEST_F(AnimationCompositorAnimationsTest, isNotCandidateForCompositorAnimationTransformDependsOnBoxSize) 251 { 252 TransformOperations ops; 253 ops.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(2, Fixed), TransformOperation::TranslateX)); 254 RefPtrWillBeRawPtr<AnimatableValueKeyframe> goodKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get()); 255 EXPECT_TRUE(duplicateSingleKeyframeAndTestIsCandidateOnResult(goodKeyframe.get())); 256 257 ops.operations().append(TranslateTransformOperation::create(Length(50, Percent), Length(2, Fixed), TransformOperation::TranslateX)); 258 RefPtrWillBeRawPtr<AnimatableValueKeyframe> badKeyframe = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops).get()); 259 EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe.get())); 260 261 TransformOperations ops2; 262 Length calcLength = Length(100, Percent).blend(Length(100, Fixed), 0.5, ValueRangeAll); 263 ops2.operations().append(TranslateTransformOperation::create(calcLength, Length(0, Fixed), TransformOperation::TranslateX)); 264 RefPtrWillBeRawPtr<AnimatableValueKeyframe> badKeyframe2 = createReplaceOpKeyframe(CSSPropertyTransform, AnimatableTransform::create(ops2).get()); 265 EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe2.get())); 266 } 267 268 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModelMultipleFramesOkay) 269 { 270 AnimatableValueKeyframeVector framesSame; 271 framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get()); 272 framesSame.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get()); 273 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame).get())); 274 275 AnimatableValueKeyframeVector framesMixed; 276 framesMixed.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get()); 277 framesMixed.append(createDefaultKeyframe(CSSPropertyTransform, AnimationEffect::CompositeReplace, 1.0).get()); 278 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesMixed).get())); 279 } 280 281 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeEffectModel) 282 { 283 AnimatableValueKeyframeVector framesSame; 284 framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 0.0).get()); 285 framesSame.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get()); 286 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame).get())); 287 288 AnimatableValueKeyframeVector framesMixedProperties; 289 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get()); 290 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeReplace, 1.0).get()); 291 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *AnimatableValueKeyframeEffectModel::create(framesMixedProperties).get())); 292 } 293 294 TEST_F(AnimationCompositorAnimationsTest, AnimatedBoundingBox) 295 { 296 Vector<TransformOperations> transformVector; 297 transformVector.append(TransformOperations()); 298 transformVector.last().operations().append(TranslateTransformOperation::create(Length(0, Fixed), Length(0, Fixed), 0.0, TransformOperation::Translate3D)); 299 transformVector.append(TransformOperations()); 300 transformVector.last().operations().append(TranslateTransformOperation::create(Length(200, Fixed), Length(200, Fixed), 0.0, TransformOperation::Translate3D)); 301 OwnPtrWillBePersistent<AnimatableValueKeyframeVector> frames = createCompositableTransformKeyframeVector(transformVector); 302 FloatBox bounds; 303 EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1)); 304 EXPECT_EQ(FloatBox(0.0f, 0.f, 0.0f, 200.0f, 200.0f, 0.0f), bounds); 305 bounds = FloatBox(); 306 EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), -1, 1)); 307 EXPECT_EQ(FloatBox(-200.0f, -200.0, 0.0, 400.0f, 400.0f, 0.0f), bounds); 308 transformVector.append(TransformOperations()); 309 transformVector.last().operations().append(TranslateTransformOperation::create(Length(-300, Fixed), Length(-400, Fixed), 1.0f, TransformOperation::Translate3D)); 310 bounds = FloatBox(); 311 frames = createCompositableTransformKeyframeVector(transformVector); 312 EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), 0, 1)); 313 EXPECT_EQ(FloatBox(-300.0f, -400.f, 0.0f, 500.0f, 600.0f, 1.0f), bounds); 314 bounds = FloatBox(); 315 EXPECT_TRUE(getAnimationBounds(bounds, *AnimatableValueKeyframeEffectModel::create(*frames).get(), -1, 2)); 316 EXPECT_EQ(FloatBox(-1300.0f, -1600.f, 0.0f, 1500.0f, 1800.0f, 3.0f), bounds); 317 } 318 319 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorStartDelay) 320 { 321 m_timing.iterationDuration = 20.0; 322 323 m_timing.startDelay = 2.0; 324 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 325 EXPECT_DOUBLE_EQ(-2.0, m_compositorTiming.scaledTimeOffset); 326 327 m_timing.startDelay = -2.0; 328 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 329 EXPECT_DOUBLE_EQ(2.0, m_compositorTiming.scaledTimeOffset); 330 } 331 332 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationStart) 333 { 334 m_timing.iterationStart = 2.2; 335 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 336 } 337 338 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationCount) 339 { 340 m_timing.iterationCount = 5.0; 341 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 342 EXPECT_EQ(5, m_compositorTiming.adjustedIterationCount); 343 344 m_timing.iterationCount = 5.5; 345 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 346 EXPECT_EQ(5.5, m_compositorTiming.adjustedIterationCount); 347 348 // EXPECT_DEATH tests are flaky on Android. 349 #if ENABLE(ASSERT) && !OS(ANDROID) 350 m_timing.iterationCount = -1; 351 EXPECT_DEATH(convertTimingForCompositor(m_timing, m_compositorTiming), ""); 352 #endif 353 354 m_timing.iterationCount = std::numeric_limits<double>::infinity(); 355 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 356 EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount); 357 358 m_timing.iterationCount = std::numeric_limits<double>::infinity(); 359 m_timing.iterationDuration = 5.0; 360 m_timing.startDelay = -6.0; 361 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 362 EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset); 363 EXPECT_EQ(-1, m_compositorTiming.adjustedIterationCount); 364 } 365 366 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorIterationsAndStartDelay) 367 { 368 m_timing.iterationCount = 4.0; 369 m_timing.iterationDuration = 5.0; 370 371 m_timing.startDelay = 6.0; 372 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 373 EXPECT_DOUBLE_EQ(-6.0, m_compositorTiming.scaledTimeOffset); 374 EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount); 375 376 m_timing.startDelay = -6.0; 377 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 378 EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset); 379 EXPECT_DOUBLE_EQ(4.0, m_compositorTiming.adjustedIterationCount); 380 381 m_timing.startDelay = 21.0; 382 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); 383 } 384 385 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorPlaybackRate) 386 { 387 m_timing.playbackRate = 1.0; 388 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 389 EXPECT_DOUBLE_EQ(1.0, m_compositorTiming.playbackRate); 390 391 m_timing.playbackRate = -2.3; 392 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 393 EXPECT_DOUBLE_EQ(-2.3, m_compositorTiming.playbackRate); 394 395 m_timing.playbackRate = 1.6; 396 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 397 EXPECT_DOUBLE_EQ(1.6, m_compositorTiming.playbackRate); 398 } 399 400 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirection) 401 { 402 m_timing.direction = Timing::PlaybackDirectionNormal; 403 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 404 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionNormal); 405 406 m_timing.direction = Timing::PlaybackDirectionAlternate; 407 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 408 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); 409 410 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; 411 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 412 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); 413 414 m_timing.direction = Timing::PlaybackDirectionReverse; 415 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 416 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionReverse); 417 } 418 419 TEST_F(AnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectionIterationsAndStartDelay) 420 { 421 m_timing.direction = Timing::PlaybackDirectionAlternate; 422 m_timing.iterationCount = 4.0; 423 m_timing.iterationDuration = 5.0; 424 m_timing.startDelay = -6.0; 425 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 426 EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset); 427 EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount); 428 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); 429 430 m_timing.direction = Timing::PlaybackDirectionAlternate; 431 m_timing.iterationCount = 4.0; 432 m_timing.iterationDuration = 5.0; 433 m_timing.startDelay = -11.0; 434 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 435 EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset); 436 EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount); 437 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternate); 438 439 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; 440 m_timing.iterationCount = 4.0; 441 m_timing.iterationDuration = 5.0; 442 m_timing.startDelay = -6.0; 443 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 444 EXPECT_DOUBLE_EQ(6.0, m_compositorTiming.scaledTimeOffset); 445 EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount); 446 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); 447 448 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; 449 m_timing.iterationCount = 4.0; 450 m_timing.iterationDuration = 5.0; 451 m_timing.startDelay = -11.0; 452 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); 453 EXPECT_DOUBLE_EQ(11.0, m_compositorTiming.scaledTimeOffset); 454 EXPECT_EQ(4, m_compositorTiming.adjustedIterationCount); 455 EXPECT_EQ(m_compositorTiming.direction, Timing::PlaybackDirectionAlternateReverse); 456 } 457 458 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingTimingFunctionPassThru) 459 { 460 m_timing.timingFunction = m_stepTimingFunction; 461 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 462 } 463 464 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionLinear) 465 { 466 m_timing.timingFunction = m_linearTimingFunction; 467 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 468 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 469 } 470 471 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionCubic) 472 { 473 m_timing.timingFunction = m_cubicEaseTimingFunction; 474 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 475 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 476 477 m_timing.timingFunction = m_cubicCustomTimingFunction; 478 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 479 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 480 } 481 482 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionSteps) 483 { 484 m_timing.timingFunction = m_stepTimingFunction; 485 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 486 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 487 } 488 489 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedLinear) 490 { 491 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 492 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 493 } 494 495 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorNonLinearTimingFunctionOnFirstFrame) 496 { 497 m_timing.timingFunction = m_cubicEaseTimingFunction; 498 499 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 500 501 (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get()); 502 m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); 503 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 504 } 505 506 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionChainedCubicMatchingOffsets) 507 { 508 (*m_keyframeVector2)[0]->setEasing(m_cubicEaseTimingFunction.get()); 509 m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); 510 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 511 512 (*m_keyframeVector2)[0]->setEasing(m_cubicCustomTimingFunction.get()); 513 m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); 514 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 515 516 (*m_keyframeVector5)[0]->setEasing(m_cubicEaseTimingFunction.get()); 517 (*m_keyframeVector5)[1]->setEasing(m_cubicCustomTimingFunction.get()); 518 (*m_keyframeVector5)[2]->setEasing(m_cubicCustomTimingFunction.get()); 519 (*m_keyframeVector5)[3]->setEasing(m_cubicCustomTimingFunction.get()); 520 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 521 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 522 } 523 524 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionMixedGood) 525 { 526 (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get()); 527 (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get()); 528 (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get()); 529 (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get()); 530 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 531 EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 532 } 533 534 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorTimingFunctionWithStepNotOkay) 535 { 536 (*m_keyframeVector2)[0]->setEasing(m_stepTimingFunction.get()); 537 m_keyframeAnimationEffect2 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector2); 538 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect2.get())); 539 540 (*m_keyframeVector5)[0]->setEasing(m_stepTimingFunction.get()); 541 (*m_keyframeVector5)[1]->setEasing(m_linearTimingFunction.get()); 542 (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get()); 543 (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get()); 544 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 545 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 546 547 (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get()); 548 (*m_keyframeVector5)[1]->setEasing(m_stepTimingFunction.get()); 549 (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get()); 550 (*m_keyframeVector5)[3]->setEasing(m_linearTimingFunction.get()); 551 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 552 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 553 554 (*m_keyframeVector5)[0]->setEasing(m_linearTimingFunction.get()); 555 (*m_keyframeVector5)[1]->setEasing(m_cubicEaseTimingFunction.get()); 556 (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get()); 557 (*m_keyframeVector5)[3]->setEasing(m_stepTimingFunction.get()); 558 m_keyframeAnimationEffect5 = AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5); 559 EXPECT_FALSE(isCandidateForAnimationOnCompositor(m_timing, *m_keyframeAnimationEffect5.get())); 560 } 561 562 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor) 563 { 564 Timing linearTiming(createCompositableTiming()); 565 566 AnimatableValueKeyframeVector basicFramesVector; 567 basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get()); 568 basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get()); 569 570 AnimatableValueKeyframeVector nonBasicFramesVector; 571 nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get()); 572 nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.5).get()); 573 nonBasicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get()); 574 575 basicFramesVector[0]->setEasing(m_linearTimingFunction.get()); 576 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get(); 577 EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get())); 578 579 basicFramesVector[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn)); 580 basicFrames = AnimatableValueKeyframeEffectModel::create(basicFramesVector).get(); 581 EXPECT_TRUE(isCandidateForAnimationOnCompositor(linearTiming, *basicFrames.get())); 582 583 nonBasicFramesVector[0]->setEasing(m_linearTimingFunction.get()); 584 nonBasicFramesVector[1]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn)); 585 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> nonBasicFrames = AnimatableValueKeyframeEffectModel::create(nonBasicFramesVector).get(); 586 EXPECT_TRUE(CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(linearTiming, *nonBasicFrames.get(), 1)); 587 } 588 589 // ----------------------------------------------------------------------- 590 // ----------------------------------------------------------------------- 591 592 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimation) 593 { 594 // Animation to convert 595 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 596 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 597 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 598 // -- 599 600 WebCompositorSupportMock mockCompositor; 601 602 // Curve is created 603 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 604 ExpectationSet usesMockCurve; 605 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 606 .WillOnce(Return(mockCurvePtr)); 607 608 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 609 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); 610 611 // Create animation 612 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 613 ExpectationSet usesMockAnimation; 614 615 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 616 .WillOnce(Return(mockAnimationPtr)); 617 618 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); 619 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 620 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 621 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 622 623 EXPECT_CALL(*mockAnimationPtr, delete_()) 624 .Times(1) 625 .After(usesMockAnimation); 626 EXPECT_CALL(*mockCurvePtr, delete_()) 627 .Times(1) 628 .After(usesMockCurve); 629 630 // Go! 631 setCompositorForTesting(mockCompositor); 632 Vector<OwnPtr<WebCompositorAnimation> > result; 633 getAnimationOnCompositor(m_timing, *effect.get(), result); 634 EXPECT_EQ(1U, result.size()); 635 result[0].clear(); 636 } 637 638 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationDuration) 639 { 640 // Animation to convert 641 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 642 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 643 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 644 645 m_timing.iterationDuration = 10.0; 646 // -- 647 648 WebCompositorSupportMock mockCompositor; 649 650 // Curve is created 651 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 652 ExpectationSet usesMockCurve; 653 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 654 .WillOnce(Return(mockCurvePtr)); 655 656 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 657 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(10.0, 5.0))); 658 659 // Create animation 660 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 661 ExpectationSet usesMockAnimation; 662 663 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 664 .WillOnce(Return(mockAnimationPtr)); 665 666 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); 667 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 668 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 669 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 670 671 EXPECT_CALL(*mockAnimationPtr, delete_()) 672 .Times(1) 673 .After(usesMockAnimation); 674 EXPECT_CALL(*mockCurvePtr, delete_()) 675 .Times(1) 676 .After(usesMockCurve); 677 678 // Go! 679 setCompositorForTesting(mockCompositor); 680 Vector<OwnPtr<WebCompositorAnimation> > result; 681 getAnimationOnCompositor(m_timing, *effect.get(), result); 682 EXPECT_EQ(1U, result.size()); 683 result[0].clear(); 684 } 685 686 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationLinear) 687 { 688 // Animation to convert 689 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 690 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 691 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25), 692 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5), 693 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 694 695 m_timing.iterationCount = 5; 696 m_timing.direction = Timing::PlaybackDirectionAlternate; 697 m_timing.playbackRate = 2.0; 698 // -- 699 700 WebCompositorSupportMock mockCompositor; 701 702 // Curve is created 703 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); 704 ExpectationSet usesMockCurve; 705 706 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 707 .WillOnce(Return(mockCurvePtr)); 708 709 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 710 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.25, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 711 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, 20.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 712 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); 713 714 // Animation is created 715 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 716 ExpectationSet usesMockAnimation; 717 718 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 719 .WillOnce(Return(mockAnimationPtr)); 720 721 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); 722 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 723 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate)); 724 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(2.0)); 725 726 EXPECT_CALL(*mockAnimationPtr, delete_()) 727 .Times(1) 728 .After(usesMockAnimation); 729 EXPECT_CALL(*mockCurvePtr, delete_()) 730 .Times(1) 731 .After(usesMockCurve); 732 733 // Go! 734 setCompositorForTesting(mockCompositor); 735 Vector<OwnPtr<WebCompositorAnimation> > result; 736 getAnimationOnCompositor(m_timing, *effect.get(), result); 737 EXPECT_EQ(1U, result.size()); 738 result[0].clear(); 739 } 740 741 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationStartDelay) 742 { 743 // Animation to convert 744 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 745 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 746 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 747 748 m_timing.iterationCount = 5.0; 749 m_timing.iterationDuration = 1.75; 750 m_timing.startDelay = 3.25; 751 // -- 752 753 WebCompositorSupportMock mockCompositor; 754 755 // Curve is created 756 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 757 ExpectationSet usesMockCurve; 758 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 759 .WillOnce(Return(mockCurvePtr)); 760 761 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 762 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.75, 5.0))); 763 764 // Create animation 765 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 766 ExpectationSet usesMockAnimation; 767 768 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 769 .WillOnce(Return(mockAnimationPtr)); 770 771 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); 772 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-3.25)); 773 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 774 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 775 776 EXPECT_CALL(*mockAnimationPtr, delete_()) 777 .Times(1) 778 .After(usesMockAnimation); 779 EXPECT_CALL(*mockCurvePtr, delete_()) 780 .Times(1) 781 .After(usesMockCurve); 782 783 // Go! 784 setCompositorForTesting(mockCompositor); 785 Vector<OwnPtr<WebCompositorAnimation> > result; 786 getAnimationOnCompositor(m_timing, *effect.get(), result); 787 EXPECT_EQ(1U, result.size()); 788 result[0].clear(); 789 } 790 791 TEST_F(AnimationCompositorAnimationsTest, createMultipleKeyframeOpacityAnimationChained) 792 { 793 // Animation to convert 794 AnimatableValueKeyframeVector frames; 795 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0)); 796 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25)); 797 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5)); 798 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 799 frames[0]->setEasing(m_cubicEaseTimingFunction.get()); 800 frames[1]->setEasing(m_linearTimingFunction.get()); 801 frames[2]->setEasing(m_cubicCustomTimingFunction.get()); 802 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = AnimatableValueKeyframeEffectModel::create(frames); 803 804 m_timing.timingFunction = m_linearTimingFunction.get(); 805 m_timing.iterationDuration = 2.0; 806 m_timing.iterationCount = 10; 807 m_timing.direction = Timing::PlaybackDirectionAlternate; 808 // -- 809 810 WebCompositorSupportMock mockCompositor; 811 812 // Curve is created 813 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); 814 ExpectationSet usesMockCurve; 815 816 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 817 .WillOnce(Return(mockCurvePtr)); 818 819 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeEase)); 820 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.5, -1.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 821 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 20.0), 1.0, 2.0, 3.0, 4.0)); 822 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(2.0, 5.0))); 823 824 // Animation is created 825 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 826 ExpectationSet usesMockAnimation; 827 828 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 829 .WillOnce(Return(mockAnimationPtr)); 830 831 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); 832 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 833 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternate)); 834 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 835 836 EXPECT_CALL(*mockAnimationPtr, delete_()) 837 .Times(1) 838 .After(usesMockAnimation); 839 EXPECT_CALL(*mockCurvePtr, delete_()) 840 .Times(1) 841 .After(usesMockCurve); 842 843 // Go! 844 setCompositorForTesting(mockCompositor); 845 Vector<OwnPtr<WebCompositorAnimation> > result; 846 getAnimationOnCompositor(m_timing, *effect.get(), result); 847 EXPECT_EQ(1U, result.size()); 848 result[0].clear(); 849 } 850 851 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation) 852 { 853 RefPtr<TimingFunction> cubicEasyFlipTimingFunction = CubicBezierTimingFunction::create(0.0, 0.0, 0.0, 1.0); 854 855 // Animation to convert 856 AnimatableValueKeyframeVector frames; 857 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0)); 858 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25)); 859 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5)); 860 frames.append(createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 861 frames[0]->setEasing(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn)); 862 frames[1]->setEasing(m_linearTimingFunction.get()); 863 frames[2]->setEasing(cubicEasyFlipTimingFunction.get()); 864 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = AnimatableValueKeyframeEffectModel::create(frames); 865 866 m_timing.timingFunction = m_linearTimingFunction.get(); 867 m_timing.iterationCount = 10; 868 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; 869 // -- 870 871 WebCompositorSupportMock mockCompositor; 872 873 // Curve is created 874 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock(); 875 ExpectationSet usesMockCurve; 876 877 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 878 .WillOnce(Return(mockCurvePtr)); 879 880 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeEaseIn)); 881 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.25, -1.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 882 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.5, 20.0), 0.0, 0.0, 0.0, 1.0)); 883 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0, 5.0))); 884 885 // Create the animation 886 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 887 ExpectationSet usesMockAnimation; 888 889 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 890 .WillOnce(Return(mockAnimationPtr)); 891 892 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); 893 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 894 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse)); 895 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 896 897 EXPECT_CALL(*mockAnimationPtr, delete_()) 898 .Times(1) 899 .After(usesMockAnimation); 900 EXPECT_CALL(*mockCurvePtr, delete_()) 901 .Times(1) 902 .After(usesMockCurve); 903 904 // Go! 905 setCompositorForTesting(mockCompositor); 906 Vector<OwnPtr<WebCompositorAnimation> > result; 907 getAnimationOnCompositor(m_timing, *effect.get(), result); 908 EXPECT_EQ(1U, result.size()); 909 result[0].clear(); 910 } 911 912 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimationNegativeStartDelay) 913 { 914 // Animation to convert 915 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 916 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 917 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 918 919 m_timing.iterationCount = 5.0; 920 m_timing.iterationDuration = 1.5; 921 m_timing.startDelay = -3; 922 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; 923 // -- 924 925 WebCompositorSupportMock mockCompositor; 926 927 // Curve is created 928 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 929 ExpectationSet usesMockCurve; 930 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 931 .WillOnce(Return(mockCurvePtr)); 932 933 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0, 2.0), blink::WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 934 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.5, 5.0))); 935 936 // Create animation 937 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 938 ExpectationSet usesMockAnimation; 939 940 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 941 .WillOnce(Return(mockAnimationPtr)); 942 943 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); 944 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(3.0)); 945 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionAlternateReverse)); 946 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 947 948 EXPECT_CALL(*mockAnimationPtr, delete_()) 949 .Times(1) 950 .After(usesMockAnimation); 951 EXPECT_CALL(*mockCurvePtr, delete_()) 952 .Times(1) 953 .After(usesMockCurve); 954 955 // Go! 956 setCompositorForTesting(mockCompositor); 957 Vector<OwnPtr<WebCompositorAnimation> > result; 958 getAnimationOnCompositor(m_timing, *effect.get(), result); 959 EXPECT_EQ(1U, result.size()); 960 result[0].clear(); 961 } 962 963 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationPlaybackRates) 964 { 965 // Animation to convert 966 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 967 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 968 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 969 970 m_timing.playbackRate = 2; 971 // -- 972 973 WebCompositorSupportMock mockCompositor; 974 975 // Curve is created 976 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 977 ExpectationSet usesMockCurve; 978 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 979 .WillOnce(Return(mockCurvePtr)); 980 981 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 982 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); 983 984 // Create animation 985 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 986 ExpectationSet usesMockAnimation; 987 988 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 989 .WillOnce(Return(mockAnimationPtr)); 990 991 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); 992 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 993 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 994 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(-3)); 995 996 EXPECT_CALL(*mockAnimationPtr, delete_()) 997 .Times(1) 998 .After(usesMockAnimation); 999 EXPECT_CALL(*mockCurvePtr, delete_()) 1000 .Times(1) 1001 .After(usesMockCurve); 1002 1003 // Go! 1004 setCompositorForTesting(mockCompositor); 1005 Vector<OwnPtr<WebCompositorAnimation> > result; 1006 // Set player plaback rate also 1007 getAnimationOnCompositor(m_timing, *effect.get(), result, -1.5); 1008 EXPECT_EQ(1U, result.size()); 1009 result[0].clear(); 1010 } 1011 1012 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeNone) 1013 { 1014 // Animation to convert 1015 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 1016 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 1017 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 1018 1019 m_timing.fillMode = Timing::FillModeNone; 1020 1021 WebCompositorSupportMock mockCompositor; 1022 1023 // Curve is created 1024 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 1025 ExpectationSet usesMockCurve; 1026 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 1027 .WillOnce(Return(mockCurvePtr)); 1028 1029 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 1030 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); 1031 1032 // Create animation 1033 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 1034 ExpectationSet usesMockAnimation; 1035 1036 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 1037 .WillOnce(Return(mockAnimationPtr)); 1038 1039 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); 1040 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 1041 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 1042 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 1043 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone)); 1044 1045 EXPECT_CALL(*mockAnimationPtr, delete_()) 1046 .Times(1) 1047 .After(usesMockAnimation); 1048 EXPECT_CALL(*mockCurvePtr, delete_()) 1049 .Times(1) 1050 .After(usesMockCurve); 1051 1052 // Go! 1053 setCompositorForTesting(mockCompositor); 1054 Vector<OwnPtr<WebCompositorAnimation> > result; 1055 getAnimationOnCompositor(m_timing, *effect.get(), result); 1056 EXPECT_EQ(1U, result.size()); 1057 result[0].clear(); 1058 } 1059 1060 TEST_F(AnimationCompositorAnimationsTest, createSimpleOpacityAnimationFillModeAuto) 1061 { 1062 // Animation to convert 1063 RefPtrWillBeRawPtr<AnimatableValueKeyframeEffectModel> effect = createKeyframeEffectModel( 1064 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0), 1065 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0)); 1066 1067 m_timing.fillMode = Timing::FillModeAuto; 1068 1069 WebCompositorSupportMock mockCompositor; 1070 1071 // Curve is created 1072 WebFloatAnimationCurveMock* mockCurvePtr = new WebFloatAnimationCurveMock; 1073 ExpectationSet usesMockCurve; 1074 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) 1075 .WillOnce(Return(mockCurvePtr)); 1076 1077 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(0.0, 2.0), WebCompositorAnimationCurve::TimingFunctionTypeLinear)); 1078 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(WebFloatKeyframe(1.0, 5.0))); 1079 1080 // Create animation 1081 WebCompositorAnimationMock* mockAnimationPtr = new WebCompositorAnimationMock(WebCompositorAnimation::TargetPropertyOpacity); 1082 ExpectationSet usesMockAnimation; 1083 1084 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurvePtr), WebCompositorAnimation::TargetPropertyOpacity, _)) 1085 .WillOnce(Return(mockAnimationPtr)); 1086 1087 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); 1088 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); 1089 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setDirection(blink::WebCompositorAnimation::DirectionNormal)); 1090 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setPlaybackRate(1)); 1091 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setFillMode(blink::WebCompositorAnimation::FillModeNone)); 1092 1093 EXPECT_CALL(*mockAnimationPtr, delete_()) 1094 .Times(1) 1095 .After(usesMockAnimation); 1096 EXPECT_CALL(*mockCurvePtr, delete_()) 1097 .Times(1) 1098 .After(usesMockCurve); 1099 1100 // Go! 1101 setCompositorForTesting(mockCompositor); 1102 Vector<OwnPtr<WebCompositorAnimation> > result; 1103 getAnimationOnCompositor(m_timing, *effect.get(), result); 1104 EXPECT_EQ(1U, result.size()); 1105 result[0].clear(); 1106 } 1107 1108 } // namespace blink 1109
