Rename of InkDropAnimationController classes to InkDrop.

ui/views/animation/ink_drop_impl.cc

Index: ui/views/animation/ink_drop_impl.cc
diff --git a/ui/views/animation/ink_drop_animation_controller_impl.cc b/ui/views/animation/ink_drop_impl.cc
similarity index 75%
copy from ui/views/animation/ink_drop_animation_controller_impl.cc
copy to ui/views/animation/ink_drop_impl.cc
index 86503f55ef27adbd9dea78101ba73d5aeec3624c..cce475b58b571bd75a16da0ed910792193c339bb 100644
--- a/ui/views/animation/ink_drop_animation_controller_impl.cc
+++ b/ui/views/animation/ink_drop_impl.cc
@@ -2,7 +2,7 @@
 // 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 "ui/views/animation/ink_drop_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/timer/timer.h"
@@ -50,35 +50,33 @@ bool ShouldAnimateToHidden(InkDropState ink_drop_state) {
 
 }  // namespace
 
-InkDropAnimationControllerImpl::InkDropAnimationControllerImpl(
-    InkDropHost* ink_drop_host)
+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),
       hover_after_ripple_timer_(nullptr) {
-  root_layer_->set_name("InkDropAnimationControllerImpl:RootLayer");
+  root_layer_->set_name("InkDropImpl:RootLayer");
 }
 
-InkDropAnimationControllerImpl::~InkDropAnimationControllerImpl() {
+InkDropImpl::~InkDropImpl() {
   // Explicitly destroy the InkDropRipple so that this still exists if
   // views::InkDropRippleObserver methods are called on this.
   DestroyInkDropRipple();
   DestroyInkDropHover();
 }
 
-InkDropState InkDropAnimationControllerImpl::GetTargetInkDropState() const {
+InkDropState InkDropImpl::GetTargetInkDropState() const {
   if (!ink_drop_ripple_)
     return InkDropState::HIDDEN;
   return ink_drop_ripple_->target_ink_drop_state();
 }
 
-bool InkDropAnimationControllerImpl::IsVisible() const {
+bool InkDropImpl::IsVisible() const {
   return ink_drop_ripple_ && ink_drop_ripple_->IsVisible();
 }
 
-void InkDropAnimationControllerImpl::AnimateToState(
-    InkDropState ink_drop_state) {
+void InkDropImpl::AnimateToState(InkDropState ink_drop_state) {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_ripple_)
     CreateInkDropRipple();
@@ -92,7 +90,7 @@ void InkDropAnimationControllerImpl::AnimateToState(
   ink_drop_ripple_->AnimateToState(ink_drop_state);
 }
 
-void InkDropAnimationControllerImpl::SnapToActivated() {
+void InkDropImpl::SnapToActivated() {
   DestroyHiddenTargetedAnimations();
   if (!ink_drop_ripple_)
     CreateInkDropRipple();
@@ -102,7 +100,7 @@ void InkDropAnimationControllerImpl::SnapToActivated() {
   ink_drop_ripple_->SnapToActivated();
 }
 
-void InkDropAnimationControllerImpl::SetHovered(bool is_hovered) {
+void InkDropImpl::SetHovered(bool is_hovered) {
   is_hovered_ = is_hovered;
   SetHoveredInternal(is_hovered,
                      is_hovered ? base::TimeDelta::FromMilliseconds(
@@ -112,7 +110,7 @@ void InkDropAnimationControllerImpl::SetHovered(bool is_hovered) {
                      false);
 }
 
-void InkDropAnimationControllerImpl::DestroyHiddenTargetedAnimations() {
+void InkDropImpl::DestroyHiddenTargetedAnimations() {
   if (ink_drop_ripple_ &&
       (ink_drop_ripple_->target_ink_drop_state() == InkDropState::HIDDEN ||
        ShouldAnimateToHidden(ink_drop_ripple_->target_ink_drop_state()))) {
@@ -120,7 +118,7 @@ void InkDropAnimationControllerImpl::DestroyHiddenTargetedAnimations() {
   }
 }
 
-void InkDropAnimationControllerImpl::CreateInkDropRipple() {
+void InkDropImpl::CreateInkDropRipple() {
   DestroyInkDropRipple();
   ink_drop_ripple_ = ink_drop_host_->CreateInkDropRipple();
   ink_drop_ripple_->set_observer(this);
@@ -128,7 +126,7 @@ void InkDropAnimationControllerImpl::CreateInkDropRipple() {
   AddRootLayerToHostIfNeeded();
 }
 
-void InkDropAnimationControllerImpl::DestroyInkDropRipple() {
+void InkDropImpl::DestroyInkDropRipple() {
   if (!ink_drop_ripple_)
     return;
   root_layer_->Remove(ink_drop_ripple_->GetRootLayer());
@@ -136,7 +134,7 @@ void InkDropAnimationControllerImpl::DestroyInkDropRipple() {
   RemoveRootLayerFromHostIfNeeded();
 }
 
-void InkDropAnimationControllerImpl::CreateInkDropHover() {
+void InkDropImpl::CreateInkDropHover() {
   DestroyInkDropHover();
 
   hover_ = ink_drop_host_->CreateInkDropHover();
@@ -147,7 +145,7 @@ void InkDropAnimationControllerImpl::CreateInkDropHover() {
   AddRootLayerToHostIfNeeded();
 }
 
-void InkDropAnimationControllerImpl::DestroyInkDropHover() {
+void InkDropImpl::DestroyInkDropHover() {
   if (!hover_)
     return;
   root_layer_->Remove(hover_->layer());
@@ -156,7 +154,7 @@ void InkDropAnimationControllerImpl::DestroyInkDropHover() {
   RemoveRootLayerFromHostIfNeeded();
 }
 
-void InkDropAnimationControllerImpl::AddRootLayerToHostIfNeeded() {
+void InkDropImpl::AddRootLayerToHostIfNeeded() {
   DCHECK(hover_ || ink_drop_ripple_);
   if (!root_layer_added_to_host_) {
     root_layer_added_to_host_ = true;
@@ -164,26 +162,24 @@ void InkDropAnimationControllerImpl::AddRootLayerToHostIfNeeded() {
   }
 }
 
-void InkDropAnimationControllerImpl::RemoveRootLayerFromHostIfNeeded() {
+void InkDropImpl::RemoveRootLayerFromHostIfNeeded() {
   if (root_layer_added_to_host_ && !hover_ && !ink_drop_ripple_) {
     root_layer_added_to_host_ = false;
     ink_drop_host_->RemoveInkDropLayer(root_layer_.get());
   }
 }
 
-bool InkDropAnimationControllerImpl::IsHoverFadingInOrVisible() const {
+bool InkDropImpl::IsHoverFadingInOrVisible() const {
   return hover_ && hover_->IsFadingInOrVisible();
 }
 
 // -----------------------------------------------------------------------------
 // views::InkDropRippleObserver:
 
-void InkDropAnimationControllerImpl::AnimationStarted(
-    InkDropState ink_drop_state) {}
+void InkDropImpl::AnimationStarted(InkDropState ink_drop_state) {}
 
-void InkDropAnimationControllerImpl::AnimationEnded(
-    InkDropState ink_drop_state,
-    InkDropAnimationEndedReason reason) {
+void InkDropImpl::AnimationEnded(InkDropState ink_drop_state,
+                                 InkDropAnimationEndedReason reason) {
   if (reason != InkDropAnimationEndedReason::SUCCESS)
     return;
   if (ShouldAnimateToHidden(ink_drop_state)) {
@@ -201,22 +197,20 @@ void InkDropAnimationControllerImpl::AnimationEnded(
 // -----------------------------------------------------------------------------
 // views::InkDropHoverObserver:
 
-void InkDropAnimationControllerImpl::AnimationStarted(
-    InkDropHover::AnimationType animation_type) {}
+void InkDropImpl::AnimationStarted(InkDropHover::AnimationType animation_type) {
+}
 
-void InkDropAnimationControllerImpl::AnimationEnded(
-    InkDropHover::AnimationType animation_type,
-    InkDropAnimationEndedReason reason) {
+void InkDropImpl::AnimationEnded(InkDropHover::AnimationType animation_type,
+                                 InkDropAnimationEndedReason reason) {
   if (animation_type == InkDropHover::FADE_OUT &&
       reason == InkDropAnimationEndedReason::SUCCESS) {
     DestroyInkDropHover();
   }
 }
 
-void InkDropAnimationControllerImpl::SetHoveredInternal(
-    bool is_hovered,
-    base::TimeDelta animation_duration,
-    bool explode) {
+void InkDropImpl::SetHoveredInternal(bool is_hovered,
+                                     base::TimeDelta animation_duration,
+                                     bool explode) {
   StopHoverAfterRippleTimer();
 
   if (IsHoverFadingInOrVisible() == is_hovered)
@@ -231,7 +225,7 @@ void InkDropAnimationControllerImpl::SetHoveredInternal(
   }
 }
 
-void InkDropAnimationControllerImpl::StartHoverAfterRippleTimer() {
+void InkDropImpl::StartHoverAfterRippleTimer() {
   StopHoverAfterRippleTimer();
 
   if (!hover_after_ripple_timer_)
@@ -240,16 +234,16 @@ void InkDropAnimationControllerImpl::StartHoverAfterRippleTimer() {
   hover_after_ripple_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kHoverFadeInAfterRippleDelayInMs),
-      base::Bind(&InkDropAnimationControllerImpl::HoverAfterRippleTimerFired,
+      base::Bind(&InkDropImpl::HoverAfterRippleTimerFired,
                  base::Unretained(this)));
 }
 
-void InkDropAnimationControllerImpl::StopHoverAfterRippleTimer() {
+void InkDropImpl::StopHoverAfterRippleTimer() {
   if (hover_after_ripple_timer_)
     hover_after_ripple_timer_.reset();
 }
 
-void InkDropAnimationControllerImpl::HoverAfterRippleTimerFired() {
+void InkDropImpl::HoverAfterRippleTimerFired() {
   SetHoveredInternal(true, base::TimeDelta::FromMilliseconds(
                                kHoverFadeInAfterRippleDurationInMs),
                      true);