Added ink drop hover/ripple to menu hosting bookmark buttons.

ui/views/animation/square_ink_drop_animation.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 <algorithm>
 
 #include "base/logging.h"
 #include "ui/compositor/layer.h"
@@ skipping 177 matching lines @@
 
   SetStateToHidden();
 }
 
 SquareInkDropAnimation::~SquareInkDropAnimation() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
+void SquareInkDropAnimation::SnapToActivated() {
+  InkDropAnimation::SnapToActivated();
+  SetOpacity(kVisibleOpacity);
+  InkDropTransforms transforms;
+  GetActivatedTargetTransforms(&transforms);
+  SetTransforms(transforms);
+}
+
 ui::Layer* SquareInkDropAnimation::GetRootLayer() {
   return &root_layer_;
 }
 
 bool SquareInkDropAnimation::IsVisible() const {
   return root_layer_.visible();
 }
 
 float SquareInkDropAnimation::GetCurrentOpacity() const {
   return root_layer_.opacity();
@@ skipping 54 matching lines @@
                        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);
       break;
     case InkDropState::QUICK_ACTION: {
       DCHECK(old_ink_drop_state == InkDropState::HIDDEN ||
              old_ink_drop_state == InkDropState::ACTION_PENDING);
+      if (old_ink_drop_state == InkDropState::HIDDEN) {
+        AnimateStateChange(old_ink_drop_state, InkDropState::ACTION_PENDING,
+                           animation_observer);
+      }
       AnimateToOpacity(kHiddenOpacity,
                        GetAnimationDuration(QUICK_ACTION_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(QUICK_ACTION_TRANSFORM),
                           ui::LayerAnimator::ENQUEUE_NEW_ANIMATION,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
@@ skipping 44 matching lines @@
         CalculateCircleTransforms(large_size_, &transforms);
         AnimateToTransforms(
             transforms, GetAnimationDuration(ACTIVATED_CIRCLE_TRANSFORM),
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
             gfx::Tween::EASE_IN_OUT, animation_observer);
       } else if (old_ink_drop_state == InkDropState::ACTION_PENDING) {
         rect_transform_preemption_strategy =
             ui::LayerAnimator::ENQUEUE_NEW_ANIMATION;
       }
 
-      CalculateRectTransforms(small_size_, small_corner_radius_, &transforms);
+      GetActivatedTargetTransforms(&transforms);
       AnimateToTransforms(transforms,
                           GetAnimationDuration(ACTIVATED_RECT_TRANSFORM),
                           rect_transform_preemption_strategy,
                           gfx::Tween::EASE_IN_OUT, animation_observer);
       break;
     }
     case InkDropState::DEACTIVATED: {
       base::TimeDelta visible_duration =
           GetAnimationDuration(DEACTIVATED_TRANSFORM) -
           GetAnimationDuration(DEACTIVATED_FADE_OUT);
@@ skipping 144 matching lines @@
                (size.width() - 2.0f * corner_radius) / rect_delegate_width),
       std::max(kMinimumRectScale, size.height() / rect_delegate_height));
 }
 
 void SquareInkDropAnimation::GetCurrentTransforms(
     InkDropTransforms* transforms_out) const {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     (*transforms_out)[i] = painted_layers_[i]->transform();
 }
 
+void SquareInkDropAnimation::GetActivatedTargetTransforms(
+    InkDropTransforms* transforms_out) const {
+  CalculateRectTransforms(small_size_, small_corner_radius_, transforms_out);
+}
+
 void SquareInkDropAnimation::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:
@@ skipping 13 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