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

ui/views/animation/ink_drop_animation_controller_impl.cc

 // Copyright 2015 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/ink_drop_animation_controller_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/timer/timer.h"
 #include "ui/compositor/layer.h"
 #include "ui/views/animation/ink_drop_host.h"
@@ skipping 63 matching lines @@
     return InkDropState::HIDDEN;
   return ink_drop_animation_->ink_drop_state();
 }
 
 bool InkDropAnimationControllerImpl::IsVisible() const {
   return ink_drop_animation_ && ink_drop_animation_->IsVisible();
 }
 
 void InkDropAnimationControllerImpl::AnimateToState(
     InkDropState ink_drop_state) {
-  if (!ink_drop_animation_)
-    CreateInkDropAnimation();
+  EnsureInkDropAnimation();
 
   // The InkDropAnimationObserver::InkDropAnimationEnded() callback needs to
   // know if it is safe to destroy the |ink_drop_animation_| and it is not safe
   // when the notification is raised within a call to
   // InkDropAnimation::AnimateToState().
   base::AutoReset<bool> auto_reset_can_destroy_after_hidden_animation(
       &can_destroy_after_hidden_animation_, false);
 
   if (ink_drop_state != views::InkDropState::HIDDEN) {
     SetHoveredInternal(false, base::TimeDelta::FromMilliseconds(
@@ skipping 14 matching lines @@
                      is_hovered ? base::TimeDelta::FromMilliseconds(
                                       kHoverFadeInFromUserInputDurationInMs)
                                 : base::TimeDelta::FromMilliseconds(
                                       kHoverFadeOutFromUserInputDurationInMs));
 }
 
 bool InkDropAnimationControllerImpl::IsHovered() const {
   return hover_ && hover_->IsVisible();
 }
 
-gfx::Size InkDropAnimationControllerImpl::GetInkDropLargeSize() const {
-  return ink_drop_large_size_;
-}
-
 void InkDropAnimationControllerImpl::SetInkDropSize(const gfx::Size& large_size,
                                                     int large_corner_radius,
                                                     const gfx::Size& small_size,
                                                     int small_corner_radius) {
+  CHECK(!ink_drop_animation_);
+  CHECK(!hover_);

[sadrul, 2016/02/10 23:26:49]

D versions?

[Evan Stade, 2016/02/11 00:13:25]

ah yes, thanks, meant to DCHECK. CHECK was just for added coverage during
development.

+
   // TODO(bruthig): Fix the ink drop animations to work for non-square sizes.
   DCHECK_EQ(large_size.width(), large_size.height())
       << "The ink drop animation does not currently support non-square sizes.";
   DCHECK_EQ(small_size.width(), small_size.height())
       << "The ink drop animation does not currently support non-square sizes.";
   ink_drop_large_size_ = large_size;
   ink_drop_large_corner_radius_ = large_corner_radius;
   ink_drop_small_size_ = small_size;
   ink_drop_small_corner_radius_ = small_corner_radius;
-
-  DestroyInkDropAnimation();
-  DestroyInkDropHover();
 }
 
 void InkDropAnimationControllerImpl::SetInkDropCenter(
     const gfx::Point& center_point) {
   ink_drop_center_ = center_point;
   if (ink_drop_animation_)
     ink_drop_animation_->SetCenterPoint(ink_drop_center_);
   if (hover_)
     hover_->SetCenterPoint(ink_drop_center_);
 }
 
-void InkDropAnimationControllerImpl::CreateInkDropAnimation() {
+void InkDropAnimationControllerImpl::EnsureInkDropAnimation() {
+  SkColor color = ink_drop_host_->GetInkDropBaseColor();
+  if (ink_drop_animation_ && ink_drop_animation_->GetColor() == color)
+    return;
+
   DestroyInkDropAnimation();
 
   ink_drop_animation_.reset(new SquareInkDropAnimation(
-      ink_drop_large_size_, ink_drop_large_corner_radius_, ink_drop_small_size_,
-      ink_drop_small_corner_radius_));
+      color, ink_drop_large_size_, ink_drop_large_corner_radius_,
+      ink_drop_small_size_, ink_drop_small_corner_radius_));
 
   ink_drop_animation_->AddObserver(this);
   ink_drop_animation_->SetCenterPoint(ink_drop_center_);
   root_layer_->Add(ink_drop_animation_->root_layer());
 }
 
 void InkDropAnimationControllerImpl::DestroyInkDropAnimation() {
   if (!ink_drop_animation_)
     return;
   root_layer_->Remove(ink_drop_animation_->root_layer());
   ink_drop_animation_->RemoveObserver(this);
   ink_drop_animation_.reset();
 }
 
-void InkDropAnimationControllerImpl::CreateInkDropHover() {
+void InkDropAnimationControllerImpl::EnsureInkDropHover() {
+  SkColor color = ink_drop_host_->GetInkDropBaseColor();
+  if (hover_ && hover_->GetColor() == color)
+    return;
+
   DestroyInkDropHover();
 
-  hover_.reset(
-      new InkDropHover(ink_drop_small_size_, ink_drop_small_corner_radius_));
+  hover_.reset(new InkDropHover(ink_drop_host_->GetInkDropBaseColor(),
+                                ink_drop_small_size_,
+                                ink_drop_small_corner_radius_));
   hover_->SetCenterPoint(ink_drop_center_);
   root_layer_->Add(hover_->layer());
 }
 
 void InkDropAnimationControllerImpl::DestroyInkDropHover() {
   if (!hover_)
     return;
   root_layer_->Remove(hover_->layer());
   hover_.reset();
 }
@@ skipping 26 matching lines @@
 
 void InkDropAnimationControllerImpl::SetHoveredInternal(
     bool is_hovered,
     base::TimeDelta animation_duration) {
   StopHoverAfterAnimationTimer();
 
   if (IsHovered() == is_hovered)
     return;
 
   if (is_hovered) {
-    if (!hover_)
-      CreateInkDropHover();
-    if (!IsVisible()) {
+    EnsureInkDropHover();
+    if (!IsVisible())
       hover_->FadeIn(animation_duration);
-    }
   } else {
     hover_->FadeOut(animation_duration);
   }
 }
 
 void InkDropAnimationControllerImpl::StartHoverAfterAnimationTimer() {
   StopHoverAfterAnimationTimer();
 
   if (!hover_after_animation_timer_)
     hover_after_animation_timer_.reset(new base::OneShotTimer);
@@ skipping 11 matching lines @@
 }
 
 void InkDropAnimationControllerImpl::HoverAfterAnimationTimerFired() {
   SetHoveredInternal(ink_drop_host_->ShouldShowInkDropHover(),
                      base::TimeDelta::FromMilliseconds(
                          kHoverFadeInAfterAnimationDurationInMs));
   hover_after_animation_timer_.reset();
 }
 
 }  // namespace views