Match animation times of FloodFillInkDropRipple

FloodFillInkDropRipple uses different durations for flood-fill and
fade-out animations for different target states. This changes
InstallableInkDrop to use the same times.

Bug: 933384
Change-Id: I84520a7c8b919223a71df979cebcbdb070dfdf03
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1716099
Commit-Queue: Collin Baker <collinbaker@chromium.org>
Reviewed-by: Peter Boström <pbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#682108}

ui/views/animation/installable_ink_drop_animator.cc

@@ -20,7 +20,8 @@
 namespace views {
 
 // static
-constexpr base::TimeDelta InstallableInkDropAnimator::kAnimationDuration;
+constexpr base::TimeDelta
+    InstallableInkDropAnimator::kHighlightAnimationDuration;
 
 InstallableInkDropAnimator::InstallableInkDropAnimator(
     gfx::Size size,
@@ -34,13 +35,11 @@ InstallableInkDropAnimator::InstallableInkDropAnimator(
       flood_fill_animation_(this),
       fade_out_animation_(this) {
   highlight_animation_.SetContainer(animation_container);
-  highlight_animation_.SetSlideDuration(kAnimationDuration.InMilliseconds());
-
   flood_fill_animation_.SetContainer(animation_container);
-  flood_fill_animation_.SetDuration(kAnimationDuration);
-
   fade_out_animation_.SetContainer(animation_container);
-  fade_out_animation_.SetDuration(kAnimationDuration);
+
+  highlight_animation_.SetSlideDuration(
+      kHighlightAnimationDuration.InMilliseconds());
 }
 
 InstallableInkDropAnimator::~InstallableInkDropAnimator() = default;
@@ -76,8 +75,13 @@ void InstallableInkDropAnimator::AnimateToState(InkDropState target_state) {
       }
       // If we weren't already fading out, start fading out. Otherwise, just
       // continue fading out.
-      if (!fade_out_animation_.is_animating())
-        fade_out_animation_.Start();
+      if (!fade_out_animation_.is_animating()) {
+        const SubAnimation sub_animation =
+            target_state == InkDropState::HIDDEN
+                ? SubAnimation::kHiddenFadeOut
+                : SubAnimation::kDeactivatedFadeOut;
+        StartSubAnimation(sub_animation);
+      }
       break;
 
     case InkDropState::ACTION_PENDING:
@@ -86,19 +90,19 @@ void InstallableInkDropAnimator::AnimateToState(InkDropState target_state) {
         flood_fill_animation_.Stop();
         fade_out_animation_.Stop();
       }
-      flood_fill_animation_.Start();
+      StartSubAnimation(SubAnimation::kActionPendingFloodFill);
       break;
 
     case InkDropState::ACTION_TRIGGERED:
       if (last_state == InkDropState::HIDDEN) {
         // Start the flood fill. On this animation's end, we will start the fade
         // out animation in AnimationEnded().
-        flood_fill_animation_.Start();
+        StartSubAnimation(SubAnimation::kActionPendingFloodFill);
       } else if (last_state == InkDropState::ACTION_PENDING &&
                  !flood_fill_animation_.is_animating()) {
         // If we were done animating to ACTION_PENDING, we must start the fade
         // out animation here.
-        fade_out_animation_.Start();
+        StartSubAnimation(SubAnimation::kActionTriggeredFadeOut);
         // If we were in ACTION_PENDING but weren't done animating, we will
         // start the fade out animation in AnimationEnded().
       } else if (last_state != InkDropState::ACTION_PENDING) {
@@ -122,7 +126,7 @@ void InstallableInkDropAnimator::AnimateToState(InkDropState target_state) {
       }
 
       // Now simply start the flood fill animation again.
-      flood_fill_animation_.Start();
+      StartSubAnimation(SubAnimation::kActivatedFloodFill);
       break;
   }
 
@@ -139,6 +143,43 @@ void InstallableInkDropAnimator::AnimateHighlight(bool fade_in) {
   }
 }
 
+base::TimeDelta InstallableInkDropAnimator::GetSubAnimationDuration(
+    SubAnimation sub_animation) {
+  switch (sub_animation) {
+    case SubAnimation::kHiddenFadeOut:
+      return base::TimeDelta::FromMilliseconds(200);
+    case SubAnimation::kActionPendingFloodFill:
+      return base::TimeDelta::FromMilliseconds(240);
+    case SubAnimation::kActionTriggeredFadeOut:
+      return base::TimeDelta::FromMilliseconds(300);
+    case SubAnimation::kActivatedFloodFill:
+      return base::TimeDelta::FromMilliseconds(200);
+    case SubAnimation::kDeactivatedFadeOut:
+      return base::TimeDelta::FromMilliseconds(300);
+  }
+}
+
+void InstallableInkDropAnimator::StartSubAnimation(SubAnimation sub_animation) {
+  const base::TimeDelta duration = GetSubAnimationDuration(sub_animation);
+  switch (sub_animation) {
+    case SubAnimation::kHiddenFadeOut:
+    case SubAnimation::kActionTriggeredFadeOut:
+    case SubAnimation::kDeactivatedFadeOut:
+      if (!fade_out_animation_.is_animating()) {
+        fade_out_animation_.SetDuration(duration);
+        fade_out_animation_.Start();
+      }
+      break;
+    case SubAnimation::kActionPendingFloodFill:
+    case SubAnimation::kActivatedFloodFill:
+      if (!flood_fill_animation_.is_animating()) {
+        flood_fill_animation_.SetDuration(duration);
+        flood_fill_animation_.Start();
+      }
+      break;
+  }
+}
+
 void InstallableInkDropAnimator::VerifyAnimationState() const {
 #if DCHECK_IS_ON()
   switch (target_state_) {
@@ -185,7 +226,7 @@ void InstallableInkDropAnimator::AnimationEnded(
 
       case InkDropState::ACTION_TRIGGERED:
         // After filling, the ink drop should fade out.
-        fade_out_animation_.Start();
+        StartSubAnimation(SubAnimation::kActionTriggeredFadeOut);
         break;
 
       case InkDropState::ALTERNATE_ACTION_PENDING:
@@ -244,7 +285,7 @@ void InstallableInkDropAnimator::AnimationProgressed(
   } else if (animation == &flood_fill_animation_) {
     visual_state_->flood_fill_center = gfx::PointF(last_event_location_);
     visual_state_->flood_fill_progress = gfx::Tween::CalculateValue(
-        gfx::Tween::EASE_IN_OUT, flood_fill_animation_.GetCurrentValue());
+        gfx::Tween::FAST_OUT_SLOW_IN, flood_fill_animation_.GetCurrentValue());
   } else if (animation == &fade_out_animation_) {
     // Do nothing for now.
   } else {

ui/views/animation/installable_ink_drop_animator.h

@@ -28,10 +28,10 @@ namespace views {
 // InstallableInkDropPainter passed in. The animations are currently minimal.
 class VIEWS_EXPORT InstallableInkDropAnimator : public gfx::AnimationDelegate {
  public:
-  // Placeholder duration used for all animations. TODO(crbug.com/933384):
-  // remove this and replace it with separate durations for different
-  // animations.
-  static constexpr base::TimeDelta kAnimationDuration =
+  // Placeholder duration used for highlight animation. TODO(crbug.com/933384):
+  // remove this and make highlight animation duration controllable, like in
+  // InkDropHighlight.
+  static constexpr base::TimeDelta kHighlightAnimationDuration =
       base::TimeDelta::FromMilliseconds(500);
 
   // We use a shared gfx::AnimationContainer for our animations to allow them to
@@ -57,7 +57,27 @@ class VIEWS_EXPORT InstallableInkDropAnimator : public gfx::AnimationDelegate {
 
   InkDropState target_state() const { return target_state_; }
 
+  // The sub-animations used when animating to an |InkDropState|. These are used
+  // to look up the animation durations. This is mainly meant for internal use
+  // but is public for tests.
+  enum class SubAnimation {
+    kHiddenFadeOut,
+    kActionPendingFloodFill,
+    kActionTriggeredFadeOut,
+    kActivatedFloodFill,
+    kDeactivatedFadeOut,
+  };
+
+  static base::TimeDelta GetSubAnimationDurationForTesting(
+      SubAnimation sub_animation) {
+    return GetSubAnimationDuration(sub_animation);
+  }
+
  private:
+  static base::TimeDelta GetSubAnimationDuration(SubAnimation sub_animation);
+
+  void StartSubAnimation(SubAnimation sub_animation);
+
   // Checks that the states of our animations make sense given
   // |target_state_|. DCHECKs if something is wrong.
   void VerifyAnimationState() const;

ui/views/animation/installable_ink_drop_animator_unittest.cc

@@ -67,7 +67,8 @@ TEST_F(InstallableInkDropAnimatorTest, AnimateToTriggeredFromHidden) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionPendingFloodFill));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::ACTION_TRIGGERED, animator.target_state());
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
@@ -75,7 +76,8 @@ TEST_F(InstallableInkDropAnimatorTest, AnimateToTriggeredFromHidden) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionTriggeredFadeOut));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::HIDDEN, animator.target_state());
   EXPECT_EQ(0.0f, visual_state_.flood_fill_progress);
@@ -94,7 +96,8 @@ TEST_F(InstallableInkDropAnimatorTest,
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionPendingFloodFill));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::ACTION_PENDING, animator.target_state());
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
@@ -103,7 +106,8 @@ TEST_F(InstallableInkDropAnimatorTest,
   // The animation should be finished now and the visual state should *not*
   // change; ACTION_PENDING lasts indefinitely.
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionTriggeredFadeOut));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::ACTION_PENDING, animator.target_state());
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
@@ -115,7 +119,8 @@ TEST_F(InstallableInkDropAnimatorTest,
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
 
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionTriggeredFadeOut));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::HIDDEN, animator.target_state());
   EXPECT_EQ(0.0f, visual_state_.flood_fill_progress);
@@ -123,10 +128,12 @@ TEST_F(InstallableInkDropAnimatorTest,
 
 TEST_F(InstallableInkDropAnimatorTest,
        AnimateToPendingWhileAnimatingToTriggered) {
-  const base::TimeDelta kHalfAnimationDuration =
-      InstallableInkDropAnimator::kAnimationDuration / 2;
+  const base::TimeDelta kPendingAnimationDuration =
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActionPendingFloodFill);
+  const base::TimeDelta kHalfAnimationDuration = kPendingAnimationDuration / 2;
   const base::TimeDelta kRemainingAnimationDuration =
-      InstallableInkDropAnimator::kAnimationDuration - kHalfAnimationDuration;
+      kPendingAnimationDuration - kHalfAnimationDuration;
 
   InstallableInkDropAnimator animator(gfx::Size(10, 10), &visual_state_,
                                       animation_container_.get(), callback_);
@@ -170,7 +177,8 @@ TEST_F(InstallableInkDropAnimatorTest, AnimateToActivatedThenDeactivated) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActivatedFloodFill));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::ACTIVATED, animator.target_state());
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
@@ -178,7 +186,8 @@ TEST_F(InstallableInkDropAnimatorTest, AnimateToActivatedThenDeactivated) {
 
   // The state should stay the same indefinitely.
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kDeactivatedFadeOut));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::ACTIVATED, animator.target_state());
   EXPECT_EQ(1.0f, visual_state_.flood_fill_progress);
@@ -190,7 +199,8 @@ TEST_F(InstallableInkDropAnimatorTest, AnimateToActivatedThenDeactivated) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kDeactivatedFadeOut));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(InkDropState::HIDDEN, animator.target_state());
   EXPECT_EQ(0.0f, visual_state_.flood_fill_progress);
@@ -200,13 +210,14 @@ TEST_F(InstallableInkDropAnimatorTest,
        FloodFillAnimationExpandsFromEventLocation) {
   constexpr gfx::Point kEventLocation(3, 7);
 
-  // Split |InstallableInkDrop::kAnimationDuration| into three chunks.
-  const base::TimeDelta kFirstDuration =
-      InstallableInkDropAnimator::kAnimationDuration / 3;
+  const base::TimeDelta kActivatedAnimationDuration =
+      InstallableInkDropAnimator::GetSubAnimationDurationForTesting(
+          InstallableInkDropAnimator::SubAnimation::kActivatedFloodFill);
+  // Split |kActivatedAnimationDuration| into three chunks.
+  const base::TimeDelta kFirstDuration = kActivatedAnimationDuration / 3;
   const base::TimeDelta kSecondDuration = kFirstDuration;
   const base::TimeDelta kLastDuration =
-      InstallableInkDropAnimator::kAnimationDuration - kFirstDuration -
-      kSecondDuration;
+      kActivatedAnimationDuration - kFirstDuration - kSecondDuration;
 
   InstallableInkDropAnimator animator(gfx::Size(10, 10), &visual_state_,
                                       animation_container_.get(), callback_);
@@ -248,7 +259,7 @@ TEST_F(InstallableInkDropAnimatorTest, HighlightAnimationFadesInAndOut) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::kHighlightAnimationDuration);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1.0f, visual_state_.highlighted_ratio);
   EXPECT_TRUE(callback_called_);
@@ -258,7 +269,7 @@ TEST_F(InstallableInkDropAnimatorTest, HighlightAnimationFadesInAndOut) {
 
   callback_called_ = false;
   animation_tester_.IncrementTime(
-      InstallableInkDropAnimator::kAnimationDuration);
+      InstallableInkDropAnimator::kHighlightAnimationDuration);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0.0f, visual_state_.highlighted_ratio);
   EXPECT_TRUE(callback_called_);