OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013, Google Inc. All rights reserved. | 2 * Copyright (c) 2013, Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 25 matching lines...) Expand all Loading... |
36 #include "core/animation/AnimatableTransform.h" | 36 #include "core/animation/AnimatableTransform.h" |
37 #include "core/animation/AnimatableValueTestHelper.h" | 37 #include "core/animation/AnimatableValueTestHelper.h" |
38 #include "core/animation/CompositorAnimationsImpl.h" | 38 #include "core/animation/CompositorAnimationsImpl.h" |
39 #include "core/animation/CompositorAnimationsTestHelper.h" | 39 #include "core/animation/CompositorAnimationsTestHelper.h" |
40 #include "core/platform/animation/TimingFunctionTestHelper.h" | 40 #include "core/platform/animation/TimingFunctionTestHelper.h" |
41 #include "core/platform/graphics/filters/FilterOperations.h" | 41 #include "core/platform/graphics/filters/FilterOperations.h" |
42 #include "platform/geometry/IntSize.h" | 42 #include "platform/geometry/IntSize.h" |
43 #include "platform/transforms/TransformOperations.h" | 43 #include "platform/transforms/TransformOperations.h" |
44 #include "platform/transforms/TranslateTransformOperation.h" | 44 #include "platform/transforms/TranslateTransformOperation.h" |
45 #include "public/platform/WebAnimation.h" | 45 #include "public/platform/WebAnimation.h" |
| 46 #include "wtf/HashFunctions.h" |
46 #include "wtf/OwnPtr.h" | 47 #include "wtf/OwnPtr.h" |
47 #include "wtf/PassOwnPtr.h" | 48 #include "wtf/PassOwnPtr.h" |
48 #include "wtf/PassRefPtr.h" | 49 #include "wtf/PassRefPtr.h" |
49 #include "wtf/RefPtr.h" | 50 #include "wtf/RefPtr.h" |
50 | 51 |
51 #include <gmock/gmock.h> | 52 #include <gmock/gmock.h> |
52 #include <gtest/gtest.h> | 53 #include <gtest/gtest.h> |
53 | 54 |
54 namespace WebCore { | 55 namespace WebCore { |
55 | 56 |
56 using ::testing::CloneToPassOwnPtr; | 57 using ::testing::CloneToPassOwnPtr; |
57 using ::testing::ExpectationSet; | 58 using ::testing::ExpectationSet; |
58 using ::testing::Ref; | 59 using ::testing::Ref; |
59 using ::testing::Return; | 60 using ::testing::Return; |
60 using ::testing::_; | 61 using ::testing::_; |
61 | 62 |
62 class CoreAnimationCompositorAnimationsTest : public CoreAnimationCompositorAnim
ationsTestBase { | 63 class CoreAnimationCompositorAnimationsTest : public CoreAnimationCompositorAnim
ationsTestBase { |
63 | 64 |
64 protected: | 65 protected: |
65 RefPtr<TimingFunction> m_linearTimingFunction; | 66 RefPtr<TimingFunction> m_linearTimingFunction; |
66 RefPtr<TimingFunction> m_cubicEaseTimingFunction; | 67 RefPtr<TimingFunction> m_cubicEaseTimingFunction; |
67 RefPtr<TimingFunction> m_cubicCustomTimingFunction; | 68 RefPtr<TimingFunction> m_cubicCustomTimingFunction; |
68 RefPtr<TimingFunction> m_stepTimingFunction; | 69 RefPtr<TimingFunction> m_stepTimingFunction; |
69 | 70 |
70 Timing m_timing; | 71 Timing m_timing; |
| 72 CompositorAnimationsImpl::CompositorTiming m_compositorTiming; |
71 KeyframeAnimationEffect::KeyframeVector m_keyframeVector2; | 73 KeyframeAnimationEffect::KeyframeVector m_keyframeVector2; |
72 KeyframeAnimationEffect::KeyframeVector m_keyframeVector5; | 74 KeyframeAnimationEffect::KeyframeVector m_keyframeVector5; |
73 | 75 |
74 virtual void SetUp() | 76 virtual void SetUp() |
75 { | 77 { |
76 CoreAnimationCompositorAnimationsTestBase::SetUp(); | 78 CoreAnimationCompositorAnimationsTestBase::SetUp(); |
77 | 79 |
78 m_linearTimingFunction = LinearTimingFunction::create(); | 80 m_linearTimingFunction = LinearTimingFunction::create(); |
79 m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezie
rTimingFunction::Ease); | 81 m_cubicEaseTimingFunction = CubicBezierTimingFunction::preset(CubicBezie
rTimingFunction::Ease); |
80 m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3,
4); | 82 m_cubicCustomTimingFunction = CubicBezierTimingFunction::create(1, 2, 3,
4); |
81 m_stepTimingFunction = StepsTimingFunction::create(1, false); | 83 m_stepTimingFunction = StepsTimingFunction::create(1, false); |
82 | 84 |
83 m_timing = createCompositableTiming(); | 85 m_timing = createCompositableTiming(); |
| 86 m_compositorTiming = CompositorAnimationsImpl::CompositorTiming(); |
| 87 // Make sure the CompositableTiming is really compositable, otherwise |
| 88 // most other tests will fail. |
| 89 ASSERT(convertTimingForCompositor(m_timing, m_compositorTiming)); |
84 | 90 |
85 m_keyframeVector2 = createCompositableFloatKeyframeVector(2); | 91 m_keyframeVector2 = createCompositableFloatKeyframeVector(2); |
86 m_keyframeVector5 = createCompositableFloatKeyframeVector(5); | 92 m_keyframeVector5 = createCompositableFloatKeyframeVector(5); |
87 } | 93 } |
88 | 94 |
89 public: | 95 public: |
90 | 96 |
91 bool isCandidateForCompositor(const Timing& t, KeyframeAnimationEffect::Keyf
rameVector& frames) | 97 bool convertTimingForCompositor(const Timing& t, CompositorAnimationsImpl::C
ompositorTiming& out) |
| 98 { |
| 99 return CompositorAnimationsImpl::convertTimingForCompositor(t, out); |
| 100 } |
| 101 bool isCandidateForCompositor(const Timing& t, const KeyframeAnimationEffect
::KeyframeVector& frames) |
92 { | 102 { |
93 return CompositorAnimationsImpl::isCandidateForCompositor(t, frames); | 103 return CompositorAnimationsImpl::isCandidateForCompositor(t, frames); |
94 } | 104 } |
95 bool isCandidateForCompositor(TimingFunction& t, KeyframeAnimationEffect::Ke
yframeVector& frames) | 105 bool isCandidateForCompositor(TimingFunction& t, const KeyframeAnimationEffe
ct::KeyframeVector* frames) |
96 { | 106 { |
97 return CompositorAnimationsImpl::isCandidateForCompositor(t, frames); | 107 return CompositorAnimationsImpl::isCandidateForCompositor(t, frames); |
98 } | 108 } |
99 bool isCandidateForCompositor(const Keyframe& k) | 109 bool isCandidateForCompositor(const Keyframe& k) |
100 { | 110 { |
101 return CompositorAnimationsImpl::isCandidateForCompositor(k); | 111 return CompositorAnimationsImpl::isCandidateForCompositor(k); |
102 } | 112 } |
103 bool isCandidateForCompositor(const KeyframeAnimationEffect& k) | 113 bool isCandidateForCompositor(const KeyframeAnimationEffect& k) |
104 { | 114 { |
105 return CompositorAnimationsImpl::isCandidateForCompositor(k); | 115 return CompositorAnimationsImpl::isCandidateForCompositor(k); |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
220 isCandidateForCompositor( | 230 isCandidateForCompositor( |
221 *createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeR
eplace).get())); | 231 *createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeR
eplace).get())); |
222 | 232 |
223 EXPECT_FALSE( | 233 EXPECT_FALSE( |
224 isCandidateForCompositor( | 234 isCandidateForCompositor( |
225 *createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeA
dd).get())); | 235 *createDefaultKeyframe(CSSPropertyColor, AnimationEffect::CompositeA
dd).get())); |
226 } | 236 } |
227 | 237 |
228 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeMu
ltipleCSSProperties) | 238 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeMu
ltipleCSSProperties) |
229 { | 239 { |
| 240 // In this test, we cheat by using an AnimatableDouble even with Transform |
| 241 // as the actual value isn't considered. |
230 RefPtr<Keyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpa
city, AnimationEffect::CompositeReplace); | 242 RefPtr<Keyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpa
city, AnimationEffect::CompositeReplace); |
231 // Cheat by using an AnimatableDouble as creating a AnimatableTransform is m
uch harder. | |
232 keyframeGoodMultiple->setPropertyValue(CSSPropertyWebkitTransform, Animatabl
eDouble::create(10.0).get()); | 243 keyframeGoodMultiple->setPropertyValue(CSSPropertyWebkitTransform, Animatabl
eDouble::create(10.0).get()); |
233 EXPECT_TRUE(isCandidateForCompositor(*keyframeGoodMultiple.get())); | 244 EXPECT_TRUE(isCandidateForCompositor(*keyframeGoodMultiple.get())); |
234 | 245 |
235 RefPtr<Keyframe> keyframeBadMultipleOp = createDefaultKeyframe(CSSPropertyOp
acity, AnimationEffect::CompositeAdd); | 246 RefPtr<Keyframe> keyframeBadMultipleOp = createDefaultKeyframe(CSSPropertyOp
acity, AnimationEffect::CompositeAdd); |
236 // Cheat by using an AnimatableDouble as creating a AnimatableTransform is m
uch harder. | |
237 keyframeBadMultipleOp->setPropertyValue(CSSPropertyWebkitTransform, Animatab
leDouble::create(10.0).get()); | 247 keyframeBadMultipleOp->setPropertyValue(CSSPropertyWebkitTransform, Animatab
leDouble::create(10.0).get()); |
238 EXPECT_FALSE(isCandidateForCompositor(*keyframeBadMultipleOp.get())); | 248 EXPECT_FALSE(isCandidateForCompositor(*keyframeBadMultipleOp.get())); |
239 | 249 |
240 RefPtr<Keyframe> keyframeBadMultipleID = createDefaultKeyframe(CSSPropertyOp
acity, AnimationEffect::CompositeReplace); | 250 // Check both an unsupported property which hashes before and after the |
241 keyframeBadMultipleID->setPropertyValue(CSSPropertyColor, AnimatableDouble::
create(10.0).get()); | 251 // supported property. |
242 EXPECT_FALSE(isCandidateForCompositor(*keyframeBadMultipleID.get())); | 252 typedef DefaultHash<CSSPropertyID>::Hash HashFunctions; |
| 253 |
| 254 RefPtr<Keyframe> keyframeBadMultiple1ID = createDefaultKeyframe(CSSPropertyC
olor, AnimationEffect::CompositeReplace); |
| 255 keyframeBadMultiple1ID->setPropertyValue(CSSPropertyOpacity, AnimatableDoubl
e::create(10.0).get()); |
| 256 EXPECT_FALSE(isCandidateForCompositor(*keyframeBadMultiple1ID.get())); |
| 257 EXPECT_LT(HashFunctions::hash(CSSPropertyColor), HashFunctions::hash(CSSProp
ertyOpacity)); |
| 258 |
| 259 RefPtr<Keyframe> keyframeBadMultiple2ID = createDefaultKeyframe(CSSPropertyW
ebkitTransform, AnimationEffect::CompositeReplace); |
| 260 keyframeBadMultiple2ID->setPropertyValue(CSSPropertyWidth, AnimatableDouble:
:create(10.0).get()); |
| 261 EXPECT_FALSE(isCandidateForCompositor(*keyframeBadMultiple2ID.get())); |
| 262 EXPECT_GT(HashFunctions::hash(CSSPropertyWebkitTransform), HashFunctions::ha
sh(CSSPropertyWidth)); |
243 } | 263 } |
244 | 264 |
245 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeEf
fectGoodSingleFrame) | 265 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeEf
fectGoodSingleFrame) |
246 { | 266 { |
247 KeyframeAnimationEffect::KeyframeVector frames; | 267 KeyframeAnimationEffect::KeyframeVector frames; |
248 frames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::Com
positeReplace).get()); | 268 frames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::Com
positeReplace).get()); |
249 EXPECT_TRUE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frames
).get())); | 269 EXPECT_TRUE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frames
).get())); |
250 } | 270 } |
251 | 271 |
252 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeEf
fectBadSingleFrame) | 272 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorKeyframeEf
fectBadSingleFrame) |
(...skipping 27 matching lines...) Expand all Loading... |
280 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyOpacity, Anima
tionEffect::CompositeReplace, 0.0).get()); | 300 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyOpacity, Anima
tionEffect::CompositeReplace, 0.0).get()); |
281 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyColor, Animati
onEffect::CompositeReplace, 1.0).get()); | 301 framesMixedProperties.append(createDefaultKeyframe(CSSPropertyColor, Animati
onEffect::CompositeReplace, 1.0).get()); |
282 EXPECT_FALSE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frame
sMixedProperties).get())); | 302 EXPECT_FALSE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frame
sMixedProperties).get())); |
283 | 303 |
284 KeyframeAnimationEffect::KeyframeVector framesMixedOps; | 304 KeyframeAnimationEffect::KeyframeVector framesMixedOps; |
285 framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEff
ect::CompositeReplace, 0.0).get()); | 305 framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEff
ect::CompositeReplace, 0.0).get()); |
286 framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEff
ect::CompositeAdd, 1.0).get()); | 306 framesMixedOps.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEff
ect::CompositeAdd, 1.0).get()); |
287 EXPECT_FALSE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frame
sMixedOps).get())); | 307 EXPECT_FALSE(isCandidateForCompositor(*KeyframeAnimationEffect::create(frame
sMixedOps).get())); |
288 } | 308 } |
289 | 309 |
290 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingStar
tDelay) | 310 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorStartDel
ay) |
291 { | 311 { |
| 312 m_timing.iterationDuration = 20.0; |
| 313 |
292 m_timing.startDelay = 2.0; | 314 m_timing.startDelay = 2.0; |
| 315 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 316 |
| 317 m_timing.startDelay = -2.0; |
| 318 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 319 EXPECT_DOUBLE_EQ(-2.0, m_compositorTiming.scaledTimeOffset); |
| 320 } |
| 321 |
| 322 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorIteratio
nStart) |
| 323 { |
| 324 m_timing.iterationStart = 2.2; |
| 325 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 326 } |
| 327 |
| 328 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorIteratio
nCount) |
| 329 { |
| 330 m_timing.iterationCount = 5.0; |
| 331 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 332 EXPECT_EQ(5, m_compositorTiming.adjustedIterationCount); |
| 333 |
| 334 m_timing.iterationCount = 5.5; |
| 335 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 336 |
| 337 m_timing.iterationCount = std::numeric_limits<double>::infinity(); |
| 338 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 339 |
| 340 #ifndef NDEBUG |
| 341 m_timing.iterationCount = -1; |
| 342 EXPECT_DEATH(convertTimingForCompositor(m_timing, m_compositorTiming), ""); |
| 343 #endif |
| 344 } |
| 345 |
| 346 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorIteratio
nsAndStartDelay) |
| 347 { |
| 348 m_timing.iterationCount = 4.0; |
| 349 m_timing.iterationDuration = 5.0; |
| 350 |
| 351 m_timing.startDelay = -6.0; |
| 352 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 353 EXPECT_DOUBLE_EQ(-1.0, m_compositorTiming.scaledTimeOffset); |
| 354 EXPECT_DOUBLE_EQ(3.0, m_compositorTiming.adjustedIterationCount); |
| 355 EXPECT_FALSE(m_compositorTiming.reverse); |
| 356 |
| 357 m_timing.iterationCount = 1.0; |
| 358 m_timing.iterationDuration = 5.0; |
| 359 m_timing.startDelay = -6.0; |
| 360 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 361 |
| 362 m_timing.iterationCount = 5.0; |
| 363 m_timing.iterationDuration = 1.0; |
| 364 m_timing.startDelay = -6.0; |
| 365 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 366 } |
| 367 |
| 368 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorPlayback
Rate) |
| 369 { |
| 370 m_timing.playbackRate = 2.0; |
| 371 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 372 |
| 373 m_timing.playbackRate = 0.0; |
| 374 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 375 |
| 376 m_timing.playbackRate = -2.0; |
| 377 EXPECT_FALSE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 378 } |
| 379 |
| 380 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectio
n) |
| 381 { |
| 382 m_timing.direction = Timing::PlaybackDirectionAlternate; |
| 383 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 384 EXPECT_TRUE(m_compositorTiming.alternate); |
| 385 EXPECT_FALSE(m_compositorTiming.reverse); |
| 386 |
| 387 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; |
| 388 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 389 EXPECT_TRUE(m_compositorTiming.alternate); |
| 390 EXPECT_TRUE(m_compositorTiming.reverse); |
| 391 |
| 392 m_timing.direction = Timing::PlaybackDirectionReverse; |
| 393 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 394 EXPECT_FALSE(m_compositorTiming.alternate); |
| 395 EXPECT_TRUE(m_compositorTiming.reverse); |
| 396 } |
| 397 |
| 398 TEST_F(CoreAnimationCompositorAnimationsTest, ConvertTimingForCompositorDirectio
nIterationsAndStartDelay) |
| 399 { |
| 400 m_timing.direction = Timing::PlaybackDirectionAlternate; |
| 401 m_timing.iterationCount = 4.0; |
| 402 m_timing.iterationDuration = 5.0; |
| 403 m_timing.startDelay = -6.0; |
| 404 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 405 EXPECT_DOUBLE_EQ(-1.0, m_compositorTiming.scaledTimeOffset); |
| 406 EXPECT_EQ(3, m_compositorTiming.adjustedIterationCount); |
| 407 EXPECT_TRUE(m_compositorTiming.alternate); |
| 408 EXPECT_TRUE(m_compositorTiming.reverse); |
| 409 |
| 410 m_timing.direction = Timing::PlaybackDirectionAlternate; |
| 411 m_timing.iterationCount = 4.0; |
| 412 m_timing.iterationDuration = 5.0; |
| 413 m_timing.startDelay = -11.0; |
| 414 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 415 EXPECT_DOUBLE_EQ(-1.0, m_compositorTiming.scaledTimeOffset); |
| 416 EXPECT_EQ(2, m_compositorTiming.adjustedIterationCount); |
| 417 EXPECT_TRUE(m_compositorTiming.alternate); |
| 418 EXPECT_FALSE(m_compositorTiming.reverse); |
| 419 |
| 420 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; |
| 421 m_timing.iterationCount = 4.0; |
| 422 m_timing.iterationDuration = 5.0; |
| 423 m_timing.startDelay = -6.0; |
| 424 EXPECT_TRUE(convertTimingForCompositor(m_timing, m_compositorTiming)); |
| 425 EXPECT_DOUBLE_EQ(-1.0, m_compositorTiming.scaledTimeOffset); |
| 426 EXPECT_EQ(3, m_compositorTiming.adjustedIterationCount); |
| 427 EXPECT_TRUE(m_compositorTiming.alternate); |
| 428 EXPECT_FALSE(m_compositorTiming.reverse); |
| 429 |
| 430 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; |
| 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(-1.0, m_compositorTiming.scaledTimeOffset); |
| 436 EXPECT_EQ(2, m_compositorTiming.adjustedIterationCount); |
| 437 EXPECT_TRUE(m_compositorTiming.alternate); |
| 438 EXPECT_TRUE(m_compositorTiming.reverse); |
| 439 } |
| 440 |
| 441 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTiming) |
| 442 { |
293 EXPECT_TRUE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | 443 EXPECT_TRUE(isCandidateForCompositor(m_timing, m_keyframeVector2)); |
294 | 444 |
295 m_timing.iterationCount = 5.0; | |
296 m_timing.startDelay = 2.0; | 445 m_timing.startDelay = 2.0; |
297 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | 446 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); |
298 | |
299 m_timing.iterationCount = 5.0; | |
300 m_timing.startDelay = -2.0; | |
301 EXPECT_TRUE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
302 } | |
303 | |
304 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFill
Mode) | |
305 { | |
306 m_timing.fillMode = Timing::FillModeForwards; | |
307 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
308 } | 447 } |
309 | 448 |
310 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingIter
ationStart) | |
311 { | |
312 m_timing.iterationStart = 2.2; | |
313 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
314 } | |
315 | |
316 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingIter
ationCount) | |
317 { | |
318 m_timing.iterationCount = 5.0; | |
319 EXPECT_TRUE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
320 | |
321 m_timing.iterationCount = 5.5; | |
322 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
323 | |
324 m_timing.iterationCount = -1.0; | |
325 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
326 | |
327 m_timing.iterationCount = std::numeric_limits<double>::infinity(); | |
328 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
329 | |
330 m_timing.iterationCount = -std::numeric_limits<double>::infinity(); | |
331 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
332 } | |
333 | |
334 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingIter
ationDuration) | |
335 { | |
336 m_timing.hasIterationDuration = false; | |
337 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
338 } | |
339 | |
340 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingPlay
backRate) | |
341 { | |
342 m_timing.playbackRate = 2.0; | |
343 EXPECT_TRUE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | |
344 } | |
345 | |
346 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingTimi
ngFunctionPassThru) | 449 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingTimi
ngFunctionPassThru) |
347 { | 450 { |
348 m_timing.timingFunction = m_stepTimingFunction; | 451 m_timing.timingFunction = m_stepTimingFunction; |
349 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); | 452 EXPECT_FALSE(isCandidateForCompositor(m_timing, m_keyframeVector2)); |
350 } | 453 } |
351 | 454 |
352 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionLinear) | 455 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionLinear) |
353 { | 456 { |
354 EXPECT_TRUE(isCandidateForCompositor(*m_linearTimingFunction.get(), m_keyfra
meVector2)); | 457 EXPECT_TRUE(isCandidateForCompositor(*m_linearTimingFunction.get(), &m_keyfr
ameVector2)); |
355 EXPECT_TRUE(isCandidateForCompositor(*m_linearTimingFunction.get(), m_keyfra
meVector5)); | 458 EXPECT_TRUE(isCandidateForCompositor(*m_linearTimingFunction.get(), &m_keyfr
ameVector5)); |
356 } | 459 } |
357 | 460 |
358 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionCubic) | 461 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionCubic) |
359 { | 462 { |
360 // Cubic bezier are okay if we only have two keyframes | 463 // Cubic bezier are okay if we only have two keyframes |
361 EXPECT_TRUE(isCandidateForCompositor(*m_cubicEaseTimingFunction.get(), m_key
frameVector2)); | 464 EXPECT_TRUE(isCandidateForCompositor(*m_cubicEaseTimingFunction.get(), &m_ke
yframeVector2)); |
362 EXPECT_FALSE(isCandidateForCompositor(*m_cubicEaseTimingFunction.get(), m_ke
yframeVector5)); | 465 EXPECT_FALSE(isCandidateForCompositor(*m_cubicEaseTimingFunction.get(), &m_k
eyframeVector5)); |
363 | 466 |
364 EXPECT_TRUE(isCandidateForCompositor(*m_cubicCustomTimingFunction.get(), m_k
eyframeVector2)); | 467 EXPECT_TRUE(isCandidateForCompositor(*m_cubicCustomTimingFunction.get(), &m_
keyframeVector2)); |
365 EXPECT_FALSE(isCandidateForCompositor(*m_cubicCustomTimingFunction.get(), m_
keyframeVector5)); | 468 EXPECT_FALSE(isCandidateForCompositor(*m_cubicCustomTimingFunction.get(), &m
_keyframeVector5)); |
366 } | 469 } |
367 | 470 |
368 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionSteps) | 471 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionSteps) |
369 { | 472 { |
370 RefPtr<TimingFunction> stepTiming = StepsTimingFunction::create(1, false); | 473 RefPtr<TimingFunction> stepTiming = StepsTimingFunction::create(1, false); |
371 EXPECT_FALSE(isCandidateForCompositor(*m_stepTimingFunction.get(), m_keyfram
eVector2)); | 474 EXPECT_FALSE(isCandidateForCompositor(*m_stepTimingFunction.get(), &m_keyfra
meVector2)); |
372 EXPECT_FALSE(isCandidateForCompositor(*m_stepTimingFunction.get(), m_keyfram
eVector5)); | 475 EXPECT_FALSE(isCandidateForCompositor(*m_stepTimingFunction.get(), &m_keyfra
meVector5)); |
373 } | 476 } |
374 | 477 |
375 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedEmpty) | 478 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedEmpty) |
376 { | 479 { |
377 RefPtr<ChainedTimingFunction> chainedEmpty = ChainedTimingFunction::create()
; | 480 RefPtr<ChainedTimingFunction> chainedEmpty = ChainedTimingFunction::create()
; |
378 EXPECT_FALSE(isCandidateForCompositor(*chainedEmpty.get(), m_keyframeVector2
)); | 481 EXPECT_FALSE(isCandidateForCompositor(*chainedEmpty.get(), &m_keyframeVector
2)); |
379 EXPECT_FALSE(isCandidateForCompositor(*chainedEmpty.get(), m_keyframeVector5
)); | 482 EXPECT_FALSE(isCandidateForCompositor(*chainedEmpty.get(), &m_keyframeVector
5)); |
380 } | 483 } |
381 | 484 |
382 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedLinear) | 485 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedLinear) |
383 { | 486 { |
384 RefPtr<ChainedTimingFunction> chainedLinearSingle = ChainedTimingFunction::c
reate(); | 487 RefPtr<ChainedTimingFunction> chainedLinearSingle = ChainedTimingFunction::c
reate(); |
385 chainedLinearSingle->appendSegment(1.0, m_linearTimingFunction.get()); | 488 chainedLinearSingle->appendSegment(1.0, m_linearTimingFunction.get()); |
386 EXPECT_TRUE(isCandidateForCompositor(*chainedLinearSingle.get(), m_keyframeV
ector2)); | 489 EXPECT_TRUE(isCandidateForCompositor(*chainedLinearSingle.get(), &m_keyframe
Vector2)); |
387 | 490 |
388 RefPtr<ChainedTimingFunction> chainedLinearMultiple = ChainedTimingFunction:
:create(); | 491 RefPtr<ChainedTimingFunction> chainedLinearMultiple = ChainedTimingFunction:
:create(); |
389 chainedLinearMultiple->appendSegment(0.25, m_linearTimingFunction.get()); | 492 chainedLinearMultiple->appendSegment(0.25, m_linearTimingFunction.get()); |
390 chainedLinearMultiple->appendSegment(0.5, m_linearTimingFunction.get()); | 493 chainedLinearMultiple->appendSegment(0.5, m_linearTimingFunction.get()); |
391 chainedLinearMultiple->appendSegment(0.75, m_linearTimingFunction.get()); | 494 chainedLinearMultiple->appendSegment(0.75, m_linearTimingFunction.get()); |
392 chainedLinearMultiple->appendSegment(1.0, m_linearTimingFunction.get()); | 495 chainedLinearMultiple->appendSegment(1.0, m_linearTimingFunction.get()); |
393 EXPECT_TRUE(isCandidateForCompositor(*chainedLinearMultiple.get(), m_keyfram
eVector5)); | 496 EXPECT_TRUE(isCandidateForCompositor(*chainedLinearMultiple.get(), &m_keyfra
meVector5)); |
394 | 497 |
395 // FIXME: Technically a chained timing function of linear functions don't | 498 // FIXME: Technically a chained timing function of linear functions don't |
396 // have to be aligned to keyframes. We don't support that currently as | 499 // have to be aligned to keyframes. We don't support that currently as |
397 // nothing generates that yet. | 500 // nothing generates that yet. |
398 } | 501 } |
399 | 502 |
400 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedCubicMatchingOffsets) | 503 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedCubicMatchingOffsets) |
401 { | 504 { |
402 RefPtr<ChainedTimingFunction> chainedSingleAGood = ChainedTimingFunction::cr
eate(); | 505 RefPtr<ChainedTimingFunction> chainedSingleAGood = ChainedTimingFunction::cr
eate(); |
403 chainedSingleAGood->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 506 chainedSingleAGood->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
404 EXPECT_TRUE(isCandidateForCompositor(*chainedSingleAGood.get(), m_keyframeVe
ctor2)); | 507 EXPECT_TRUE(isCandidateForCompositor(*chainedSingleAGood.get(), &m_keyframeV
ector2)); |
405 | 508 |
406 RefPtr<ChainedTimingFunction> chainedSingleBGood = ChainedTimingFunction::cr
eate(); | 509 RefPtr<ChainedTimingFunction> chainedSingleBGood = ChainedTimingFunction::cr
eate(); |
407 chainedSingleBGood->appendSegment(1.0, m_cubicCustomTimingFunction.get()); | 510 chainedSingleBGood->appendSegment(1.0, m_cubicCustomTimingFunction.get()); |
408 EXPECT_TRUE(isCandidateForCompositor(*chainedSingleBGood.get(), m_keyframeVe
ctor2)); | 511 EXPECT_TRUE(isCandidateForCompositor(*chainedSingleBGood.get(), &m_keyframeV
ector2)); |
409 | 512 |
410 RefPtr<ChainedTimingFunction> chainedMultipleGood = ChainedTimingFunction::c
reate(); | 513 RefPtr<ChainedTimingFunction> chainedMultipleGood = ChainedTimingFunction::c
reate(); |
411 chainedMultipleGood->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 514 chainedMultipleGood->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
412 chainedMultipleGood->appendSegment(0.5, m_cubicCustomTimingFunction.get()); | 515 chainedMultipleGood->appendSegment(0.5, m_cubicCustomTimingFunction.get()); |
413 chainedMultipleGood->appendSegment(0.75, m_cubicCustomTimingFunction.get()); | 516 chainedMultipleGood->appendSegment(0.75, m_cubicCustomTimingFunction.get()); |
414 chainedMultipleGood->appendSegment(1.0, m_cubicCustomTimingFunction.get()); | 517 chainedMultipleGood->appendSegment(1.0, m_cubicCustomTimingFunction.get()); |
415 EXPECT_TRUE(isCandidateForCompositor(*chainedMultipleGood.get(), m_keyframeV
ector5)); | 518 EXPECT_TRUE(isCandidateForCompositor(*chainedMultipleGood.get(), &m_keyframe
Vector5)); |
416 } | 519 } |
417 | 520 |
418 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedCubicNonMatchingOffsets) | 521 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionChainedCubicNonMatchingOffsets) |
419 { | 522 { |
420 RefPtr<ChainedTimingFunction> chained0 = ChainedTimingFunction::create(); | 523 RefPtr<ChainedTimingFunction> chained0 = ChainedTimingFunction::create(); |
421 chained0->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 524 chained0->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
422 EXPECT_FALSE(isCandidateForCompositor(*chained0.get(), m_keyframeVector2)); | 525 EXPECT_FALSE(isCandidateForCompositor(*chained0.get(), &m_keyframeVector2)); |
423 | 526 |
424 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); | 527 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); |
425 chained1->appendSegment(0.24, m_cubicEaseTimingFunction.get()); | 528 chained1->appendSegment(0.24, m_cubicEaseTimingFunction.get()); |
426 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 529 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
427 chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 530 chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
428 chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 531 chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
429 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), m_keyframeVector5)); | 532 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), &m_keyframeVector5)); |
430 | 533 |
431 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); | 534 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); |
432 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 535 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
433 chained2->appendSegment(0.51, m_cubicEaseTimingFunction.get()); | 536 chained2->appendSegment(0.51, m_cubicEaseTimingFunction.get()); |
434 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 537 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
435 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 538 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
436 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), m_keyframeVector5)); | 539 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), &m_keyframeVector5)); |
437 | 540 |
438 RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create(); | 541 RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create(); |
439 chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 542 chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
440 chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 543 chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
441 chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 544 chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
442 chained3->appendSegment(0.8, m_cubicEaseTimingFunction.get()); | 545 chained3->appendSegment(0.8, m_cubicEaseTimingFunction.get()); |
443 EXPECT_FALSE(isCandidateForCompositor(*chained3.get(), m_keyframeVector5)); | 546 EXPECT_FALSE(isCandidateForCompositor(*chained3.get(), &m_keyframeVector5)); |
444 | 547 |
445 RefPtr<ChainedTimingFunction> chained4 = ChainedTimingFunction::create(); | 548 RefPtr<ChainedTimingFunction> chained4 = ChainedTimingFunction::create(); |
446 chained4->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 549 chained4->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
447 chained4->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 550 chained4->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
448 chained4->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 551 chained4->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
449 chained4->appendSegment(1.1, m_cubicEaseTimingFunction.get()); | 552 chained4->appendSegment(1.1, m_cubicEaseTimingFunction.get()); |
450 EXPECT_FALSE(isCandidateForCompositor(*chained4.get(), m_keyframeVector5)); | 553 EXPECT_FALSE(isCandidateForCompositor(*chained4.get(), &m_keyframeVector5)); |
451 } | 554 } |
452 | 555 |
453 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionMissingFrames) | 556 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionMissingFrames) |
454 { | 557 { |
455 // Missing first | 558 // Missing first |
456 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); | 559 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); |
457 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 560 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
458 chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 561 chained1->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
459 chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 562 chained1->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
460 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), m_keyframeVector5)); | 563 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), &m_keyframeVector5)); |
461 | 564 |
462 // Missing middle | 565 // Missing middle |
463 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); | 566 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); |
464 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 567 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
465 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 568 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
466 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 569 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
467 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), m_keyframeVector5)); | 570 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), &m_keyframeVector5)); |
468 | 571 |
469 // Missing last | 572 // Missing last |
470 RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create(); | 573 RefPtr<ChainedTimingFunction> chained3 = ChainedTimingFunction::create(); |
471 chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 574 chained3->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
472 chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 575 chained3->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
473 chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 576 chained3->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
474 EXPECT_FALSE(isCandidateForCompositor(*chained3.get(), m_keyframeVector5)); | 577 EXPECT_FALSE(isCandidateForCompositor(*chained3.get(), &m_keyframeVector5)); |
475 } | 578 } |
476 | 579 |
477 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionToManyFrames) | 580 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionToManyFrames) |
478 { | 581 { |
479 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); | 582 RefPtr<ChainedTimingFunction> chained1 = ChainedTimingFunction::create(); |
480 chained1->appendSegment(0.1, m_cubicEaseTimingFunction.get()); | 583 chained1->appendSegment(0.1, m_cubicEaseTimingFunction.get()); |
481 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 584 chained1->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
482 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), m_keyframeVector2)); | 585 EXPECT_FALSE(isCandidateForCompositor(*chained1.get(), &m_keyframeVector2)); |
483 | 586 |
484 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); | 587 RefPtr<ChainedTimingFunction> chained2 = ChainedTimingFunction::create(); |
485 chained2->appendSegment(0.1, m_cubicEaseTimingFunction.get()); | 588 chained2->appendSegment(0.1, m_cubicEaseTimingFunction.get()); |
486 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); | 589 chained2->appendSegment(0.25, m_cubicEaseTimingFunction.get()); |
487 chained2->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 590 chained2->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
488 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 591 chained2->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
489 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 592 chained2->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
490 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), m_keyframeVector5)); | 593 EXPECT_FALSE(isCandidateForCompositor(*chained2.get(), &m_keyframeVector5)); |
491 } | 594 } |
492 | 595 |
493 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionMixedGood) | 596 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionMixedGood) |
494 { | 597 { |
495 RefPtr<ChainedTimingFunction> chainedMixed = ChainedTimingFunction::create()
; | 598 RefPtr<ChainedTimingFunction> chainedMixed = ChainedTimingFunction::create()
; |
496 chainedMixed->appendSegment(0.25, m_linearTimingFunction.get()); | 599 chainedMixed->appendSegment(0.25, m_linearTimingFunction.get()); |
497 chainedMixed->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 600 chainedMixed->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
498 chainedMixed->appendSegment(0.75, m_cubicEaseTimingFunction.get()); | 601 chainedMixed->appendSegment(0.75, m_cubicEaseTimingFunction.get()); |
499 chainedMixed->appendSegment(1.0, m_linearTimingFunction.get()); | 602 chainedMixed->appendSegment(1.0, m_linearTimingFunction.get()); |
500 EXPECT_TRUE(isCandidateForCompositor(*chainedMixed.get(), m_keyframeVector5)
); | 603 EXPECT_TRUE(isCandidateForCompositor(*chainedMixed.get(), &m_keyframeVector5
)); |
501 } | 604 } |
502 | 605 |
503 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionWithStepNotOkay) | 606 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionWithStepNotOkay) |
504 { | 607 { |
505 RefPtr<ChainedTimingFunction> chainedStepSingle = ChainedTimingFunction::cre
ate(); | 608 RefPtr<ChainedTimingFunction> chainedStepSingle = ChainedTimingFunction::cre
ate(); |
506 chainedStepSingle->appendSegment(1.0, m_stepTimingFunction.get()); | 609 chainedStepSingle->appendSegment(1.0, m_stepTimingFunction.get()); |
507 EXPECT_FALSE(isCandidateForCompositor(*chainedStepSingle.get(), m_keyframeVe
ctor2)); | 610 EXPECT_FALSE(isCandidateForCompositor(*chainedStepSingle.get(), &m_keyframeV
ector2)); |
508 | 611 |
509 RefPtr<ChainedTimingFunction> chainedStepMixedA = ChainedTimingFunction::cre
ate(); | 612 RefPtr<ChainedTimingFunction> chainedStepMixedA = ChainedTimingFunction::cre
ate(); |
510 chainedStepMixedA->appendSegment(0.25, m_stepTimingFunction.get()); | 613 chainedStepMixedA->appendSegment(0.25, m_stepTimingFunction.get()); |
511 chainedStepMixedA->appendSegment(0.5, m_linearTimingFunction.get()); | 614 chainedStepMixedA->appendSegment(0.5, m_linearTimingFunction.get()); |
512 chainedStepMixedA->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 615 chainedStepMixedA->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
513 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedA.get(), m_keyframeVe
ctor5)); | 616 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedA.get(), &m_keyframeV
ector5)); |
514 | 617 |
515 RefPtr<ChainedTimingFunction> chainedStepMixedB = ChainedTimingFunction::cre
ate(); | 618 RefPtr<ChainedTimingFunction> chainedStepMixedB = ChainedTimingFunction::cre
ate(); |
516 chainedStepMixedB->appendSegment(0.25, m_linearTimingFunction.get()); | 619 chainedStepMixedB->appendSegment(0.25, m_linearTimingFunction.get()); |
517 chainedStepMixedB->appendSegment(0.5, m_stepTimingFunction.get()); | 620 chainedStepMixedB->appendSegment(0.5, m_stepTimingFunction.get()); |
518 chainedStepMixedB->appendSegment(1.0, m_cubicEaseTimingFunction.get()); | 621 chainedStepMixedB->appendSegment(1.0, m_cubicEaseTimingFunction.get()); |
519 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedB.get(), m_keyframeVe
ctor5)); | 622 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedB.get(), &m_keyframeV
ector5)); |
520 | 623 |
521 RefPtr<ChainedTimingFunction> chainedStepMixedC = ChainedTimingFunction::cre
ate(); | 624 RefPtr<ChainedTimingFunction> chainedStepMixedC = ChainedTimingFunction::cre
ate(); |
522 chainedStepMixedC->appendSegment(0.25, m_linearTimingFunction.get()); | 625 chainedStepMixedC->appendSegment(0.25, m_linearTimingFunction.get()); |
523 chainedStepMixedC->appendSegment(0.5, m_cubicEaseTimingFunction.get()); | 626 chainedStepMixedC->appendSegment(0.5, m_cubicEaseTimingFunction.get()); |
524 chainedStepMixedC->appendSegment(1.0, m_stepTimingFunction.get()); | 627 chainedStepMixedC->appendSegment(1.0, m_stepTimingFunction.get()); |
525 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedC.get(), m_keyframeVe
ctor5)); | 628 EXPECT_FALSE(isCandidateForCompositor(*chainedStepMixedC.get(), &m_keyframeV
ector5)); |
526 } | 629 } |
527 | 630 |
528 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionNestedNotOkay) | 631 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositorTimingFunc
tionNestedNotOkay) |
529 { | 632 { |
530 RefPtr<ChainedTimingFunction> chainedChild = ChainedTimingFunction::create()
; | 633 RefPtr<ChainedTimingFunction> chainedChild = ChainedTimingFunction::create()
; |
531 chainedChild->appendSegment(1.0, m_linearTimingFunction.get()); | 634 chainedChild->appendSegment(1.0, m_linearTimingFunction.get()); |
532 | 635 |
533 RefPtr<ChainedTimingFunction> chainedParent = ChainedTimingFunction::create(
); | 636 RefPtr<ChainedTimingFunction> chainedParent = ChainedTimingFunction::create(
); |
534 chainedParent->appendSegment(0.25, m_linearTimingFunction.get()); | 637 chainedParent->appendSegment(0.25, m_linearTimingFunction.get()); |
535 chainedParent->appendSegment(0.5, chainedChild.get()); | 638 chainedParent->appendSegment(0.5, chainedChild.get()); |
536 chainedParent->appendSegment(0.75, m_linearTimingFunction.get()); | 639 chainedParent->appendSegment(0.75, m_linearTimingFunction.get()); |
537 chainedParent->appendSegment(1.0, m_linearTimingFunction.get()); | 640 chainedParent->appendSegment(1.0, m_linearTimingFunction.get()); |
538 EXPECT_FALSE(isCandidateForCompositor(*chainedParent.get(), m_keyframeVector
5)); | 641 EXPECT_FALSE(isCandidateForCompositor(*chainedParent.get(), &m_keyframeVecto
r5)); |
539 } | 642 } |
540 | 643 |
541 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositor) | 644 TEST_F(CoreAnimationCompositorAnimationsTest, isCandidateForCompositor) |
542 { | 645 { |
543 Timing linearTiming(createCompositableTiming()); | 646 Timing linearTiming(createCompositableTiming()); |
544 | 647 |
545 RefPtr<TimingFunction> cubicTimingFunc = CubicBezierTimingFunction::preset(C
ubicBezierTimingFunction::EaseIn); | 648 RefPtr<TimingFunction> cubicTimingFunc = CubicBezierTimingFunction::preset(C
ubicBezierTimingFunction::EaseIn); |
546 Timing cubicTiming(createCompositableTiming()); | 649 Timing cubicTiming(createCompositableTiming()); |
547 cubicTiming.timingFunction = cubicTimingFunc; | 650 cubicTiming.timingFunction = cubicTimingFunc; |
548 | 651 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
596 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); | 699 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); |
597 | 700 |
598 // Create animation | 701 // Create animation |
599 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 702 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
600 ExpectationSet usesMockAnimation; | 703 ExpectationSet usesMockAnimation; |
601 | 704 |
602 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 705 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
603 .WillOnce(Return(mockAnimationPtr)); | 706 .WillOnce(Return(mockAnimationPtr)); |
604 | 707 |
605 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); | 708 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); |
| 709 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); |
606 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); | 710 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); |
607 | 711 |
608 EXPECT_CALL(*mockAnimationPtr, delete_()) | 712 EXPECT_CALL(*mockAnimationPtr, delete_()) |
609 .Times(1) | 713 .Times(1) |
610 .After(usesMockAnimation); | 714 .After(usesMockAnimation); |
611 EXPECT_CALL(*mockCurvePtr, delete_()) | 715 EXPECT_CALL(*mockCurvePtr, delete_()) |
612 .Times(1) | 716 .Times(1) |
613 .After(usesMockCurve); | 717 .After(usesMockCurve); |
614 | 718 |
615 // Go! | 719 // Go! |
616 setCompositorForTesting(mockCompositor); | 720 setCompositorForTesting(mockCompositor); |
617 Vector<OwnPtr<blink::WebAnimation> > result; | 721 Vector<OwnPtr<blink::WebAnimation> > result; |
618 getCompositorAnimations(m_timing, *effect.get(), result); | 722 getCompositorAnimations(m_timing, *effect.get(), result); |
619 EXPECT_EQ(1U, result.size()); | 723 EXPECT_EQ(1U, result.size()); |
620 result[0].clear(); | 724 result[0].clear(); |
621 } | 725 } |
622 | 726 |
623 TEST_F(CoreAnimationCompositorAnimationsTest, createSimpleOpacityAnimationDurati
onPlaybackOffset) | 727 TEST_F(CoreAnimationCompositorAnimationsTest, createSimpleOpacityAnimationDurati
on) |
624 { | 728 { |
625 // Animation to convert | 729 // Animation to convert |
626 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( | 730 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( |
627 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), | 731 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), |
628 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); | 732 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); |
629 | 733 |
630 m_timing.iterationDuration = 10.0; | 734 m_timing.iterationDuration = 10.0; |
631 m_timing.playbackRate = 2.0; | |
632 m_timing.startDelay = 200.0; | |
633 // -- | 735 // -- |
634 | 736 |
635 WebCompositorSupportMock mockCompositor; | 737 WebCompositorSupportMock mockCompositor; |
636 | 738 |
637 // Curve is created | 739 // Curve is created |
638 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; | 740 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; |
639 ExpectationSet usesMockCurve; | 741 ExpectationSet usesMockCurve; |
640 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) | 742 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) |
641 .WillOnce(Return(mockCurvePtr)); | 743 .WillOnce(Return(mockCurvePtr)); |
642 | 744 |
643 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(100.
0, 2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); | 745 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0,
2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); |
644 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(105.
0, 5.0))); | 746 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(10.0
, 5.0))); |
645 | 747 |
646 // Create animation | 748 // Create animation |
647 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 749 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
648 ExpectationSet usesMockAnimation; | 750 ExpectationSet usesMockAnimation; |
649 | 751 |
650 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 752 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
651 .WillOnce(Return(mockAnimationPtr)); | 753 .WillOnce(Return(mockAnimationPtr)); |
652 | 754 |
653 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); | 755 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); |
| 756 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); |
654 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); | 757 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); |
655 | 758 |
656 EXPECT_CALL(*mockAnimationPtr, delete_()) | 759 EXPECT_CALL(*mockAnimationPtr, delete_()) |
657 .Times(1) | 760 .Times(1) |
658 .After(usesMockAnimation); | 761 .After(usesMockAnimation); |
659 EXPECT_CALL(*mockCurvePtr, delete_()) | 762 EXPECT_CALL(*mockCurvePtr, delete_()) |
660 .Times(1) | 763 .Times(1) |
661 .After(usesMockCurve); | 764 .After(usesMockCurve); |
662 | 765 |
663 // Go! | 766 // Go! |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
696 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); | 799 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); |
697 | 800 |
698 // Animation is created | 801 // Animation is created |
699 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 802 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
700 ExpectationSet usesMockAnimation; | 803 ExpectationSet usesMockAnimation; |
701 | 804 |
702 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 805 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
703 .WillOnce(Return(mockAnimationPtr)); | 806 .WillOnce(Return(mockAnimationPtr)); |
704 | 807 |
705 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); | 808 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(5)); |
| 809 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); |
706 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); | 810 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); |
707 | 811 |
708 EXPECT_CALL(*mockAnimationPtr, delete_()) | 812 EXPECT_CALL(*mockAnimationPtr, delete_()) |
709 .Times(1) | 813 .Times(1) |
710 .After(usesMockAnimation); | 814 .After(usesMockAnimation); |
711 EXPECT_CALL(*mockCurvePtr, delete_()) | 815 EXPECT_CALL(*mockCurvePtr, delete_()) |
712 .Times(1) | 816 .Times(1) |
713 .After(usesMockCurve); | 817 .After(usesMockCurve); |
714 | 818 |
715 // Go! | 819 // Go! |
716 setCompositorForTesting(mockCompositor); | 820 setCompositorForTesting(mockCompositor); |
717 Vector<OwnPtr<blink::WebAnimation> > result; | 821 Vector<OwnPtr<blink::WebAnimation> > result; |
718 getCompositorAnimations(m_timing, *effect.get(), result); | 822 getCompositorAnimations(m_timing, *effect.get(), result); |
719 EXPECT_EQ(1U, result.size()); | 823 EXPECT_EQ(1U, result.size()); |
720 result[0].clear(); | 824 result[0].clear(); |
721 } | 825 } |
722 | 826 |
723 TEST_F(CoreAnimationCompositorAnimationsTest, createSimpleOpacityAnimationNegati
veStartDelay) | 827 TEST_F(CoreAnimationCompositorAnimationsTest, createSimpleOpacityAnimationNegati
veStartDelay) |
724 { | 828 { |
725 // Animation to convert | 829 // Animation to convert |
726 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( | 830 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( |
727 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), | 831 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), |
728 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); | 832 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); |
729 | 833 |
730 m_timing.iterationCount = 5.0; | 834 m_timing.iterationCount = 5.0; |
731 m_timing.iterationDuration = 2.0; | 835 m_timing.iterationDuration = 1.75; |
732 m_timing.startDelay = -3; | 836 m_timing.startDelay = -3.25; |
733 // -- | 837 // -- |
734 | 838 |
735 WebCompositorSupportMock mockCompositor; | 839 WebCompositorSupportMock mockCompositor; |
736 | 840 |
737 // Curve is created | 841 // Curve is created |
738 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; | 842 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; |
739 ExpectationSet usesMockCurve; | 843 ExpectationSet usesMockCurve; |
740 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) | 844 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) |
741 .WillOnce(Return(mockCurvePtr)); | 845 .WillOnce(Return(mockCurvePtr)); |
742 | 846 |
743 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0,
2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); | 847 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0,
2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); |
744 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(2.0,
5.0))); | 848 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.75
, 5.0))); |
745 | 849 |
746 // Create animation | 850 // Create animation |
747 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 851 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
748 ExpectationSet usesMockAnimation; | 852 ExpectationSet usesMockAnimation; |
749 | 853 |
750 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 854 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
751 .WillOnce(Return(mockAnimationPtr)); | 855 .WillOnce(Return(mockAnimationPtr)); |
752 | 856 |
753 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-1.0)); | |
754 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(4)); | 857 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(4)); |
| 858 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-1.5)); |
755 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); | 859 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); |
756 | 860 |
757 EXPECT_CALL(*mockAnimationPtr, delete_()) | 861 EXPECT_CALL(*mockAnimationPtr, delete_()) |
758 .Times(1) | 862 .Times(1) |
759 .After(usesMockAnimation); | 863 .After(usesMockAnimation); |
760 EXPECT_CALL(*mockCurvePtr, delete_()) | 864 EXPECT_CALL(*mockCurvePtr, delete_()) |
761 .Times(1) | 865 .Times(1) |
762 .After(usesMockCurve); | 866 .After(usesMockCurve); |
763 | 867 |
764 // Go! | 868 // Go! |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
803 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); | 907 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
5.0))); |
804 | 908 |
805 // Animation is created | 909 // Animation is created |
806 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 910 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
807 ExpectationSet usesMockAnimation; | 911 ExpectationSet usesMockAnimation; |
808 | 912 |
809 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 913 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
810 .WillOnce(Return(mockAnimationPtr)); | 914 .WillOnce(Return(mockAnimationPtr)); |
811 | 915 |
812 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); | 916 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); |
| 917 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); |
813 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); | 918 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); |
814 | 919 |
815 EXPECT_CALL(*mockAnimationPtr, delete_()) | 920 EXPECT_CALL(*mockAnimationPtr, delete_()) |
816 .Times(1) | 921 .Times(1) |
817 .After(usesMockAnimation); | 922 .After(usesMockAnimation); |
818 EXPECT_CALL(*mockCurvePtr, delete_()) | 923 EXPECT_CALL(*mockCurvePtr, delete_()) |
819 .Times(1) | 924 .Times(1) |
820 .After(usesMockCurve); | 925 .After(usesMockCurve); |
821 | 926 |
822 // Go! | 927 // Go! |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
862 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
2.0))); | 967 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(1.0,
2.0))); |
863 | 968 |
864 // Create the animation | 969 // Create the animation |
865 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 970 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
866 ExpectationSet usesMockAnimation; | 971 ExpectationSet usesMockAnimation; |
867 | 972 |
868 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 973 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
869 .WillOnce(Return(mockAnimationPtr)); | 974 .WillOnce(Return(mockAnimationPtr)); |
870 | 975 |
871 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); | 976 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(10)); |
| 977 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(0.0)); |
872 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); | 978 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); |
873 | 979 |
874 EXPECT_CALL(*mockAnimationPtr, delete_()) | 980 EXPECT_CALL(*mockAnimationPtr, delete_()) |
875 .Times(1) | 981 .Times(1) |
876 .After(usesMockAnimation); | 982 .After(usesMockAnimation); |
877 EXPECT_CALL(*mockCurvePtr, delete_()) | 983 EXPECT_CALL(*mockCurvePtr, delete_()) |
878 .Times(1) | 984 .Times(1) |
879 .After(usesMockCurve); | 985 .After(usesMockCurve); |
880 | 986 |
881 // Go! | 987 // Go! |
882 setCompositorForTesting(mockCompositor); | 988 setCompositorForTesting(mockCompositor); |
883 Vector<OwnPtr<blink::WebAnimation> > result; | 989 Vector<OwnPtr<blink::WebAnimation> > result; |
884 getCompositorAnimations(m_timing, *effect.get(), result); | 990 getCompositorAnimations(m_timing, *effect.get(), result); |
885 EXPECT_EQ(1U, result.size()); | 991 EXPECT_EQ(1U, result.size()); |
886 result[0].clear(); | 992 result[0].clear(); |
887 } | 993 } |
888 | 994 |
889 TEST_F(CoreAnimationCompositorAnimationsTest, createReversedOpacityAnimationDura
tionPlaybackOffset) | 995 TEST_F(CoreAnimationCompositorAnimationsTest, createReversedOpacityAnimationNega
tiveStartDelay) |
890 { | 996 { |
891 // Animation to convert | 997 // Animation to convert |
892 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( | 998 RefPtr<KeyframeAnimationEffect> effect = createKeyframeAnimationEffect( |
893 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), | 999 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(2.0
).get(), 0), |
894 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); | 1000 createReplaceOpKeyframe(CSSPropertyOpacity, AnimatableDouble::create(5.0
).get(), 1.0)); |
895 | 1001 |
896 m_timing.iterationDuration = 10.0; | 1002 m_timing.iterationCount = 5.0; |
897 m_timing.playbackRate = 2.0; | 1003 m_timing.iterationDuration = 2.0; |
898 m_timing.startDelay = 200.0; | 1004 m_timing.startDelay = -3; |
899 m_timing.direction = Timing::PlaybackDirectionReverse; | 1005 m_timing.direction = Timing::PlaybackDirectionAlternateReverse; |
900 // -- | 1006 // -- |
901 | 1007 |
902 WebCompositorSupportMock mockCompositor; | 1008 WebCompositorSupportMock mockCompositor; |
903 | 1009 |
904 // Curve is created | 1010 // Curve is created |
905 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; | 1011 blink::WebFloatAnimationCurveMock* mockCurvePtr = new blink::WebFloatAnimati
onCurveMock; |
906 ExpectationSet usesMockCurve; | 1012 ExpectationSet usesMockCurve; |
907 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) | 1013 EXPECT_CALL(mockCompositor, createFloatAnimationCurve()) |
908 .WillOnce(Return(mockCurvePtr)); | 1014 .WillOnce(Return(mockCurvePtr)); |
909 | 1015 |
910 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(100.
0, 5.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); | 1016 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(0.0,
2.0), blink::WebAnimationCurve::TimingFunctionTypeLinear)); |
911 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(105.
0, 2.0))); | 1017 usesMockCurve += EXPECT_CALL(*mockCurvePtr, add(blink::WebFloatKeyframe(2.0,
5.0))); |
912 | 1018 |
913 // Create animation | 1019 // Create animation |
914 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); | 1020 blink::WebAnimationMock* mockAnimationPtr = new blink::WebAnimationMock(blin
k::WebAnimation::TargetPropertyOpacity); |
915 ExpectationSet usesMockAnimation; | 1021 ExpectationSet usesMockAnimation; |
916 | 1022 |
917 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) | 1023 usesMockCurve += EXPECT_CALL(mockCompositor, createAnimation(Ref(*mockCurveP
tr), blink::WebAnimation::TargetPropertyOpacity, _)) |
918 .WillOnce(Return(mockAnimationPtr)); | 1024 .WillOnce(Return(mockAnimationPtr)); |
919 | 1025 |
920 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(1)); | 1026 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setIterations(4)); |
921 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(f
alse)); | 1027 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setTimeOffset(-1.0)); |
| 1028 usesMockAnimation += EXPECT_CALL(*mockAnimationPtr, setAlternatesDirection(t
rue)); |
922 | 1029 |
923 EXPECT_CALL(*mockAnimationPtr, delete_()) | 1030 EXPECT_CALL(*mockAnimationPtr, delete_()) |
924 .Times(1) | 1031 .Times(1) |
925 .After(usesMockAnimation); | 1032 .After(usesMockAnimation); |
926 EXPECT_CALL(*mockCurvePtr, delete_()) | 1033 EXPECT_CALL(*mockCurvePtr, delete_()) |
927 .Times(1) | 1034 .Times(1) |
928 .After(usesMockCurve); | 1035 .After(usesMockCurve); |
929 | 1036 |
930 // Go! | 1037 // Go! |
931 setCompositorForTesting(mockCompositor); | 1038 setCompositorForTesting(mockCompositor); |
932 Vector<OwnPtr<blink::WebAnimation> > result; | 1039 Vector<OwnPtr<blink::WebAnimation> > result; |
933 getCompositorAnimations(m_timing, *effect.get(), result); | 1040 getCompositorAnimations(m_timing, *effect.get(), result); |
934 EXPECT_EQ(1U, result.size()); | 1041 EXPECT_EQ(1U, result.size()); |
935 result[0].clear(); | 1042 result[0].clear(); |
936 } | 1043 } |
937 | 1044 |
| 1045 |
938 } // namespace WebCore | 1046 } // namespace WebCore |
OLD | NEW |