Use ink drop hover for focus states on toolbar buttons and location

ui/views/animation/ink_drop_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_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 37 matching lines @@
   }
 }
 
 }  // namespace
 
 InkDropImpl::InkDropImpl(InkDropHost* ink_drop_host)
     : ink_drop_host_(ink_drop_host),
       root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
       root_layer_added_to_host_(false),
       is_hovered_(false),
+      is_focused_(false),
       hover_after_ripple_timer_(nullptr) {
   root_layer_->set_name("InkDropImpl:RootLayer");
 }
 
 InkDropImpl::~InkDropImpl() {
   // Explicitly destroy the InkDropRipple so that this still exists if
   // views::InkDropRippleObserver methods are called on this.
   DestroyInkDropRipple();
   DestroyInkDropHover();
 }
 
 InkDropState InkDropImpl::GetTargetInkDropState() const {
   if (!ink_drop_ripple_)
     return InkDropState::HIDDEN;
   return ink_drop_ripple_->target_ink_drop_state();
 }
 
 bool InkDropImpl::IsVisible() const {
   return ink_drop_ripple_ && ink_drop_ripple_->IsVisible();
 }
 
 void InkDropImpl::AnimateToState(InkDropState ink_drop_state) {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_ripple_)
     CreateInkDropRipple();
 
   if (ink_drop_state != views::InkDropState::HIDDEN) {
-    SetHoveredInternal(false, base::TimeDelta::FromMilliseconds(
-                                  kHoverFadeOutBeforeRippleDurationInMs),
-                       true);
+    SetHighlight(false, base::TimeDelta::FromMilliseconds(
+                            kHoverFadeOutBeforeRippleDurationInMs),
+                 true);
   }
 
   ink_drop_ripple_->AnimateToState(ink_drop_state);
 }
 
 void InkDropImpl::SnapToActivated() {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_ripple_)
     CreateInkDropRipple();
 
-  SetHoveredInternal(false, base::TimeDelta(), false);
+  SetHighlight(false, base::TimeDelta(), false);
 
   ink_drop_ripple_->SnapToActivated();
 }
 
 void InkDropImpl::SetHovered(bool is_hovered) {
   is_hovered_ = is_hovered;
-  SetHoveredInternal(is_hovered,
-                     is_hovered ? base::TimeDelta::FromMilliseconds(
-                                      kHoverFadeInFromUserInputDurationInMs)
-                                : base::TimeDelta::FromMilliseconds(
-                                      kHoverFadeOutFromUserInputDurationInMs),
-                     false);
+  SetHighlight(ShouldHighlight(),
+               ShouldHighlight() ? base::TimeDelta::FromMilliseconds(
+                                       kHoverFadeInFromUserInputDurationInMs)
+                                 : base::TimeDelta::FromMilliseconds(
+                                       kHoverFadeOutFromUserInputDurationInMs),
+               false);
+}
+
+void InkDropImpl::SetFocused(bool is_focused) {
+  is_focused_ = is_focused;
+  SetHighlight(ShouldHighlight(), base::TimeDelta(), false);
 }
 
 void InkDropImpl::DestroyHiddenTargetedAnimations() {
   if (ink_drop_ripple_ &&
       (ink_drop_ripple_->target_ink_drop_state() == InkDropState::HIDDEN ||
        ShouldAnimateToHidden(ink_drop_ripple_->target_ink_drop_state()))) {
     DestroyInkDropRipple();
   }
 }
 
@@ skipping 80 matching lines @@
 }
 
 void InkDropImpl::AnimationEnded(InkDropHover::AnimationType animation_type,
                                  InkDropAnimationEndedReason reason) {
   if (animation_type == InkDropHover::FADE_OUT &&
       reason == InkDropAnimationEndedReason::SUCCESS) {
     DestroyInkDropHover();
   }
 }
 
-void InkDropImpl::SetHoveredInternal(bool is_hovered,
-                                     base::TimeDelta animation_duration,
-                                     bool explode) {
+void InkDropImpl::SetHighlight(bool should_highlight,
+                               base::TimeDelta animation_duration,
+                               bool explode) {
   StopHoverAfterRippleTimer();
 
-  if (IsHoverFadingInOrVisible() == is_hovered)
+  if (IsHoverFadingInOrVisible() == should_highlight)
     return;
 
-  if (is_hovered) {
+  if (should_highlight) {
     CreateInkDropHover();
     if (hover_ && !IsVisible())
       hover_->FadeIn(animation_duration);
   } else {
     hover_->FadeOut(animation_duration, explode);
   }
 }
 
+bool InkDropImpl::ShouldHighlight() const {
+  return is_focused_ || is_hovered_;
+}
+
 void InkDropImpl::StartHoverAfterRippleTimer() {
   StopHoverAfterRippleTimer();
 
   if (!hover_after_ripple_timer_)
     hover_after_ripple_timer_.reset(new base::OneShotTimer);
 
   hover_after_ripple_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kHoverFadeInAfterRippleDelayInMs),
       base::Bind(&InkDropImpl::HoverAfterRippleTimerFired,
                  base::Unretained(this)));
 }
 
 void InkDropImpl::StopHoverAfterRippleTimer() {
   if (hover_after_ripple_timer_)
     hover_after_ripple_timer_.reset();
 }
 
 void InkDropImpl::HoverAfterRippleTimerFired() {
-  SetHoveredInternal(true, base::TimeDelta::FromMilliseconds(
-                               kHoverFadeInAfterRippleDurationInMs),
-                     true);
+  SetHighlight(true, base::TimeDelta::FromMilliseconds(
+                         kHoverFadeInAfterRippleDurationInMs),
+               true);
   hover_after_ripple_timer_.reset();
 }
 
 }  // namespace views