Color the ink drop ripple and hover effects based on theming.

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/command_line.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 namespace {
 
 // The minimum scale factor to use when scaling rectangle layers. Smaller values
 // were causing visual anomalies.
 const float kMinimumRectScale = 0.0001f;
 
 // The minimum scale factor to use when scaling circle layers. Smaller values
 // were causing visual anomalies.
 const float kMinimumCircleScale = 0.001f;
 
-// The ink drop color.
-const SkColor kInkDropColor = SK_ColorBLACK;
-
 // All the sub animations that are used to animate each of the InkDropStates.
 // These are used to get time durations with
 // GetAnimationDuration(InkDropSubAnimations). Note that in general a sub
 // animation defines the duration for either a transformation animation or an
 // opacity animation but there are some exceptions where an entire InkDropState
 // animation consists of only 1 sub animation and it defines the duration for
 // both the transformation and opacity animations.
 enum InkDropSubAnimations {
   // HIDDEN sub animations.
 
@@ skipping 125 matching lines @@
   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)
+                                               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(
-          kInkDropColor,
+          color,
           std::min(large_size_.width(), large_size_.height()) / 2)),
-      rect_layer_delegate_(
-          new RectangleLayerDelegate(kInkDropColor, large_size_)),
+      rect_layer_delegate_(new RectangleLayerDelegate(color, large_size_)),
       root_layer_(ui::LAYER_NOT_DRAWN),
       ink_drop_state_(InkDropState::HIDDEN) {
   root_layer_.set_name("SquareInkDropAnimation: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() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
 ui::Layer* SquareInkDropAnimation::GetRootLayer() {
@@ skipping 37 matching lines @@
   // the target InkDropState when calling GetInkDropState().
   ink_drop_state_ = ink_drop_state;
 
   if (old_ink_drop_state == InkDropState::HIDDEN &&
       ink_drop_state_ != InkDropState::HIDDEN) {
     root_layer_.SetVisible(true);
   }
 
   AnimateStateChange(old_ink_drop_state, ink_drop_state_, animation_observer);
   animation_observer->SetActive();
-}
-
-void SquareInkDropAnimation::SetCenterPoint(const gfx::Point& center_point) {
-  gfx::Transform transform;
-  transform.Translate(center_point.x(), center_point.y());
-  root_layer_.SetTransform(transform);
+  // |this| may be deleted! |animation_observer| might synchronously call
+  // AnimationEndedCallback which can delete |this|.
 }
 
 void SquareInkDropAnimation::HideImmediately() {
   AbortAllAnimations();
   SetStateToHidden();
   ink_drop_state_ = InkDropState::HIDDEN;
 }
 
 std::string SquareInkDropAnimation::ToLayerName(PaintedShape painted_shape) {
   switch (painted_shape) {
@@ skipping 330 matching lines @@
   if (ink_drop_state == InkDropState::HIDDEN)
     SetStateToHidden();
   NotifyAnimationEnded(ink_drop_state,
                        observer.aborted_count()
                            ? InkDropAnimationObserver::PRE_EMPTED
                            : InkDropAnimationObserver::SUCCESS);
   return true;
 }
 
 }  // namespace views