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 "third_party/blink/renderer/core/animation/animation_effect.h"
32
33 #include "testing/gmock/include/gmock/gmock.h"
34 #include "testing/gtest/include/gtest/gtest.h"
35 #include "third_party/blink/renderer/bindings/core/v8/v8_computed_effect_timing.h"
36 #include "third_party/blink/renderer/bindings/core/v8/v8_optional_effect_timing.h"
37 #include "third_party/blink/renderer/core/animation/animation_effect_owner.h"
38 #include "third_party/blink/renderer/platform/heap/heap.h"
39
40 namespace blink {
41
42 class MockAnimationEffectOwner
43 : public GarbageCollected<MockAnimationEffectOwner>,
44 public AnimationEffectOwner {
45 USING_GARBAGE_COLLECTED_MIXIN(MockAnimationEffectOwner);
46
47 public:
48 MOCK_CONST_METHOD0(SequenceNumber, unsigned());
49 MOCK_CONST_METHOD0(Playing, bool());
50 MOCK_CONST_METHOD0(IsEventDispatchAllowed, bool());
51 MOCK_CONST_METHOD0(EffectSuppressed, bool());
52 MOCK_CONST_METHOD0(ReplaceStateRemoved, bool());
53 MOCK_METHOD0(EffectInvalidated, void());
54 MOCK_METHOD0(UpdateIfNecessary, void());
55 MOCK_METHOD0(GetAnimation, Animation*());
56 };
57
58 class TestAnimationEffectEventDelegate : public AnimationEffect::EventDelegate {
59 public:
OnEventCondition(const AnimationEffect & animation_node,Timing::Phase current_phase)60 void OnEventCondition(const AnimationEffect& animation_node,
61 Timing::Phase current_phase) override {
62 event_triggered_ = true;
63 }
RequiresIterationEvents(const AnimationEffect & animation_node)64 bool RequiresIterationEvents(const AnimationEffect& animation_node) override {
65 return true;
66 }
Reset()67 void Reset() { event_triggered_ = false; }
EventTriggered()68 bool EventTriggered() { return event_triggered_; }
69
70 private:
71 bool event_triggered_;
72 };
73
74 class TestAnimationEffect : public AnimationEffect {
75 public:
TestAnimationEffect(const Timing & specified,TestAnimationEffectEventDelegate * event_delegate=MakeGarbageCollected<TestAnimationEffectEventDelegate> ())76 TestAnimationEffect(
77 const Timing& specified,
78 TestAnimationEffectEventDelegate* event_delegate =
79 MakeGarbageCollected<TestAnimationEffectEventDelegate>())
80 : AnimationEffect(specified, event_delegate),
81 event_delegate_(event_delegate) {}
82
UpdateInheritedTime(double time)83 void UpdateInheritedTime(double time) {
84 UpdateInheritedTime(time, kTimingUpdateForAnimationFrame);
85 }
86
UpdateInheritedTime(double time,TimingUpdateReason reason)87 void UpdateInheritedTime(double time, TimingUpdateReason reason) {
88 event_delegate_->Reset();
89 AnimationEffect::UpdateInheritedTime(time, reason);
90 }
91
UpdateChildrenAndEffects() const92 void UpdateChildrenAndEffects() const override {}
WillDetach()93 void WillDetach() {}
EventDelegate()94 TestAnimationEffectEventDelegate* EventDelegate() {
95 return event_delegate_.Get();
96 }
CalculateTimeToEffectChange(bool forwards,base::Optional<double> local_time,AnimationTimeDelta time_to_next_iteration) const97 AnimationTimeDelta CalculateTimeToEffectChange(
98 bool forwards,
99 base::Optional<double> local_time,
100 AnimationTimeDelta time_to_next_iteration) const override {
101 DCHECK(!local_time || !Timing::IsNull(local_time.value()));
102 local_time_ = local_time;
103 time_to_next_iteration_ = time_to_next_iteration;
104 return AnimationTimeDelta::FromSecondsD(
105 std::numeric_limits<double>::infinity());
106 }
TakeLocalTime()107 double TakeLocalTime() {
108 DCHECK(local_time_);
109 const double result = local_time_.value();
110 local_time_.reset();
111 return result;
112 }
113
TakeTimeToNextIteration()114 base::Optional<AnimationTimeDelta> TakeTimeToNextIteration() {
115 const base::Optional<AnimationTimeDelta> result = time_to_next_iteration_;
116 time_to_next_iteration_.reset();
117 return result;
118 }
119
Trace(Visitor * visitor)120 void Trace(Visitor* visitor) override {
121 visitor->Trace(event_delegate_);
122 AnimationEffect::Trace(visitor);
123 }
124
125 private:
126 Member<TestAnimationEffectEventDelegate> event_delegate_;
127 mutable base::Optional<double> local_time_;
128 mutable base::Optional<AnimationTimeDelta> time_to_next_iteration_;
129 };
130
TEST(AnimationAnimationEffectTest,Sanity)131 TEST(AnimationAnimationEffectTest, Sanity) {
132 Timing timing;
133 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(2);
134 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
135
136 animation_node->UpdateInheritedTime(0);
137
138 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
139 EXPECT_TRUE(animation_node->IsInPlay());
140 EXPECT_TRUE(animation_node->IsCurrent());
141 EXPECT_TRUE(animation_node->IsInEffect());
142 EXPECT_EQ(0, animation_node->CurrentIteration());
143 EXPECT_EQ(2, animation_node->SpecifiedTiming().ActiveDuration());
144 EXPECT_EQ(0, animation_node->Progress());
145
146 animation_node->UpdateInheritedTime(1);
147
148 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
149 EXPECT_TRUE(animation_node->IsInPlay());
150 EXPECT_TRUE(animation_node->IsCurrent());
151 EXPECT_TRUE(animation_node->IsInEffect());
152 EXPECT_EQ(0, animation_node->CurrentIteration());
153 EXPECT_EQ(2, animation_node->SpecifiedTiming().ActiveDuration());
154 EXPECT_EQ(0.5, animation_node->Progress());
155
156 animation_node->UpdateInheritedTime(2);
157
158 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
159 EXPECT_FALSE(animation_node->IsInPlay());
160 EXPECT_FALSE(animation_node->IsCurrent());
161 EXPECT_TRUE(animation_node->IsInEffect());
162 EXPECT_EQ(0, animation_node->CurrentIteration());
163 EXPECT_EQ(2, animation_node->SpecifiedTiming().ActiveDuration());
164 EXPECT_EQ(1, animation_node->Progress());
165
166 animation_node->UpdateInheritedTime(3);
167
168 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
169 EXPECT_FALSE(animation_node->IsInPlay());
170 EXPECT_FALSE(animation_node->IsCurrent());
171 EXPECT_TRUE(animation_node->IsInEffect());
172 EXPECT_EQ(0, animation_node->CurrentIteration());
173 EXPECT_EQ(2, animation_node->SpecifiedTiming().ActiveDuration());
174 EXPECT_EQ(1, animation_node->Progress());
175 }
176
TEST(AnimationAnimationEffectTest,FillAuto)177 TEST(AnimationAnimationEffectTest, FillAuto) {
178 Timing timing;
179 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
180 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
181
182 animation_node->UpdateInheritedTime(-1);
183 EXPECT_EQ(0, animation_node->Progress());
184
185 animation_node->UpdateInheritedTime(2);
186 EXPECT_EQ(1, animation_node->Progress());
187 }
188
TEST(AnimationAnimationEffectTest,FillForwards)189 TEST(AnimationAnimationEffectTest, FillForwards) {
190 Timing timing;
191 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
192 timing.fill_mode = Timing::FillMode::FORWARDS;
193 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
194
195 animation_node->UpdateInheritedTime(-1);
196 EXPECT_FALSE(animation_node->Progress());
197
198 animation_node->UpdateInheritedTime(2);
199 EXPECT_EQ(1, animation_node->Progress());
200 }
201
TEST(AnimationAnimationEffectTest,FillBackwards)202 TEST(AnimationAnimationEffectTest, FillBackwards) {
203 Timing timing;
204 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
205 timing.fill_mode = Timing::FillMode::BACKWARDS;
206 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
207
208 animation_node->UpdateInheritedTime(-1);
209 EXPECT_EQ(0, animation_node->Progress());
210
211 animation_node->UpdateInheritedTime(2);
212 EXPECT_FALSE(animation_node->Progress());
213 }
214
TEST(AnimationAnimationEffectTest,FillBoth)215 TEST(AnimationAnimationEffectTest, FillBoth) {
216 Timing timing;
217 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
218 timing.fill_mode = Timing::FillMode::BOTH;
219 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
220
221 animation_node->UpdateInheritedTime(-1);
222 EXPECT_EQ(0, animation_node->Progress());
223
224 animation_node->UpdateInheritedTime(2);
225 EXPECT_EQ(1, animation_node->Progress());
226 }
227
TEST(AnimationAnimationEffectTest,StartDelay)228 TEST(AnimationAnimationEffectTest, StartDelay) {
229 Timing timing;
230 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
231 timing.fill_mode = Timing::FillMode::FORWARDS;
232 timing.start_delay = 0.5;
233 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
234
235 animation_node->UpdateInheritedTime(0);
236 EXPECT_FALSE(animation_node->Progress());
237
238 animation_node->UpdateInheritedTime(0.5);
239 EXPECT_EQ(0, animation_node->Progress());
240
241 animation_node->UpdateInheritedTime(1.5);
242 EXPECT_EQ(1, animation_node->Progress());
243 }
244
TEST(AnimationAnimationEffectTest,ZeroIteration)245 TEST(AnimationAnimationEffectTest, ZeroIteration) {
246 Timing timing;
247 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
248 timing.fill_mode = Timing::FillMode::FORWARDS;
249 timing.iteration_count = 0;
250 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
251
252 animation_node->UpdateInheritedTime(-1);
253 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
254 EXPECT_FALSE(animation_node->CurrentIteration());
255 EXPECT_FALSE(animation_node->Progress());
256
257 animation_node->UpdateInheritedTime(0);
258 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
259 EXPECT_EQ(0, animation_node->CurrentIteration());
260 EXPECT_EQ(0, animation_node->Progress());
261 }
262
TEST(AnimationAnimationEffectTest,InfiniteIteration)263 TEST(AnimationAnimationEffectTest, InfiniteIteration) {
264 Timing timing;
265 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
266 timing.fill_mode = Timing::FillMode::FORWARDS;
267 timing.iteration_count = std::numeric_limits<double>::infinity();
268 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
269
270 animation_node->UpdateInheritedTime(-1);
271 EXPECT_FALSE(animation_node->CurrentIteration());
272 EXPECT_FALSE(animation_node->Progress());
273
274 EXPECT_EQ(std::numeric_limits<double>::infinity(),
275 animation_node->SpecifiedTiming().ActiveDuration());
276
277 animation_node->UpdateInheritedTime(0);
278 EXPECT_EQ(0, animation_node->CurrentIteration());
279 EXPECT_EQ(0, animation_node->Progress());
280 }
281
TEST(AnimationAnimationEffectTest,Iteration)282 TEST(AnimationAnimationEffectTest, Iteration) {
283 Timing timing;
284 timing.iteration_count = 2;
285 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(2);
286 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
287
288 animation_node->UpdateInheritedTime(0);
289 EXPECT_EQ(0, animation_node->CurrentIteration());
290 EXPECT_EQ(0, animation_node->Progress());
291
292 animation_node->UpdateInheritedTime(1);
293 EXPECT_EQ(0, animation_node->CurrentIteration());
294 EXPECT_EQ(0.5, animation_node->Progress());
295
296 animation_node->UpdateInheritedTime(2);
297 EXPECT_EQ(1, animation_node->CurrentIteration());
298 EXPECT_EQ(0, animation_node->Progress());
299
300 animation_node->UpdateInheritedTime(2);
301 EXPECT_EQ(1, animation_node->CurrentIteration());
302 EXPECT_EQ(0, animation_node->Progress());
303
304 animation_node->UpdateInheritedTime(5);
305 EXPECT_EQ(1, animation_node->CurrentIteration());
306 EXPECT_EQ(1, animation_node->Progress());
307 }
308
TEST(AnimationAnimationEffectTest,IterationStart)309 TEST(AnimationAnimationEffectTest, IterationStart) {
310 Timing timing;
311 timing.iteration_start = 1.2;
312 timing.iteration_count = 2.2;
313 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
314 timing.fill_mode = Timing::FillMode::BOTH;
315 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
316
317 animation_node->UpdateInheritedTime(-1);
318 EXPECT_EQ(1, animation_node->CurrentIteration());
319 EXPECT_NEAR(0.2, animation_node->Progress().value(), 0.000000000000001);
320
321 animation_node->UpdateInheritedTime(0);
322 EXPECT_EQ(1, animation_node->CurrentIteration());
323 EXPECT_NEAR(0.2, animation_node->Progress().value(), 0.000000000000001);
324
325 animation_node->UpdateInheritedTime(10);
326 EXPECT_EQ(3, animation_node->CurrentIteration());
327 EXPECT_NEAR(0.4, animation_node->Progress().value(), 0.000000000000001);
328 }
329
TEST(AnimationAnimationEffectTest,IterationAlternate)330 TEST(AnimationAnimationEffectTest, IterationAlternate) {
331 Timing timing;
332 timing.iteration_count = 10;
333 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
334 timing.direction = Timing::PlaybackDirection::ALTERNATE_NORMAL;
335 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
336
337 animation_node->UpdateInheritedTime(0.75);
338 EXPECT_EQ(0, animation_node->CurrentIteration());
339 EXPECT_EQ(0.75, animation_node->Progress());
340
341 animation_node->UpdateInheritedTime(1.75);
342 EXPECT_EQ(1, animation_node->CurrentIteration());
343 EXPECT_EQ(0.25, animation_node->Progress());
344
345 animation_node->UpdateInheritedTime(2.75);
346 EXPECT_EQ(2, animation_node->CurrentIteration());
347 EXPECT_EQ(0.75, animation_node->Progress());
348 }
349
TEST(AnimationAnimationEffectTest,IterationAlternateReverse)350 TEST(AnimationAnimationEffectTest, IterationAlternateReverse) {
351 Timing timing;
352 timing.iteration_count = 10;
353 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
354 timing.direction = Timing::PlaybackDirection::ALTERNATE_REVERSE;
355 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
356
357 animation_node->UpdateInheritedTime(0.75);
358 EXPECT_EQ(0, animation_node->CurrentIteration());
359 EXPECT_EQ(0.25, animation_node->Progress());
360
361 animation_node->UpdateInheritedTime(1.75);
362 EXPECT_EQ(1, animation_node->CurrentIteration());
363 EXPECT_EQ(0.75, animation_node->Progress());
364
365 animation_node->UpdateInheritedTime(2.75);
366 EXPECT_EQ(2, animation_node->CurrentIteration());
367 EXPECT_EQ(0.25, animation_node->Progress());
368 }
369
TEST(AnimationAnimationEffectTest,ZeroDurationSanity)370 TEST(AnimationAnimationEffectTest, ZeroDurationSanity) {
371 Timing timing;
372 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
373
374 animation_node->UpdateInheritedTime(0);
375
376 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
377 EXPECT_FALSE(animation_node->IsInPlay());
378 EXPECT_FALSE(animation_node->IsCurrent());
379 EXPECT_TRUE(animation_node->IsInEffect());
380 EXPECT_EQ(0, animation_node->CurrentIteration());
381 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
382 EXPECT_EQ(1, animation_node->Progress());
383
384 animation_node->UpdateInheritedTime(1);
385
386 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
387 EXPECT_FALSE(animation_node->IsInPlay());
388 EXPECT_FALSE(animation_node->IsCurrent());
389 EXPECT_TRUE(animation_node->IsInEffect());
390 EXPECT_EQ(0, animation_node->CurrentIteration());
391 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
392 EXPECT_EQ(1, animation_node->Progress());
393 }
394
TEST(AnimationAnimationEffectTest,ZeroDurationFillForwards)395 TEST(AnimationAnimationEffectTest, ZeroDurationFillForwards) {
396 Timing timing;
397 timing.fill_mode = Timing::FillMode::FORWARDS;
398 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
399
400 animation_node->UpdateInheritedTime(-1);
401 EXPECT_FALSE(animation_node->Progress());
402
403 animation_node->UpdateInheritedTime(0);
404 EXPECT_EQ(1, animation_node->Progress());
405
406 animation_node->UpdateInheritedTime(1);
407 EXPECT_EQ(1, animation_node->Progress());
408 }
409
TEST(AnimationAnimationEffectTest,ZeroDurationFillBackwards)410 TEST(AnimationAnimationEffectTest, ZeroDurationFillBackwards) {
411 Timing timing;
412 timing.fill_mode = Timing::FillMode::BACKWARDS;
413 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
414
415 animation_node->UpdateInheritedTime(-1);
416 EXPECT_EQ(0, animation_node->Progress());
417
418 animation_node->UpdateInheritedTime(0);
419 EXPECT_FALSE(animation_node->Progress());
420
421 animation_node->UpdateInheritedTime(1);
422 EXPECT_FALSE(animation_node->Progress());
423 }
424
TEST(AnimationAnimationEffectTest,ZeroDurationFillBoth)425 TEST(AnimationAnimationEffectTest, ZeroDurationFillBoth) {
426 Timing timing;
427 timing.fill_mode = Timing::FillMode::BOTH;
428 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
429
430 animation_node->UpdateInheritedTime(-1);
431 EXPECT_EQ(0, animation_node->Progress());
432
433 animation_node->UpdateInheritedTime(0);
434 EXPECT_EQ(1, animation_node->Progress());
435
436 animation_node->UpdateInheritedTime(1);
437 EXPECT_EQ(1, animation_node->Progress());
438 }
439
TEST(AnimationAnimationEffectTest,ZeroDurationStartDelay)440 TEST(AnimationAnimationEffectTest, ZeroDurationStartDelay) {
441 Timing timing;
442 timing.fill_mode = Timing::FillMode::FORWARDS;
443 timing.start_delay = 0.5;
444 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
445
446 animation_node->UpdateInheritedTime(0);
447 EXPECT_FALSE(animation_node->Progress());
448
449 animation_node->UpdateInheritedTime(0.5);
450 EXPECT_EQ(1, animation_node->Progress());
451
452 animation_node->UpdateInheritedTime(1.5);
453 EXPECT_EQ(1, animation_node->Progress());
454 }
455
TEST(AnimationAnimationEffectTest,ZeroDurationIterationStartAndCount)456 TEST(AnimationAnimationEffectTest, ZeroDurationIterationStartAndCount) {
457 Timing timing;
458 timing.iteration_start = 0.1;
459 timing.iteration_count = 0.2;
460 timing.fill_mode = Timing::FillMode::BOTH;
461 timing.start_delay = 0.3;
462 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
463
464 animation_node->UpdateInheritedTime(0);
465 EXPECT_EQ(0.1, animation_node->Progress());
466
467 animation_node->UpdateInheritedTime(0.3);
468 EXPECT_DOUBLE_EQ(0.3, animation_node->Progress().value());
469
470 animation_node->UpdateInheritedTime(1);
471 EXPECT_DOUBLE_EQ(0.3, animation_node->Progress().value());
472 }
473
474 // FIXME: Needs specification work.
TEST(AnimationAnimationEffectTest,ZeroDurationInfiniteIteration)475 TEST(AnimationAnimationEffectTest, ZeroDurationInfiniteIteration) {
476 Timing timing;
477 timing.fill_mode = Timing::FillMode::FORWARDS;
478 timing.iteration_count = std::numeric_limits<double>::infinity();
479 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
480
481 animation_node->UpdateInheritedTime(-1);
482 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
483 EXPECT_FALSE(animation_node->CurrentIteration());
484 EXPECT_FALSE(animation_node->Progress());
485
486 animation_node->UpdateInheritedTime(0);
487 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
488 EXPECT_EQ(std::numeric_limits<double>::infinity(),
489 animation_node->CurrentIteration());
490 EXPECT_EQ(1, animation_node->Progress());
491 }
492
TEST(AnimationAnimationEffectTest,ZeroDurationIteration)493 TEST(AnimationAnimationEffectTest, ZeroDurationIteration) {
494 Timing timing;
495 timing.fill_mode = Timing::FillMode::FORWARDS;
496 timing.iteration_count = 2;
497 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
498
499 animation_node->UpdateInheritedTime(-1);
500 EXPECT_FALSE(animation_node->CurrentIteration());
501 EXPECT_FALSE(animation_node->Progress());
502
503 animation_node->UpdateInheritedTime(0);
504 EXPECT_EQ(1, animation_node->CurrentIteration());
505 EXPECT_EQ(1, animation_node->Progress());
506
507 animation_node->UpdateInheritedTime(1);
508 EXPECT_EQ(1, animation_node->CurrentIteration());
509 EXPECT_EQ(1, animation_node->Progress());
510 }
511
TEST(AnimationAnimationEffectTest,ZeroDurationIterationStart)512 TEST(AnimationAnimationEffectTest, ZeroDurationIterationStart) {
513 Timing timing;
514 timing.iteration_start = 1.2;
515 timing.iteration_count = 2.2;
516 timing.fill_mode = Timing::FillMode::BOTH;
517 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
518
519 animation_node->UpdateInheritedTime(-1);
520 EXPECT_EQ(1, animation_node->CurrentIteration());
521 EXPECT_NEAR(0.2, animation_node->Progress().value(), 0.000000000000001);
522
523 animation_node->UpdateInheritedTime(0);
524 EXPECT_EQ(3, animation_node->CurrentIteration());
525 EXPECT_NEAR(0.4, animation_node->Progress().value(), 0.000000000000001);
526
527 animation_node->UpdateInheritedTime(10);
528 EXPECT_EQ(3, animation_node->CurrentIteration());
529 EXPECT_NEAR(0.4, animation_node->Progress().value(), 0.000000000000001);
530 }
531
TEST(AnimationAnimationEffectTest,ZeroDurationIterationAlternate)532 TEST(AnimationAnimationEffectTest, ZeroDurationIterationAlternate) {
533 Timing timing;
534 timing.fill_mode = Timing::FillMode::FORWARDS;
535 timing.iteration_count = 2;
536 timing.direction = Timing::PlaybackDirection::ALTERNATE_NORMAL;
537 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
538
539 animation_node->UpdateInheritedTime(-1);
540 EXPECT_FALSE(animation_node->CurrentIteration());
541 EXPECT_FALSE(animation_node->Progress());
542
543 animation_node->UpdateInheritedTime(0);
544 EXPECT_EQ(1, animation_node->CurrentIteration());
545 EXPECT_EQ(0, animation_node->Progress());
546
547 animation_node->UpdateInheritedTime(1);
548 EXPECT_EQ(1, animation_node->CurrentIteration());
549 EXPECT_EQ(0, animation_node->Progress());
550 }
551
TEST(AnimationAnimationEffectTest,ZeroDurationIterationAlternateReverse)552 TEST(AnimationAnimationEffectTest, ZeroDurationIterationAlternateReverse) {
553 Timing timing;
554 timing.fill_mode = Timing::FillMode::FORWARDS;
555 timing.iteration_count = 2;
556 timing.direction = Timing::PlaybackDirection::ALTERNATE_REVERSE;
557 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
558
559 animation_node->UpdateInheritedTime(-1);
560 EXPECT_FALSE(animation_node->CurrentIteration());
561 EXPECT_FALSE(animation_node->Progress());
562
563 animation_node->UpdateInheritedTime(0);
564 EXPECT_EQ(1, animation_node->CurrentIteration());
565 EXPECT_EQ(1, animation_node->Progress());
566
567 animation_node->UpdateInheritedTime(1);
568 EXPECT_EQ(1, animation_node->CurrentIteration());
569 EXPECT_EQ(1, animation_node->Progress());
570 }
571
TEST(AnimationAnimationEffectTest,InfiniteDurationSanity)572 TEST(AnimationAnimationEffectTest, InfiniteDurationSanity) {
573 Timing timing;
574 timing.iteration_duration = AnimationTimeDelta::Max();
575 timing.iteration_count = 1;
576 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
577
578 animation_node->UpdateInheritedTime(0);
579
580 EXPECT_EQ(std::numeric_limits<double>::infinity(),
581 animation_node->SpecifiedTiming().ActiveDuration());
582 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
583 EXPECT_TRUE(animation_node->IsInPlay());
584 EXPECT_TRUE(animation_node->IsCurrent());
585 EXPECT_TRUE(animation_node->IsInEffect());
586 EXPECT_EQ(0, animation_node->CurrentIteration());
587 EXPECT_EQ(0, animation_node->Progress());
588
589 animation_node->UpdateInheritedTime(1);
590
591 EXPECT_EQ(std::numeric_limits<double>::infinity(),
592 animation_node->SpecifiedTiming().ActiveDuration());
593 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
594 EXPECT_TRUE(animation_node->IsInPlay());
595 EXPECT_TRUE(animation_node->IsCurrent());
596 EXPECT_TRUE(animation_node->IsInEffect());
597 EXPECT_EQ(0, animation_node->CurrentIteration());
598 EXPECT_EQ(0, animation_node->Progress());
599 }
600
601 // FIXME: Needs specification work.
TEST(AnimationAnimationEffectTest,InfiniteDurationZeroIterations)602 TEST(AnimationAnimationEffectTest, InfiniteDurationZeroIterations) {
603 Timing timing;
604 timing.iteration_duration = AnimationTimeDelta::Max();
605 timing.iteration_count = 0;
606 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
607
608 animation_node->UpdateInheritedTime(0);
609
610 EXPECT_EQ(0, animation_node->SpecifiedTiming().ActiveDuration());
611 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
612 EXPECT_FALSE(animation_node->IsInPlay());
613 EXPECT_FALSE(animation_node->IsCurrent());
614 EXPECT_TRUE(animation_node->IsInEffect());
615 EXPECT_EQ(0, animation_node->CurrentIteration());
616 EXPECT_EQ(0, animation_node->Progress());
617
618 animation_node->UpdateInheritedTime(1);
619
620 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
621 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
622 EXPECT_FALSE(animation_node->IsInPlay());
623 EXPECT_FALSE(animation_node->IsCurrent());
624 EXPECT_TRUE(animation_node->IsInEffect());
625 EXPECT_EQ(0, animation_node->CurrentIteration());
626 EXPECT_EQ(0, animation_node->Progress());
627 }
628
TEST(AnimationAnimationEffectTest,InfiniteDurationInfiniteIterations)629 TEST(AnimationAnimationEffectTest, InfiniteDurationInfiniteIterations) {
630 Timing timing;
631 timing.iteration_duration = AnimationTimeDelta::Max();
632 timing.iteration_count = std::numeric_limits<double>::infinity();
633 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
634
635 animation_node->UpdateInheritedTime(0);
636
637 EXPECT_EQ(std::numeric_limits<double>::infinity(),
638 animation_node->SpecifiedTiming().ActiveDuration());
639 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
640 EXPECT_TRUE(animation_node->IsInPlay());
641 EXPECT_TRUE(animation_node->IsCurrent());
642 EXPECT_TRUE(animation_node->IsInEffect());
643 EXPECT_EQ(0, animation_node->CurrentIteration());
644 EXPECT_EQ(0, animation_node->Progress());
645
646 animation_node->UpdateInheritedTime(1);
647
648 EXPECT_EQ(std::numeric_limits<double>::infinity(),
649 animation_node->SpecifiedTiming().ActiveDuration());
650 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
651 EXPECT_TRUE(animation_node->IsInPlay());
652 EXPECT_TRUE(animation_node->IsCurrent());
653 EXPECT_TRUE(animation_node->IsInEffect());
654 EXPECT_EQ(0, animation_node->CurrentIteration());
655 EXPECT_EQ(0, animation_node->Progress());
656 }
657
TEST(AnimationAnimationEffectTest,EndTime)658 TEST(AnimationAnimationEffectTest, EndTime) {
659 Timing timing;
660 timing.start_delay = 1;
661 timing.end_delay = 2;
662 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(4);
663 timing.iteration_count = 2;
664 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
665 EXPECT_EQ(11, animation_node->SpecifiedTiming().EndTimeInternal());
666 }
667
TEST(AnimationAnimationEffectTest,Events)668 TEST(AnimationAnimationEffectTest, Events) {
669 Timing timing;
670 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
671 timing.fill_mode = Timing::FillMode::FORWARDS;
672 timing.iteration_count = 2;
673 timing.start_delay = 1;
674 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
675
676 animation_node->UpdateInheritedTime(0.0, kTimingUpdateOnDemand);
677 EXPECT_FALSE(animation_node->EventDelegate()->EventTriggered());
678
679 animation_node->UpdateInheritedTime(0.0, kTimingUpdateForAnimationFrame);
680 EXPECT_TRUE(animation_node->EventDelegate()->EventTriggered());
681
682 animation_node->UpdateInheritedTime(1.5, kTimingUpdateOnDemand);
683 EXPECT_FALSE(animation_node->EventDelegate()->EventTriggered());
684
685 animation_node->UpdateInheritedTime(1.5, kTimingUpdateForAnimationFrame);
686 EXPECT_TRUE(animation_node->EventDelegate()->EventTriggered());
687 }
688
TEST(AnimationAnimationEffectTest,TimeToEffectChange)689 TEST(AnimationAnimationEffectTest, TimeToEffectChange) {
690 Timing timing;
691 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(1);
692 timing.fill_mode = Timing::FillMode::FORWARDS;
693 timing.iteration_start = 0.2;
694 timing.iteration_count = 2.5;
695 timing.start_delay = 1;
696 timing.direction = Timing::PlaybackDirection::ALTERNATE_NORMAL;
697 auto* animation_node = MakeGarbageCollected<TestAnimationEffect>(timing);
698
699 animation_node->UpdateInheritedTime(0);
700 EXPECT_EQ(0, animation_node->TakeLocalTime());
701 base::Optional<AnimationTimeDelta> time_to_next_iteration =
702 animation_node->TakeTimeToNextIteration();
703 EXPECT_TRUE(time_to_next_iteration);
704 EXPECT_TRUE(time_to_next_iteration->is_max());
705
706 // Normal iteration.
707 animation_node->UpdateInheritedTime(1.75);
708 EXPECT_EQ(1.75, animation_node->TakeLocalTime());
709 time_to_next_iteration = animation_node->TakeTimeToNextIteration();
710 EXPECT_TRUE(time_to_next_iteration);
711 EXPECT_NEAR(0.05, time_to_next_iteration->InSecondsF(), 0.000000000000001);
712
713 // Reverse iteration.
714 animation_node->UpdateInheritedTime(2.75);
715 EXPECT_EQ(2.75, animation_node->TakeLocalTime());
716 time_to_next_iteration = animation_node->TakeTimeToNextIteration();
717 EXPECT_TRUE(time_to_next_iteration);
718 EXPECT_NEAR(0.05, time_to_next_iteration->InSecondsF(), 0.000000000000001);
719
720 // Item ends before iteration finishes.
721 animation_node->UpdateInheritedTime(3.4);
722 EXPECT_EQ(Timing::kPhaseActive, animation_node->GetPhase());
723 EXPECT_EQ(3.4, animation_node->TakeLocalTime());
724 time_to_next_iteration = animation_node->TakeTimeToNextIteration();
725 EXPECT_TRUE(time_to_next_iteration);
726 EXPECT_TRUE(time_to_next_iteration->is_max());
727
728 // Item has finished.
729 animation_node->UpdateInheritedTime(3.5);
730 EXPECT_EQ(Timing::kPhaseAfter, animation_node->GetPhase());
731 EXPECT_EQ(3.5, animation_node->TakeLocalTime());
732 time_to_next_iteration = animation_node->TakeTimeToNextIteration();
733 EXPECT_TRUE(time_to_next_iteration);
734 EXPECT_TRUE(time_to_next_iteration->is_max());
735 }
736
TEST(AnimationAnimationEffectTest,UpdateTiming)737 TEST(AnimationAnimationEffectTest, UpdateTiming) {
738 Timing timing;
739 auto* effect = MakeGarbageCollected<TestAnimationEffect>(timing);
740
741 EXPECT_EQ(0, effect->getTiming()->delay());
742 OptionalEffectTiming* effect_timing = OptionalEffectTiming::Create();
743 effect_timing->setDelay(2);
744 effect->updateTiming(effect_timing);
745 EXPECT_EQ(2, effect->getTiming()->delay());
746
747 EXPECT_EQ(0, effect->getTiming()->endDelay());
748 effect_timing = OptionalEffectTiming::Create();
749 effect_timing->setEndDelay(0.5);
750 effect->updateTiming(effect_timing);
751 EXPECT_EQ(0.5, effect->getTiming()->endDelay());
752
753 EXPECT_EQ("auto", effect->getTiming()->fill());
754 effect_timing = OptionalEffectTiming::Create();
755 effect_timing->setFill("backwards");
756 effect->updateTiming(effect_timing);
757 EXPECT_EQ("backwards", effect->getTiming()->fill());
758
759 EXPECT_EQ(0, effect->getTiming()->iterationStart());
760 effect_timing = OptionalEffectTiming::Create();
761 effect_timing->setIterationStart(2);
762 effect->updateTiming(effect_timing);
763 EXPECT_EQ(2, effect->getTiming()->iterationStart());
764
765 EXPECT_EQ(1, effect->getTiming()->iterations());
766 effect_timing = OptionalEffectTiming::Create();
767 effect_timing->setIterations(10);
768 effect->updateTiming(effect_timing);
769 EXPECT_EQ(10, effect->getTiming()->iterations());
770
771 EXPECT_EQ("normal", effect->getTiming()->direction());
772 effect_timing = OptionalEffectTiming::Create();
773 effect_timing->setDirection("reverse");
774 effect->updateTiming(effect_timing);
775 EXPECT_EQ("reverse", effect->getTiming()->direction());
776
777 EXPECT_EQ("linear", effect->getTiming()->easing());
778 effect_timing = OptionalEffectTiming::Create();
779 effect_timing->setEasing("ease-in-out");
780 effect->updateTiming(effect_timing);
781 EXPECT_EQ("ease-in-out", effect->getTiming()->easing());
782
783 EXPECT_EQ("auto", effect->getTiming()->duration().GetAsString());
784 effect_timing = OptionalEffectTiming::Create();
785 effect_timing->setDuration(
786 UnrestrictedDoubleOrString::FromUnrestrictedDouble(2.5));
787 effect->updateTiming(effect_timing);
788 EXPECT_EQ(2.5, effect->getTiming()->duration().GetAsUnrestrictedDouble());
789 }
790
TEST(AnimationAnimationEffectTest,UpdateTimingThrowsWhenExpected)791 TEST(AnimationAnimationEffectTest, UpdateTimingThrowsWhenExpected) {
792 Timing timing;
793 auto* effect = MakeGarbageCollected<TestAnimationEffect>(timing);
794
795 DummyExceptionStateForTesting exception_state;
796
797 // iterationStart must be non-negative
798 OptionalEffectTiming* effect_timing = OptionalEffectTiming::Create();
799 effect_timing->setIterationStart(-10);
800 effect->updateTiming(effect_timing, exception_state);
801 EXPECT_TRUE(exception_state.HadException());
802
803 // iterations must be non-negative and non-null.
804 exception_state.ClearException();
805 effect_timing = OptionalEffectTiming::Create();
806 effect_timing->setIterations(-2);
807 effect->updateTiming(effect_timing, exception_state);
808 EXPECT_TRUE(exception_state.HadException());
809
810 exception_state.ClearException();
811 effect_timing = OptionalEffectTiming::Create();
812 effect_timing->setIterations(std::numeric_limits<double>::quiet_NaN());
813 effect->updateTiming(effect_timing, exception_state);
814 EXPECT_TRUE(exception_state.HadException());
815
816 // If it is a number, duration must be non-negative and non-null.
817 exception_state.ClearException();
818 effect_timing = OptionalEffectTiming::Create();
819 effect_timing->setDuration(
820 UnrestrictedDoubleOrString::FromUnrestrictedDouble(-100));
821 effect->updateTiming(effect_timing, exception_state);
822 EXPECT_TRUE(exception_state.HadException());
823
824 exception_state.ClearException();
825 effect_timing = OptionalEffectTiming::Create();
826 effect_timing->setDuration(UnrestrictedDoubleOrString::FromUnrestrictedDouble(
827 std::numeric_limits<double>::quiet_NaN()));
828 effect->updateTiming(effect_timing, exception_state);
829 EXPECT_TRUE(exception_state.HadException());
830
831 // easing must be a valid timing function
832 exception_state.ClearException();
833 effect_timing = OptionalEffectTiming::Create();
834 effect_timing->setEasing("my-custom-timing-function");
835 effect->updateTiming(effect_timing, exception_state);
836 EXPECT_TRUE(exception_state.HadException());
837 }
838
TEST(AnimationAnimationEffectTest,UpdateTimingInformsOwnerOnChange)839 TEST(AnimationAnimationEffectTest, UpdateTimingInformsOwnerOnChange) {
840 Timing timing;
841 auto* effect = MakeGarbageCollected<TestAnimationEffect>(timing);
842
843 MockAnimationEffectOwner* owner =
844 MakeGarbageCollected<MockAnimationEffectOwner>();
845 effect->Attach(owner);
846
847 EXPECT_CALL(*owner, EffectInvalidated()).Times(1);
848
849 OptionalEffectTiming* effect_timing = OptionalEffectTiming::Create();
850 effect_timing->setDelay(5);
851 effect->updateTiming(effect_timing);
852 }
853
TEST(AnimationAnimationEffectTest,UpdateTimingNoChange)854 TEST(AnimationAnimationEffectTest, UpdateTimingNoChange) {
855 Timing timing;
856 timing.start_delay = 0;
857 timing.end_delay = 5;
858 timing.fill_mode = Timing::FillMode::BOTH;
859 timing.iteration_start = 0.1;
860 timing.iteration_count = 3;
861 timing.iteration_duration = AnimationTimeDelta::FromSecondsD(2);
862 timing.direction = Timing::PlaybackDirection::ALTERNATE_REVERSE;
863 timing.timing_function = CubicBezierTimingFunction::Create(1, 1, 0.3, 0.3);
864 auto* effect = MakeGarbageCollected<TestAnimationEffect>(timing);
865
866 MockAnimationEffectOwner* owner =
867 MakeGarbageCollected<MockAnimationEffectOwner>();
868 effect->Attach(owner);
869
870 // None of the below calls to updateTime should cause the AnimationEffect to
871 // update, as they all match the existing timing information.
872 EXPECT_CALL(*owner, EffectInvalidated()).Times(0);
873
874 OptionalEffectTiming* effect_timing = OptionalEffectTiming::Create();
875 effect->updateTiming(effect_timing);
876
877 effect_timing = OptionalEffectTiming::Create();
878 effect_timing->setDelay(0);
879 effect->updateTiming(effect_timing);
880
881 effect_timing = OptionalEffectTiming::Create();
882 effect_timing->setEndDelay(5000);
883 effect_timing->setFill("both");
884 effect_timing->setIterationStart(0.1);
885 effect->updateTiming(effect_timing);
886
887 effect_timing = OptionalEffectTiming::Create();
888 effect_timing->setIterations(3);
889 effect_timing->setDuration(
890 UnrestrictedDoubleOrString::FromUnrestrictedDouble(2000));
891 effect_timing->setDirection("alternate-reverse");
892 effect->updateTiming(effect_timing);
893
894 effect_timing = OptionalEffectTiming::Create();
895 effect_timing->setEasing("cubic-bezier(1, 1, 0.3, 0.3)");
896 effect->updateTiming(effect_timing);
897 }
898
899 } // namespace blink
900