Fix double ripple on activated flood fill ripple

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_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 197 matching lines @@
                            gfx::Tween::EASE_IN_OUT, animation_observer);
       }
       break;
     case InkDropState::ACTION_PENDING: {
       DCHECK(old_ink_drop_state == InkDropState::HIDDEN);
 
       AnimateToOpacity(visible_opacity_,
                        GetAnimationDuration(ACTION_PENDING_FADE_IN),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
-      AnimateToOpacity(visible_opacity_,
-                       GetAnimationDuration(ACTION_PENDING_TRANSFORM) -
-                           GetAnimationDuration(ACTION_PENDING_FADE_IN),
-                       ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
-                       gfx::Tween::EASE_IN, animation_observer);
+      PauseOpacityAnimation(GetAnimationDuration(ACTION_PENDING_TRANSFORM) -
+                                GetAnimationDuration(ACTION_PENDING_FADE_IN),
+                            ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
+                            animation_observer);
 
       AnimateToTransform(GetMaxSizeTargetTransform(),
                          GetAnimationDuration(ACTION_PENDING_TRANSFORM),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                          gfx::Tween::FAST_OUT_SLOW_IN, animation_observer);
       break;
     }
     case InkDropState::ACTION_TRIGGERED: {
       DCHECK(old_ink_drop_state == InkDropState::HIDDEN ||
              old_ink_drop_state == InkDropState::ACTION_PENDING);
@@ skipping 20 matching lines @@
       break;
     }
     case InkDropState::ALTERNATE_ACTION_TRIGGERED:
       DCHECK(old_ink_drop_state == InkDropState::ALTERNATE_ACTION_PENDING);
       AnimateToOpacity(kHiddenOpacity, GetAnimationDuration(
                                            ALTERNATE_ACTION_TRIGGERED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     case InkDropState::ACTIVATED: {
-      AnimateToOpacity(visible_opacity_,
-                       GetAnimationDuration(ACTIVATED_FADE_IN),
-                       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                       gfx::Tween::EASE_IN, animation_observer);
-      AnimateToTransform(GetMaxSizeTargetTransform(),
-                         GetAnimationDuration(ACTIVATED_TRANSFORM),
+      if (old_ink_drop_state == InkDropState::ACTION_PENDING) {
+        // The final state of pending animation is the same as the final state
+        // of activated animation. We only need to enqueue a zero-length pause
+        // so that animation observers are notified in order.
+        PauseOpacityAnimation(
+            base::TimeDelta(),
+            ui::LayerAnimator::PreemptionStrategy::ENQUEUE_NEW_ANIMATION,
+            animation_observer);
+        PauseTransformAnimation(
+            base::TimeDelta(),
+            ui::LayerAnimator::PreemptionStrategy::ENQUEUE_NEW_ANIMATION,
+            animation_observer);
+      } else {
+        AnimateToOpacity(visible_opacity_,
+                         GetAnimationDuration(ACTIVATED_FADE_IN),
                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
-                         gfx::Tween::EASE_IN_OUT, animation_observer);
+                         gfx::Tween::EASE_IN, animation_observer);
+        AnimateToTransform(GetMaxSizeTargetTransform(),
+                           GetAnimationDuration(ACTIVATED_TRANSFORM),
+                           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
+                           gfx::Tween::EASE_IN_OUT, animation_observer);
+      }
       break;
     }
     case InkDropState::DEACTIVATED:
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(DEACTIVATED_FADE_OUT),
                        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                        gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
   }
 }
@@ skipping 25 matching lines @@
 
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(std::move(element));
 
   if (animation_observer)
     sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(sequence);
 }
 
+void FloodFillInkDropRipple::PauseTransformAnimation(
+    base::TimeDelta duration,
+    ui::LayerAnimator::PreemptionStrategy preemption_strategy,
+    ui::LayerAnimationObserver* observer) {
+  ui::LayerAnimator* animator = painted_layer_.GetAnimator();
+  ui::ScopedLayerAnimationSettings animation(animator);
+  animation.SetPreemptionStrategy(preemption_strategy);
+
+  std::unique_ptr<ui::LayerAnimationElement> element =
+      ui::LayerAnimationElement::CreatePauseElement(
+          ui::LayerAnimationElement::TRANSFORM, duration);
+
+  ui::LayerAnimationSequence* sequence =
+      new ui::LayerAnimationSequence(std::move(element));
+
+  if (observer)
+    sequence->AddObserver(observer);
+
+  animator->StartAnimation(sequence);
+}
+
 void FloodFillInkDropRipple::SetOpacity(float opacity) {
   root_layer_.SetOpacity(opacity);
 }
 
 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);
   std::unique_ptr<ui::LayerAnimationElement> animation_element =
       ui::LayerAnimationElement::CreateOpacityElement(opacity, duration);
   ui::LayerAnimationSequence* animation_sequence =
       new ui::LayerAnimationSequence(std::move(animation_element));
 
   if (animation_observer)
     animation_sequence->AddObserver(animation_observer);
 
   animator->StartAnimation(animation_sequence);
 }
 
+void FloodFillInkDropRipple::PauseOpacityAnimation(
+    base::TimeDelta duration,
+    ui::LayerAnimator::PreemptionStrategy preemption_strategy,
+    ui::LayerAnimationObserver* observer) {
+  ui::LayerAnimator* animator = root_layer_.GetAnimator();
+  ui::ScopedLayerAnimationSettings animation(animator);
+  animation.SetPreemptionStrategy(preemption_strategy);
+
+  std::unique_ptr<ui::LayerAnimationElement> element =
+      ui::LayerAnimationElement::CreatePauseElement(
+          ui::LayerAnimationElement::OPACITY, duration);
+
+  ui::LayerAnimationSequence* sequence =
+      new ui::LayerAnimationSequence(std::move(element));
+
+  if (observer)
+    sequence->AddObserver(observer);
+
+  animator->StartAnimation(sequence);
+}
+
 gfx::Transform FloodFillInkDropRipple::CalculateTransform(
     float target_radius) const {
   const float target_scale = target_radius / circle_layer_delegate_.radius();
 
   gfx::Transform transform = gfx::Transform();
   transform.Translate(center_point_.x() - root_layer_.bounds().x(),
                       center_point_.y() - root_layer_.bounds().y());
   transform.Scale(target_scale, target_scale);
 
   const gfx::Vector2dF drawn_center_offset =
@@ skipping 17 matching lines @@
       (bounds.bottom_right() - point).Length();
 
   float largest_distance =
       std::max(distance_to_top_left, distance_to_top_right);
   largest_distance = std::max(largest_distance, distance_to_bottom_left);
   largest_distance = std::max(largest_distance, distance_to_bottom_right);
   return largest_distance;
 }
 
 }  // namespace views