Expand the Material Design hover as it fades out when a ripple is triggered.

ui/views/animation/ink_drop_animation_controller_impl.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/animation/ink_drop_animation_controller_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/timer/timer.h"
 #include "ui/compositor/layer.h"
 #include "ui/views/animation/ink_drop_host.h"
@@ skipping 11 matching lines @@
 // The duration, in milliseconds, of the hover state fade out animation when it
 // is triggered by user input.
 const int kHoverFadeOutFromUserInputDurationInMs = 250;
 
 // The duration, in milliseconds, of the hover state fade in animation when it
 // is triggered by an ink drop ripple animation ending.
 const int kHoverFadeInAfterAnimationDurationInMs = 250;
 
 // The duration, in milliseconds, of the hover state fade out animation when it
 // is triggered by an ink drop ripple animation starting.
-const int kHoverFadeOutBeforeAnimationDurationInMs = 300;
+const int kHoverFadeOutBeforeAnimationDurationInMs = 120;
 
 // The amount of time in milliseconds that |hover_| should delay after a ripple
 // animation before fading in.
 const int kHoverFadeInAfterAnimationDelayInMs = 1000;
 
 // Returns true if an ink drop with the given |ink_drop_state| should
 // automatically transition to the InkDropState::HIDDEN state.
 bool ShouldAnimateToHidden(InkDropState ink_drop_state) {
   switch (ink_drop_state) {
     case views::InkDropState::ACTION_TRIGGERED:
@@ skipping 35 matching lines @@
 }
 
 void InkDropAnimationControllerImpl::AnimateToState(
     InkDropState ink_drop_state) {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_animation_)
     CreateInkDropAnimation();
 
   if (ink_drop_state != views::InkDropState::HIDDEN) {
     SetHoveredInternal(false, base::TimeDelta::FromMilliseconds(
-                                  kHoverFadeOutBeforeAnimationDurationInMs));
+                                  kHoverFadeOutBeforeAnimationDurationInMs),
+                       true);
   }
 
   ink_drop_animation_->AnimateToState(ink_drop_state);
 }
 
 void InkDropAnimationControllerImpl::SnapToActivated() {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_animation_)
     CreateInkDropAnimation();
 
-  SetHoveredInternal(false, base::TimeDelta());
+  SetHoveredInternal(false, base::TimeDelta(), false);
 
   ink_drop_animation_->SnapToActivated();
 }
 
 void InkDropAnimationControllerImpl::SetHovered(bool is_hovered) {
   is_hovered_ = is_hovered;
   SetHoveredInternal(is_hovered,
                      is_hovered ? base::TimeDelta::FromMilliseconds(
                                       kHoverFadeInFromUserInputDurationInMs)
                                 : base::TimeDelta::FromMilliseconds(
-                                      kHoverFadeOutFromUserInputDurationInMs));
+                                      kHoverFadeOutFromUserInputDurationInMs),
+                     false);
 }
 
 void InkDropAnimationControllerImpl::DestroyHiddenTargetedAnimations() {
   if (ink_drop_animation_ &&
       (ink_drop_animation_->target_ink_drop_state() == InkDropState::HIDDEN ||
        ShouldAnimateToHidden(ink_drop_animation_->target_ink_drop_state()))) {
     DestroyInkDropAnimation();
   }
 }
 
@@ skipping 47 matching lines @@
       StartHoverAfterAnimationTimer();
     // TODO(bruthig): Investigate whether creating and destroying
     // InkDropAnimations is expensive and consider creating an
     // InkDropAnimationPool. See www.crbug.com/522175.
     DestroyInkDropAnimation();
   }
 }
 
 void InkDropAnimationControllerImpl::SetHoveredInternal(
     bool is_hovered,
-    base::TimeDelta animation_duration) {
+    base::TimeDelta animation_duration,
+    bool explode) {
   StopHoverAfterAnimationTimer();
 
   if (IsHoverFadingInOrVisible() == is_hovered)
     return;
 
   if (is_hovered) {
     CreateInkDropHover();
     if (hover_ && !IsVisible())
       hover_->FadeIn(animation_duration);
   } else {
-    hover_->FadeOut(animation_duration);
+    hover_->FadeOut(animation_duration, explode);
   }
 }
 
 void InkDropAnimationControllerImpl::StartHoverAfterAnimationTimer() {
   StopHoverAfterAnimationTimer();
 
   if (!hover_after_animation_timer_)
     hover_after_animation_timer_.reset(new base::OneShotTimer);
 
   hover_after_animation_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kHoverFadeInAfterAnimationDelayInMs),
       base::Bind(&InkDropAnimationControllerImpl::HoverAfterAnimationTimerFired,
                  base::Unretained(this)));
 }
 
 void InkDropAnimationControllerImpl::StopHoverAfterAnimationTimer() {
   if (hover_after_animation_timer_)
     hover_after_animation_timer_.reset();
 }
 
 void InkDropAnimationControllerImpl::HoverAfterAnimationTimerFired() {
   SetHoveredInternal(true, base::TimeDelta::FromMilliseconds(
-                               kHoverFadeInAfterAnimationDurationInMs));
+                               kHoverFadeInAfterAnimationDurationInMs),
+                     true);
   hover_after_animation_timer_.reset();
 }
 
 }  // namespace views