Make updates to InkDropHighlight to pave the way for improved ink drops

ui/views/animation/ink_drop_highlight.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_highlight.h"
 
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/callback_layer_animation_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
@@ skipping 25 matching lines @@
 
 InkDropHighlight::InkDropHighlight(
     const gfx::PointF& center_point,
     std::unique_ptr<BasePaintedLayerDelegate> layer_delegate)
     : center_point_(center_point),
       visible_opacity_(1.f),
       last_animation_initiated_was_fade_in_(false),
       layer_delegate_(std::move(layer_delegate)),
       layer_(new ui::Layer()),
       observer_(nullptr) {
-  const gfx::Rect layer_bounds = layer_delegate_->GetPaintedBounds();
-  size_ = explode_size_ = layer_bounds.size();
+  const gfx::RectF painted_bounds = layer_delegate_->GetPaintedBounds();
+  size_ = explode_size_ = painted_bounds.size();
 
-  layer_->SetBounds(layer_bounds);
+  layer_->SetBounds(gfx::ToEnclosingRect(painted_bounds));
   layer_->SetFillsBoundsOpaquely(false);
   layer_->set_delegate(layer_delegate_.get());
   layer_->SetVisible(false);
   layer_->SetMasksToBounds(false);
   layer_->set_name("InkDropHighlight:layer");
 }
 
-InkDropHighlight::InkDropHighlight(const gfx::Size& size,
+InkDropHighlight::InkDropHighlight(const gfx::SizeF& size,
                                    int corner_radius,
                                    const gfx::PointF& center_point,
                                    SkColor color)
     : InkDropHighlight(
           center_point,
           std::unique_ptr<BasePaintedLayerDelegate>(
               new RoundedRectangleLayerDelegate(color, size, corner_radius))) {
   visible_opacity_ = 0.128f;
   layer_->SetOpacity(visible_opacity_);
 }
 
+InkDropHighlight::InkDropHighlight(const gfx::Size& size,
+                                   int corner_radius,
+                                   const gfx::PointF& center_point,
+                                   SkColor color)
+    : InkDropHighlight(gfx::SizeF(size), corner_radius, center_point, color) {}
+
 InkDropHighlight::~InkDropHighlight() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   layer_->GetAnimator()->AbortAllAnimations();
 }
 
 bool InkDropHighlight::IsFadingInOrVisible() const {
   return last_animation_initiated_was_fade_in_;
 }
 
 void InkDropHighlight::FadeIn(const base::TimeDelta& duration) {
   layer_->SetOpacity(kHiddenOpacity);
   layer_->SetVisible(true);
   AnimateFade(FADE_IN, duration, size_, size_);
 }
 
 void InkDropHighlight::FadeOut(const base::TimeDelta& duration, bool explode) {
   AnimateFade(FADE_OUT, duration, size_, explode ? explode_size_ : size_);
 }
 
 test::InkDropHighlightTestApi* InkDropHighlight::GetTestApi() {
   return nullptr;
 }
 
 void InkDropHighlight::AnimateFade(AnimationType animation_type,
                                    const base::TimeDelta& duration,
-                                   const gfx::Size& initial_size,
-                                   const gfx::Size& target_size) {
+                                   const gfx::SizeF& initial_size,
+                                   const gfx::SizeF& target_size) {
   last_animation_initiated_was_fade_in_ = animation_type == FADE_IN;
 
   layer_->SetTransform(CalculateTransform(initial_size));
 
   // The |animation_observer| will be destroyed when the
   // AnimationStartedCallback() returns true.
   ui::CallbackLayerAnimationObserver* animation_observer =
       new ui::CallbackLayerAnimationObserver(
           base::Bind(&InkDropHighlight::AnimationStartedCallback,
                      base::Unretained(this), animation_type),
@@ skipping 24 matching lines @@
         new ui::LayerAnimationSequence(std::move(transform_element));
 
     transform_sequence->AddObserver(animation_observer);
     animator->StartAnimation(transform_sequence);
   }
 
   animation_observer->SetActive();
 }
 
 gfx::Transform InkDropHighlight::CalculateTransform(
-    const gfx::Size& size) const {
+    const gfx::SizeF& size) const {
   gfx::Transform transform;
   transform.Translate(center_point_.x(), center_point_.y());
   // TODO(bruthig): Fix the InkDropHighlight to work well when initialized with
   // a (0x0) size. See https://crbug.com/661618.
   transform.Scale(size_.width() == 0 ? 0 : size.width() / size_.width(),
                   size_.height() == 0 ? 0 : size.height() / size_.height());
   gfx::Vector2dF layer_offset = layer_delegate_->GetCenteringOffset();
   transform.Translate(-layer_offset.x(), -layer_offset.y());
   return transform;
 }
@@ skipping 16 matching lines @@
   if (observer_) {
     observer_->AnimationEnded(animation_type,
                               observer.aborted_count()
                                   ? InkDropAnimationEndedReason::PRE_EMPTED
                                   : InkDropAnimationEndedReason::SUCCESS);
   }
   return true;
 }
 
 }  // namespace views