Remove SquareInkDropRipple::AnimateToCenterPoint

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_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/compositor/layer.h"
@@ skipping 152 matching lines @@
 
 namespace views {
 
 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,
                                          float visible_opacity)
-    : SquareInkDropRipple(large_size,
-                          large_corner_radius,
-                          small_size,
-                          small_corner_radius,
-                          center_point,
-                          center_point,
-                          color,
-                          visible_opacity) {}
-
-SquareInkDropRipple::SquareInkDropRipple(const gfx::Size& large_size,
-                                         int large_corner_radius,
-                                         const gfx::Size& small_size,
-                                         int small_corner_radius,
-                                         const gfx::Point& initial_center_point,
-                                         const gfx::Point& target_center_point,
-                                         SkColor color,
-                                         float visible_opacity)
     : activated_shape_(ROUNDED_RECT),
       visible_opacity_(visible_opacity),
-      target_center_point_(target_center_point),
       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, gfx::SizeF(large_size_))),
       root_layer_(ui::LAYER_NOT_DRAWN) {
   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(initial_center_point.x(), initial_center_point.y());
+  transform.Translate(center_point.x(), center_point.y());
   root_layer_.SetTransform(transform);
 
   SetStateToHidden();
 }
 
 SquareInkDropRipple::~SquareInkDropRipple() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
@@ skipping 67 matching lines @@
                        gfx::Tween::EASE_IN, animation_observer);
       AnimateToOpacity(visible_opacity_,
                        GetAnimationDuration(ACTION_PENDING_TRANSFORM),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
       CalculateCircleTransforms(large_size_, &transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(ACTION_PENDING_TRANSFORM),
                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(target_center_point_,
-                         GetAnimationDuration(ACTION_PENDING_TRANSFORM),
-                         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                         gfx::Tween::EASE_IN, animation_observer);
       break;
     case InkDropState::ACTION_TRIGGERED: {
       DCHECK(old_ink_drop_state == InkDropState::HIDDEN ||
              old_ink_drop_state == InkDropState::ACTION_PENDING)
           << " old_ink_drop_state=" << ToString(old_ink_drop_state);
       if (old_ink_drop_state == InkDropState::HIDDEN) {
         AnimateStateChange(old_ink_drop_state, InkDropState::ACTION_PENDING,
                            animation_observer);
       }
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(ACTION_TRIGGERED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       gfx::Size s = ScaleToRoundedSize(large_size_, kQuickActionBurstScale);
       CalculateCircleTransforms(s, &transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(ACTION_TRIGGERED_TRANSFORM),
                           ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(target_center_point_,
-                         GetAnimationDuration(ACTION_TRIGGERED_TRANSFORM),
-                         ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
-                         gfx::Tween::EASE_IN, animation_observer);
       break;
     }
     case InkDropState::ALTERNATE_ACTION_PENDING:
       DCHECK_EQ(InkDropState::ACTION_PENDING, old_ink_drop_state)
           << " old_ink_drop_state=" << ToString(old_ink_drop_state);
       AnimateToOpacity(visible_opacity_,
                        GetAnimationDuration(ALTERNATE_ACTION_PENDING),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
       CalculateRectTransforms(small_size_, small_corner_radius_, &transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(ALTERNATE_ACTION_PENDING),
                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(target_center_point_,
-                         GetAnimationDuration(ALTERNATE_ACTION_PENDING),
-                         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                         gfx::Tween::EASE_IN, animation_observer);
       break;
     case InkDropState::ALTERNATE_ACTION_TRIGGERED: {
       DCHECK_EQ(InkDropState::ALTERNATE_ACTION_PENDING, old_ink_drop_state)
           << " old_ink_drop_state=" << ToString(old_ink_drop_state);
       base::TimeDelta visible_duration =
           GetAnimationDuration(ALTERNATE_ACTION_TRIGGERED_TRANSFORM) -
           GetAnimationDuration(ALTERNATE_ACTION_TRIGGERED_FADE_OUT);
       AnimateToOpacity(visible_opacity_, visible_duration,
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       AnimateToOpacity(kHiddenOpacity, GetAnimationDuration(
                                            ALTERNATE_ACTION_TRIGGERED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       CalculateRectTransforms(large_size_, large_corner_radius_, &transforms);
       AnimateToTransforms(transforms, GetAnimationDuration(
                                           ALTERNATE_ACTION_TRIGGERED_TRANSFORM),
                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(
-          target_center_point_,
-          GetAnimationDuration(ALTERNATE_ACTION_TRIGGERED_TRANSFORM),
-          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-          gfx::Tween::EASE_IN, animation_observer);
       break;
     }
     case InkDropState::ACTIVATED: {
       // Animate the opacity so that it cancels any opacity animations already
       // in progress.
       AnimateToOpacity(visible_opacity_, base::TimeDelta(),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
 
       ui::LayerAnimator::PreemptionStrategy rect_transform_preemption_strategy =
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET;
       if (old_ink_drop_state == InkDropState::HIDDEN) {
         rect_transform_preemption_strategy =
             ui::LayerAnimator::ENQUEUE_NEW_ANIMATION;
         CalculateCircleTransforms(large_size_, &transforms);
         AnimateToTransforms(
             transforms, GetAnimationDuration(ACTIVATED_CIRCLE_TRANSFORM),
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
             gfx::Tween::EASE_IN_OUT, animation_observer);
-        AnimateCenterPoint(target_center_point_,
-                           GetAnimationDuration(ACTIVATED_CIRCLE_TRANSFORM),
-                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                           gfx::Tween::EASE_IN, animation_observer);
       } else if (old_ink_drop_state == InkDropState::ACTION_PENDING) {
         rect_transform_preemption_strategy =
             ui::LayerAnimator::ENQUEUE_NEW_ANIMATION;
       }
 
       GetActivatedTargetTransforms(&transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(ACTIVATED_RECT_TRANSFORM),
                           rect_transform_preemption_strategy,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(target_center_point_,
-                         GetAnimationDuration(ACTIVATED_RECT_TRANSFORM),
-                         rect_transform_preemption_strategy,
-                         gfx::Tween::EASE_IN, animation_observer);
       break;
     }
     case InkDropState::DEACTIVATED: {
       base::TimeDelta visible_duration =
           GetAnimationDuration(DEACTIVATED_TRANSFORM) -
           GetAnimationDuration(DEACTIVATED_FADE_OUT);
       AnimateToOpacity(visible_opacity_, visible_duration,
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(DEACTIVATED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       GetDeactivatedTargetTransforms(&transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(DEACTIVATED_TRANSFORM),
                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
-      AnimateCenterPoint(target_center_point_,
-                         GetAnimationDuration(DEACTIVATED_TRANSFORM),
-                         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                         gfx::Tween::EASE_IN, animation_observer);
       break;
     }
   }
 }
 
 void SquareInkDropRipple::SetStateToHidden() {
   InkDropTransforms transforms;
   // Use non-zero size to avoid visual anomalies.
   CalculateCircleTransforms(gfx::Size(1, 1), &transforms);
   SetTransforms(transforms);
   root_layer_.SetOpacity(InkDropRipple::kHiddenOpacity);
   root_layer_.SetVisible(false);
 }
 
 void SquareInkDropRipple::AbortAllAnimations() {
   root_layer_.GetAnimator()->AbortAllAnimations();
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     painted_layers_[i]->GetAnimator()->AbortAllAnimations();
 }
 
-void SquareInkDropRipple::AnimateCenterPoint(
-    const gfx::Point& center_point,
-    base::TimeDelta duration,
-    ui::LayerAnimator::PreemptionStrategy preemption_strategy,
-    gfx::Tween::Type tween,
-    ui::LayerAnimationObserver* observer) {
-  ui::LayerAnimator* animator = root_layer_.GetAnimator();
-  ui::ScopedLayerAnimationSettings animation(animator);
-  animation.SetPreemptionStrategy(preemption_strategy);
-  animation.SetTweenType(tween);
-  gfx::Transform transform;
-  transform.Translate(target_center_point_.x(), target_center_point_.y());
-  std::unique_ptr<ui::LayerAnimationElement> element =
-      ui::LayerAnimationElement::CreateTransformElement(transform, duration);
-  ui::LayerAnimationSequence* sequence =
-      new ui::LayerAnimationSequence(std::move(element));
-
-  if (observer)
-    sequence->AddObserver(observer);
-
-  animator->StartAnimation(sequence);
-}
-
 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);
@@ skipping 164 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