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 "ui/compositor/layer.h"
 #include "ui/views/animation/ink_drop_animation.h"
 #include "ui/views/animation/ink_drop_host.h"
 #include "ui/views/animation/ink_drop_hover.h"
 
 namespace views {
 
 namespace {
 
 // The duration of the hover state fade in animation.
 const int kFadeInDurationInMs = 250;
 
 // The duration of the hover state fade out animation.
 const int kFadeOutDurationInMs = 250;
 
 }  // namespace
 
 InkDropAnimationControllerImpl::InkDropAnimationControllerImpl(
     InkDropHost* ink_drop_host)
     : ink_drop_host_(ink_drop_host),
       ink_drop_large_corner_radius_(0),
       ink_drop_small_corner_radius_(0),
-      root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)) {
+      root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
+      can_destroy_after_hidden_animation_(true) {
   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();
 }
 
 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 {

[varkha, 2015/11/06 00:00:27]

nit: Maybe ShouldAutoAnimateToHidden? It is not really a promise as much as a
configuration dictated by this implementation.

[bruthig, 2015/11/11 18:11:20]

From the perspective of the InkDropAnimationController clients this is a
promise. For example in ToolbarButton::OnGestureEvent() it checks
WillAutoAnimateToHidden() to know whether to pass along an
AnimateToState(HIDDEN) or not.  If this is not a promise then clients would not
be able to depend on it.

Having said that, I'm not too keen on the name and am open to changing it but
I'm hesitant to use 'Should' because that implies it isn't a promise when I
actually want it to be.

+  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) {
   if (IsHovered() == is_hovered)
     return;
 
   if (is_hovered) {
     if (!hover_)
       CreateInkDropHover();
     if (GetInkDropState() == views::InkDropState::HIDDEN) {
       base::TimeDelta duration =
           base::TimeDelta::FromMilliseconds(kFadeInDurationInMs);
@@ skipping 92 matching lines @@
       SetHovered(false);
       break;
   }
 }
 
 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:
+  if (WillAutoAnimateToHidden())
+    ink_drop_animation_->AnimateToState(views::InkDropState::HIDDEN);
+  else if (ink_drop_state == views::InkDropState::HIDDEN &&
+           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;
   }
 }
 
 }  // namespace views