Made material design ink drop QUICK_ACTION animation more visible.

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_animation.h"
 #include "ui/views/animation/ink_drop_consumer.h"
 #include "ui/views/animation/ink_drop_host.h"
 #include "ui/views/animation/ink_drop_hover.h"
 
 namespace views {
 
 namespace {
@@ skipping 21 matching lines @@
 }  // namespace
 
 InkDropAnimationControllerImpl::InkDropAnimationControllerImpl(
     InkDropHost* ink_drop_host,
     InkDropConsumer* ink_drop_consumer)
     : ink_drop_host_(ink_drop_host),
       ink_drop_consumer_(ink_drop_consumer),
       ink_drop_large_corner_radius_(0),
       ink_drop_small_corner_radius_(0),
       root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
+      can_destroy_after_hidden_animation_(true),
       hover_after_animation_timer_(new base::OneShotTimer()) {
   ink_drop_host_->AddInkDropLayer(root_layer_.get());
 }
 
 InkDropAnimationControllerImpl::~InkDropAnimationControllerImpl() {
   // Explicitly destroy the InkDropAnimation so that this still exists if
   // views::InkDropAnimationObserver methods are called on this.
   DestroyInkDropAnimation();
   ink_drop_host_->RemoveInkDropLayer(root_layer_.get());
 }
 
 InkDropState InkDropAnimationControllerImpl::GetInkDropState() const {
   if (!ink_drop_animation_)
     return InkDropState::HIDDEN;
   return ink_drop_animation_->ink_drop_state();
 }
 
 void InkDropAnimationControllerImpl::AnimateToState(
     InkDropState ink_drop_state) {
   if (!ink_drop_animation_)
     CreateInkDropAnimation();
+
+  // The InkDropAnimationObserver::InkDropAnimationEnded() callback needs to
+  // know if it is safe to destroy the |ink_drop_animation_| and it is not safe
+  // when the notification is raised within a call to
+  // InkDropAnimation::AnimateToState().
+  base::AutoReset<bool> auto_reset_can_destroy_after_hidden_animation(
+      &can_destroy_after_hidden_animation_, false);
+
+  // Make sure the ink drop completes its full state transitions if it was going
+  // to auto transition to the HIDDEN state.
+  if (WillAutoAnimateToHidden())
+    ink_drop_animation_->AnimateToState(views::InkDropState::HIDDEN);
   ink_drop_animation_->AnimateToState(ink_drop_state);
 }
 
+bool InkDropAnimationControllerImpl::WillAutoAnimateToHidden() const {
+  if (!ink_drop_animation_)
+    return false;
+  switch (ink_drop_animation_->ink_drop_state()) {
+    case views::InkDropState::QUICK_ACTION:
+    case views::InkDropState::SLOW_ACTION:
+    case views::InkDropState::DEACTIVATED:
+      return true;
+    default:
+      return false;
+  }
+}
+
 void InkDropAnimationControllerImpl::SetHovered(bool is_hovered) {
   SetHoveredInternal(is_hovered,
                      is_hovered ? base::TimeDelta::FromMilliseconds(
                                       kHoverFadeInFromUserInputDurationInMs)
                                 : base::TimeDelta::FromMilliseconds(
                                       kHoverFadeOutFromUserInputDurationInMs));
 }
 
 bool InkDropAnimationControllerImpl::IsHovered() const {
   return hover_ && hover_->IsVisible();
@@ skipping 76 matching lines @@
     SetHoveredInternal(false, base::TimeDelta::FromMilliseconds(
                                   kHoverFadeOutBeforeAnimationDurationInMs));
   }
 }
 
 void InkDropAnimationControllerImpl::InkDropAnimationEnded(
     InkDropState ink_drop_state,
     InkDropAnimationEndedReason reason) {
   if (reason != SUCCESS)
     return;
-  switch (ink_drop_state) {
-    case views::InkDropState::QUICK_ACTION:
-    case views::InkDropState::SLOW_ACTION:
-    case views::InkDropState::DEACTIVATED:
-      ink_drop_animation_->AnimateToState(views::InkDropState::HIDDEN);
-      break;
-    case views::InkDropState::HIDDEN:
-      StartHoverAfterAnimationTimer();
+  if (WillAutoAnimateToHidden())
+    ink_drop_animation_->AnimateToState(views::InkDropState::HIDDEN);
+  else if (ink_drop_state == views::InkDropState::HIDDEN) {
+    StartHoverAfterAnimationTimer();
+    if (can_destroy_after_hidden_animation_) {
       // TODO(bruthig): Investigate whether creating and destroying
       // InkDropAnimations is expensive and consider creating an
       // InkDropAnimationPool. See www.crbug.com/522175.
       DestroyInkDropAnimation();
-      break;
-    default:
-      break;
+    }
   }
 }
 
 void InkDropAnimationControllerImpl::SetHoveredInternal(
     bool is_hovered,
     base::TimeDelta animation_duration) {
   StopHoverAfterAnimationTimer();
 
   if (IsHovered() == is_hovered)
     return;
@@ skipping 24 matching lines @@
     hover_after_animation_timer_->Reset();
 }
 
 void InkDropAnimationControllerImpl::HoverAfterAnimationTimerFired() {
   SetHoveredInternal(ink_drop_consumer_->ShouldShowInkDropHover(),
                      base::TimeDelta::FromMilliseconds(
                          kHoverFadeInAfterAnimationDurationInMs));
 }
 
 }  // namespace views