Rename of InkDropAnimation classes to InkDropRipple.

ui/views/animation/flood_fill_ink_drop_ripple.cc

 // Copyright 2016 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/flood_fill_ink_drop_animation.h"
+#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/vector2d_f.h"
@@ skipping 73 matching lines @@
     200,  // ALTERNATE_ACTION_PENDING
     300,  // ALTERNATE_ACTION_TRIGGERED_FADE_OUT
     150,  // ACTIVATED_FADE_IN
     200,  // ACTIVATED_TRANSFORM
     300,  // DEACTIVATED_FADE_OUT
 };
 
 // Returns the InkDropState sub animation duration for the given |state|.
 base::TimeDelta GetAnimationDuration(InkDropSubAnimations state) {
   return base::TimeDelta::FromMilliseconds(
-      (views::InkDropAnimation::UseFastAnimations()
+      (views::InkDropRipple::UseFastAnimations()
            ? 1
-           : views::InkDropAnimation::kSlowAnimationDurationFactor) *
+           : views::InkDropRipple::kSlowAnimationDurationFactor) *
       kAnimationDurationInMs[state]);
 }
 
 }  // namespace
 
 namespace views {
 
-FloodFillInkDropAnimation::FloodFillInkDropAnimation(
-    const gfx::Rect& clip_bounds,
-    const gfx::Point& center_point,
-    SkColor color)
+FloodFillInkDropRipple::FloodFillInkDropRipple(const gfx::Rect& clip_bounds,
+                                               const gfx::Point& center_point,
+                                               SkColor color)
     : clip_bounds_(clip_bounds),
       center_point_(center_point),
       root_layer_(ui::LAYER_NOT_DRAWN),
       circle_layer_delegate_(
           color,
           std::max(clip_bounds_.width(), clip_bounds_.height()) / 2.f),
       ink_drop_state_(InkDropState::HIDDEN) {
-  root_layer_.set_name("FloodFillInkDropAnimation:ROOT_LAYER");
+  root_layer_.set_name("FloodFillInkDropRipple:ROOT_LAYER");
   root_layer_.SetMasksToBounds(true);
   root_layer_.SetBounds(clip_bounds);
 
   const int painted_size_length =
       2 * std::max(clip_bounds_.width(), clip_bounds_.height());
 
   painted_layer_.SetBounds(gfx::Rect(painted_size_length, painted_size_length));
   painted_layer_.SetFillsBoundsOpaquely(false);
   painted_layer_.set_delegate(&circle_layer_delegate_);
   painted_layer_.SetVisible(true);
   painted_layer_.SetOpacity(1.0);
   painted_layer_.SetMasksToBounds(false);
-  painted_layer_.set_name("FloodFillInkDropAnimation:PAINTED_LAYER");
+  painted_layer_.set_name("FloodFillInkDropRipple:PAINTED_LAYER");
 
   root_layer_.Add(&painted_layer_);
 
   SetStateToHidden();
 }
 
-FloodFillInkDropAnimation::~FloodFillInkDropAnimation() {
+FloodFillInkDropRipple::~FloodFillInkDropRipple() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
-void FloodFillInkDropAnimation::SnapToActivated() {
-  InkDropAnimation::SnapToActivated();
+void FloodFillInkDropRipple::SnapToActivated() {
+  InkDropRipple::SnapToActivated();
   SetOpacity(kVisibleOpacity);
   painted_layer_.SetTransform(GetMaxSizeTargetTransform());
 }
 
-ui::Layer* FloodFillInkDropAnimation::GetRootLayer() {
+ui::Layer* FloodFillInkDropRipple::GetRootLayer() {
   return &root_layer_;
 }
 
-bool FloodFillInkDropAnimation::IsVisible() const {
+bool FloodFillInkDropRipple::IsVisible() const {
   return root_layer_.visible();
 }
 
-void FloodFillInkDropAnimation::AnimateStateChange(
+void FloodFillInkDropRipple::AnimateStateChange(
     InkDropState old_ink_drop_state,
     InkDropState new_ink_drop_state,
     ui::LayerAnimationObserver* animation_observer) {
   switch (new_ink_drop_state) {
     case InkDropState::HIDDEN:
       if (!IsVisible()) {
         SetStateToHidden();
       } else {
         AnimateToOpacity(kHiddenOpacity, GetAnimationDuration(HIDDEN_FADE_OUT),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
@@ skipping 67 matching lines @@
     }
     case InkDropState::DEACTIVATED:
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(DEACTIVATED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
   }
 }
 
-void FloodFillInkDropAnimation::SetStateToHidden() {
+void FloodFillInkDropRipple::SetStateToHidden() {
   painted_layer_.SetTransform(CalculateTransform(kMinRadius));
-  root_layer_.SetOpacity(InkDropAnimation::kHiddenOpacity);
+  root_layer_.SetOpacity(InkDropRipple::kHiddenOpacity);
   root_layer_.SetVisible(false);
 }
 
-void FloodFillInkDropAnimation::AbortAllAnimations() {
+void FloodFillInkDropRipple::AbortAllAnimations() {
   root_layer_.GetAnimator()->AbortAllAnimations();
   painted_layer_.GetAnimator()->AbortAllAnimations();
 }
 
-void FloodFillInkDropAnimation::AnimateToTransform(
+void FloodFillInkDropRipple::AnimateToTransform(
     const gfx::Transform& transform,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   ui::LayerAnimator* animator = painted_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetPreemptionStrategy(preemption_strategy);
   animation.SetTweenType(tween);
   ui::LayerAnimationElement* element =
       ui::LayerAnimationElement::CreateTransformElement(transform, duration);
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(element);
 
   if (animation_observer)
     sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(sequence);
 }
 
-void FloodFillInkDropAnimation::SetOpacity(float opacity) {
+void FloodFillInkDropRipple::SetOpacity(float opacity) {
   root_layer_.SetOpacity(opacity);
 }
 
-void FloodFillInkDropAnimation::AnimateToOpacity(
+void FloodFillInkDropRipple::AnimateToOpacity(
     float opacity,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   ui::LayerAnimator* animator = root_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation_settings(animator);
   animation_settings.SetPreemptionStrategy(preemption_strategy);
   animation_settings.SetTweenType(tween);
   ui::LayerAnimationElement* animation_element =
       ui::LayerAnimationElement::CreateOpacityElement(opacity, duration);
   ui::LayerAnimationSequence* animation_sequence =
       new ui::LayerAnimationSequence(animation_element);
 
   if (animation_observer)
     animation_sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(animation_sequence);
 }
 
-gfx::Transform FloodFillInkDropAnimation::CalculateTransform(
+gfx::Transform FloodFillInkDropRipple::CalculateTransform(
     float target_radius) const {
   const float target_scale = target_radius / circle_layer_delegate_.radius();
   const gfx::Point drawn_center_point =
       ToRoundedPoint(circle_layer_delegate_.GetCenterPoint());
 
   gfx::Transform transform = gfx::Transform();
   transform.Translate(center_point_.x(), center_point_.y());
   transform.Scale(target_scale, target_scale);
   transform.Translate(-drawn_center_point.x() - root_layer_.bounds().x(),
                       -drawn_center_point.y() - root_layer_.bounds().y());
 
   return transform;
 }
 
-gfx::Transform FloodFillInkDropAnimation::GetMaxSizeTargetTransform() const {
+gfx::Transform FloodFillInkDropRipple::GetMaxSizeTargetTransform() const {
   // TODO(estade): get rid of this 2, but make the fade out start before the
   // active/action transform is done.
   return CalculateTransform(
       gfx::Vector2dF(clip_bounds_.width(), clip_bounds_.height()).Length() / 2);
 }
 
 }  // namespace views