ambient_animation_progress_tracker_unittest.cc 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
  1. // Copyright 2022 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/ambient/ui/ambient_animation_progress_tracker.h"
  5. #include "base/memory/scoped_refptr.h"
  6. #include "base/time/time.h"
  7. #include "cc/paint/skottie_wrapper.h"
  8. #include "cc/test/skia_common.h"
  9. #include "testing/gmock/include/gmock/gmock.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. #include "ui/gfx/canvas.h"
  12. #include "ui/gfx/geometry/size.h"
  13. #include "ui/lottie/animation.h"
  14. namespace ash {
  15. namespace {
  16. constexpr float kTimestampEpsilon = .001f;
  17. using ::testing::AllOf;
  18. using ::testing::Eq;
  19. using ::testing::FloatEq;
  20. using ::testing::Ge;
  21. using ::testing::Le;
  22. using ::testing::SizeIs;
  23. class AmbientAnimationProgressTrackerTest : public ::testing::Test {
  24. protected:
  25. static constexpr gfx::Size kAnimationSize = gfx::Size(100, 100);
  26. AmbientAnimationProgressTrackerTest()
  27. : clock_(base::TimeTicks::Now()),
  28. canvas_(kAnimationSize, /*image_scale=*/1.f, /*is_opaque=*/false) {}
  29. scoped_refptr<cc::SkottieWrapper> CreateSkottie(int duration_secs) {
  30. return cc::CreateSkottie(kAnimationSize, duration_secs);
  31. }
  32. void Paint(lottie::Animation& animation) {
  33. animation.Paint(&canvas_, clock_, kAnimationSize);
  34. }
  35. base::TimeTicks clock_;
  36. gfx::Canvas canvas_;
  37. AmbientAnimationProgressTracker tracker_;
  38. };
  39. TEST_F(AmbientAnimationProgressTrackerTest, SingleAnimation) {
  40. AmbientAnimationProgressTracker tracker;
  41. lottie::Animation animation(CreateSkottie(/*duration_secs=*/10));
  42. tracker.RegisterAnimation(&animation);
  43. ASSERT_FALSE(tracker.HasActiveAnimations());
  44. animation.Start();
  45. Paint(animation);
  46. ASSERT_TRUE(tracker.HasActiveAnimations());
  47. AmbientAnimationProgressTracker::ImmutableParams immutable_params =
  48. tracker.GetImmutableParams();
  49. AmbientAnimationProgressTracker::Progress global_progress =
  50. tracker.GetGlobalProgress();
  51. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  52. EXPECT_THAT(global_progress.current_timestamp, FloatEq(0.f));
  53. EXPECT_THAT(immutable_params.total_duration, Eq(base::Seconds(10)));
  54. ASSERT_THAT(immutable_params.scheduled_cycles, SizeIs(1));
  55. EXPECT_THAT(immutable_params.scheduled_cycles.front().start_offset,
  56. Eq(base::TimeDelta()));
  57. EXPECT_THAT(immutable_params.scheduled_cycles.front().end_offset,
  58. Eq(base::Seconds(10)));
  59. EXPECT_THAT(immutable_params.style, Eq(lottie::Animation::Style::kLoop));
  60. clock_ += base::Seconds(5);
  61. Paint(animation);
  62. global_progress = tracker.GetGlobalProgress();
  63. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  64. EXPECT_THAT(global_progress.current_timestamp, FloatEq(.5f));
  65. clock_ += base::Seconds(5);
  66. Paint(animation);
  67. global_progress = tracker.GetGlobalProgress();
  68. EXPECT_THAT(global_progress.num_completed_cycles, Eq(1));
  69. EXPECT_THAT(global_progress.current_timestamp, FloatEq(0.f));
  70. clock_ += base::Seconds(5);
  71. Paint(animation);
  72. global_progress = tracker.GetGlobalProgress();
  73. EXPECT_THAT(global_progress.num_completed_cycles, Eq(1));
  74. EXPECT_THAT(global_progress.current_timestamp, FloatEq(.5f));
  75. }
  76. TEST_F(AmbientAnimationProgressTrackerTest, MultipleAnimations) {
  77. AmbientAnimationProgressTracker tracker;
  78. lottie::Animation animation_1(CreateSkottie(/*duration_secs=*/10));
  79. lottie::Animation animation_2(CreateSkottie(/*duration_secs=*/10));
  80. tracker.RegisterAnimation(&animation_1);
  81. tracker.RegisterAnimation(&animation_2);
  82. ASSERT_FALSE(tracker.HasActiveAnimations());
  83. animation_1.Start();
  84. animation_2.Start();
  85. Paint(animation_1);
  86. Paint(animation_2);
  87. ASSERT_TRUE(tracker.HasActiveAnimations());
  88. AmbientAnimationProgressTracker::ImmutableParams immutable_params =
  89. tracker.GetImmutableParams();
  90. AmbientAnimationProgressTracker::Progress global_progress =
  91. tracker.GetGlobalProgress();
  92. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  93. EXPECT_THAT(global_progress.current_timestamp, FloatEq(0.f));
  94. EXPECT_THAT(immutable_params.total_duration, Eq(base::Seconds(10)));
  95. ASSERT_THAT(immutable_params.scheduled_cycles, SizeIs(1));
  96. EXPECT_THAT(immutable_params.scheduled_cycles.front().start_offset,
  97. Eq(base::TimeDelta()));
  98. EXPECT_THAT(immutable_params.scheduled_cycles.front().end_offset,
  99. Eq(base::Seconds(10)));
  100. EXPECT_THAT(immutable_params.style, Eq(lottie::Animation::Style::kLoop));
  101. clock_ += base::Seconds(5);
  102. Paint(animation_1);
  103. clock_ += base::Milliseconds(100);
  104. Paint(animation_2);
  105. global_progress = tracker.GetGlobalProgress();
  106. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  107. EXPECT_THAT(global_progress.current_timestamp,
  108. AllOf(Ge(.5f - kTimestampEpsilon), Le(.51f + kTimestampEpsilon)));
  109. clock_ += base::Seconds(5) - base::Milliseconds(100);
  110. Paint(animation_1);
  111. Paint(animation_2);
  112. global_progress = tracker.GetGlobalProgress();
  113. EXPECT_THAT(global_progress.num_completed_cycles, Eq(1));
  114. EXPECT_THAT(global_progress.current_timestamp, FloatEq(.0f));
  115. clock_ += base::Seconds(2);
  116. Paint(animation_2);
  117. clock_ += base::Seconds(1);
  118. Paint(animation_1);
  119. global_progress = tracker.GetGlobalProgress();
  120. EXPECT_THAT(global_progress.num_completed_cycles, Eq(1));
  121. EXPECT_THAT(global_progress.current_timestamp,
  122. AllOf(Ge(.2f - kTimestampEpsilon), Le(.3f + kTimestampEpsilon)));
  123. }
  124. TEST_F(AmbientAnimationProgressTrackerTest, AnimationsDestroyed) {
  125. AmbientAnimationProgressTracker tracker;
  126. auto animation_1 =
  127. std::make_unique<lottie::Animation>(CreateSkottie(/*duration_secs=*/10));
  128. auto animation_2 =
  129. std::make_unique<lottie::Animation>(CreateSkottie(/*duration_secs=*/10));
  130. tracker.RegisterAnimation(animation_1.get());
  131. tracker.RegisterAnimation(animation_2.get());
  132. animation_1->Start();
  133. animation_2->Start();
  134. Paint(*animation_1);
  135. Paint(*animation_2);
  136. clock_ += base::Seconds(5);
  137. Paint(*animation_1);
  138. clock_ += base::Milliseconds(100);
  139. Paint(*animation_2);
  140. animation_1.reset();
  141. AmbientAnimationProgressTracker::Progress global_progress =
  142. tracker.GetGlobalProgress();
  143. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  144. EXPECT_THAT(global_progress.current_timestamp, FloatEq(.51f));
  145. animation_2.reset();
  146. EXPECT_FALSE(tracker.HasActiveAnimations());
  147. auto animation_3 =
  148. std::make_unique<lottie::Animation>(CreateSkottie(/*duration_secs=*/20));
  149. auto animation_4 =
  150. std::make_unique<lottie::Animation>(CreateSkottie(/*duration_secs=*/20));
  151. tracker.RegisterAnimation(animation_3.get());
  152. tracker.RegisterAnimation(animation_4.get());
  153. animation_3->Start();
  154. animation_4->Start();
  155. Paint(*animation_3);
  156. Paint(*animation_4);
  157. clock_ += base::Seconds(5);
  158. Paint(*animation_3);
  159. Paint(*animation_4);
  160. global_progress = tracker.GetGlobalProgress();
  161. EXPECT_THAT(global_progress.num_completed_cycles, Eq(0));
  162. EXPECT_THAT(global_progress.current_timestamp, FloatEq(.25f));
  163. }
  164. } // namespace
  165. } // namespace ash