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