Rename of InkDropAnimation classes to InkDropRipple.

ui/views/animation/square_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/square_ink_drop_animation.h"
+#include "ui/views/animation/square_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.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/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/point_f.h"
@@ skipping 104 matching lines @@
     200,  // ALTERNATE_ACTION_TRIGGERED_TRANSFORM
     200,  // ACTIVATED_CIRCLE_TRANSFORM
     160,  // ACTIVATED_RECT_TRANSFORM
     150,  // DEACTIVATED_FADE_OUT
     200,  // DEACTIVATED_TRANSFORM
 };
 
 // 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]);
 }
 
 // Calculates a Transform for a circle layer. The transform will be set up to
 // translate the |drawn_center_point| to the origin, scale, and then translate
 // to the target point defined by |target_center_x| and |target_center_y|.
 gfx::Transform CalculateCircleTransform(const gfx::Point& drawn_center_point,
                                         float scale,
                                         float target_center_x,
                                         float target_center_y) {
@@ skipping 13 matching lines @@
   gfx::Transform transform;
   transform.Scale(x_scale, y_scale);
   transform.Translate(-drawn_center_point.x(), -drawn_center_point.y());
   return transform;
 }
 
 }  // namespace
 
 namespace views {
 
-SquareInkDropAnimation::SquareInkDropAnimation(const gfx::Size& large_size,
-                                               int large_corner_radius,
-                                               const gfx::Size& small_size,
-                                               int small_corner_radius,
-                                               const gfx::Point& center_point,
-                                               SkColor color)
+SquareInkDropRipple::SquareInkDropRipple(const gfx::Size& large_size,
+                                         int large_corner_radius,
+                                         const gfx::Size& small_size,
+                                         int small_corner_radius,
+                                         const gfx::Point& center_point,
+                                         SkColor color)
     : large_size_(large_size),
       large_corner_radius_(large_corner_radius),
       small_size_(small_size),
       small_corner_radius_(small_corner_radius),
       circle_layer_delegate_(new CircleLayerDelegate(
           color,
           std::min(large_size_.width(), large_size_.height()) / 2)),
       rect_layer_delegate_(new RectangleLayerDelegate(color, large_size_)),
       root_layer_(ui::LAYER_NOT_DRAWN) {
-  root_layer_.set_name("SquareInkDropAnimation:ROOT_LAYER");
+  root_layer_.set_name("SquareInkDropRipple:ROOT_LAYER");
 
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     AddPaintLayer(static_cast<PaintedShape>(i));
 
   root_layer_.SetMasksToBounds(false);
   root_layer_.SetBounds(gfx::Rect(large_size_));
 
   gfx::Transform transform;
   transform.Translate(center_point.x(), center_point.y());
   root_layer_.SetTransform(transform);
 
   SetStateToHidden();
 }
 
-SquareInkDropAnimation::~SquareInkDropAnimation() {
+SquareInkDropRipple::~SquareInkDropRipple() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
-void SquareInkDropAnimation::SnapToActivated() {
-  InkDropAnimation::SnapToActivated();
+void SquareInkDropRipple::SnapToActivated() {
+  InkDropRipple::SnapToActivated();
   SetOpacity(kVisibleOpacity);
   InkDropTransforms transforms;
   GetActivatedTargetTransforms(&transforms);
   SetTransforms(transforms);
 }
 
-ui::Layer* SquareInkDropAnimation::GetRootLayer() {
+ui::Layer* SquareInkDropRipple::GetRootLayer() {
   return &root_layer_;
 }
 
-bool SquareInkDropAnimation::IsVisible() const {
+bool SquareInkDropRipple::IsVisible() const {
   return root_layer_.visible();
 }
 
-float SquareInkDropAnimation::GetCurrentOpacity() const {
+float SquareInkDropRipple::GetCurrentOpacity() const {
   return root_layer_.opacity();
 }
 
-std::string SquareInkDropAnimation::ToLayerName(PaintedShape painted_shape) {
+std::string SquareInkDropRipple::ToLayerName(PaintedShape painted_shape) {
   switch (painted_shape) {
     case TOP_LEFT_CIRCLE:
       return "TOP_LEFT_CIRCLE";
     case TOP_RIGHT_CIRCLE:
       return "TOP_RIGHT_CIRCLE";
     case BOTTOM_RIGHT_CIRCLE:
       return "BOTTOM_RIGHT_CIRCLE";
     case BOTTOM_LEFT_CIRCLE:
       return "BOTTOM_LEFT_CIRCLE";
     case HORIZONTAL_RECT:
       return "HORIZONTAL_RECT";
     case VERTICAL_RECT:
       return "VERTICAL_RECT";
     case PAINTED_SHAPE_COUNT:
       NOTREACHED() << "The PAINTED_SHAPE_COUNT value should never be used.";
       return "PAINTED_SHAPE_COUNT";
   }
   return "UNKNOWN";
 }
 
-void SquareInkDropAnimation::AnimateStateChange(
+void SquareInkDropRipple::AnimateStateChange(
     InkDropState old_ink_drop_state,
     InkDropState new_ink_drop_state,
     ui::LayerAnimationObserver* animation_observer) {
   InkDropTransforms transforms;
 
   switch (new_ink_drop_state) {
     case InkDropState::HIDDEN:
       if (!IsVisible()) {
         SetStateToHidden();
         break;
@@ skipping 118 matching lines @@
       CalculateRectTransforms(large_size_, large_corner_radius_, &transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(DEACTIVATED_TRANSFORM),
                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     }
   }
 }
 
-void SquareInkDropAnimation::SetStateToHidden() {
+void SquareInkDropRipple::SetStateToHidden() {
   InkDropTransforms transforms;
   // Use non-zero size to avoid visual anomalies.
   CalculateCircleTransforms(gfx::Size(1, 1), &transforms);
   SetTransforms(transforms);
-  root_layer_.SetOpacity(InkDropAnimation::kHiddenOpacity);
+  root_layer_.SetOpacity(InkDropRipple::kHiddenOpacity);
   root_layer_.SetVisible(false);
 }
 
-void SquareInkDropAnimation::AbortAllAnimations() {
+void SquareInkDropRipple::AbortAllAnimations() {
   root_layer_.GetAnimator()->AbortAllAnimations();
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     painted_layers_[i]->GetAnimator()->AbortAllAnimations();
 }
 
-void SquareInkDropAnimation::AnimateToTransforms(
+void SquareInkDropRipple::AnimateToTransforms(
     const InkDropTransforms transforms,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i) {
     ui::LayerAnimator* animator = painted_layers_[i]->GetAnimator();
     ui::ScopedLayerAnimationSettings animation(animator);
     animation.SetPreemptionStrategy(preemption_strategy);
     animation.SetTweenType(tween);
     ui::LayerAnimationElement* element =
         ui::LayerAnimationElement::CreateTransformElement(transforms[i],
                                                           duration);
     ui::LayerAnimationSequence* sequence =
         new ui::LayerAnimationSequence(element);
 
     if (animation_observer)
       sequence->AddObserver(animation_observer);
 
     animator->StartAnimation(sequence);
   }
 }
 
-void SquareInkDropAnimation::SetTransforms(const InkDropTransforms transforms) {
+void SquareInkDropRipple::SetTransforms(const InkDropTransforms transforms) {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     painted_layers_[i]->SetTransform(transforms[i]);
 }
 
-void SquareInkDropAnimation::SetOpacity(float opacity) {
+void SquareInkDropRipple::SetOpacity(float opacity) {
   root_layer_.SetOpacity(opacity);
 }
 
-void SquareInkDropAnimation::AnimateToOpacity(
+void SquareInkDropRipple::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);
 }
 
-void SquareInkDropAnimation::CalculateCircleTransforms(
+void SquareInkDropRipple::CalculateCircleTransforms(
     const gfx::Size& size,
     InkDropTransforms* transforms_out) const {
   CalculateRectTransforms(size, std::min(size.width(), size.height()) / 2.0f,
                           transforms_out);
 }
 
-void SquareInkDropAnimation::CalculateRectTransforms(
+void SquareInkDropRipple::CalculateRectTransforms(
     const gfx::Size& size,
     float corner_radius,
     InkDropTransforms* transforms_out) const {
   DCHECK_GE(size.width() / 2.0f, corner_radius)
       << "The circle's diameter should not be greater than the total width.";
   DCHECK_GE(size.height() / 2.0f, corner_radius)
       << "The circle's diameter should not be greater than the total height.";
 
   // The shapes are drawn such that their center points are not at the origin.
   // Thus we use the CalculateCircleTransform() and CalculateRectTransform()
@@ skipping 33 matching lines @@
       std::max(kMinimumRectScale,
                (size.height() - 2.0f * corner_radius) / rect_delegate_height));
 
   (*transforms_out)[VERTICAL_RECT] = CalculateRectTransform(
       ToRoundedPoint(rect_layer_delegate_->GetCenterPoint()),
       std::max(kMinimumRectScale,
                (size.width() - 2.0f * corner_radius) / rect_delegate_width),
       std::max(kMinimumRectScale, size.height() / rect_delegate_height));
 }
 
-void SquareInkDropAnimation::GetCurrentTransforms(
+void SquareInkDropRipple::GetCurrentTransforms(
     InkDropTransforms* transforms_out) const {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     (*transforms_out)[i] = painted_layers_[i]->transform();
 }
 
-void SquareInkDropAnimation::GetActivatedTargetTransforms(
+void SquareInkDropRipple::GetActivatedTargetTransforms(
     InkDropTransforms* transforms_out) const {
   CalculateRectTransforms(small_size_, small_corner_radius_, transforms_out);
 }
 
-void SquareInkDropAnimation::AddPaintLayer(PaintedShape painted_shape) {
+void SquareInkDropRipple::AddPaintLayer(PaintedShape painted_shape) {
   ui::LayerDelegate* delegate = nullptr;
   switch (painted_shape) {
     case TOP_LEFT_CIRCLE:
     case TOP_RIGHT_CIRCLE:
     case BOTTOM_RIGHT_CIRCLE:
     case BOTTOM_LEFT_CIRCLE:
       delegate = circle_layer_delegate_.get();
       break;
     case HORIZONTAL_RECT:
     case VERTICAL_RECT:
@@ skipping 12 matching lines @@
   layer->set_delegate(delegate);
   layer->SetVisible(true);
   layer->SetOpacity(1.0);
   layer->SetMasksToBounds(false);
   layer->set_name("PAINTED_SHAPE_COUNT:" + ToLayerName(painted_shape));
 
   painted_layers_[painted_shape].reset(layer);
 }
 
 }  // namespace views