Improve toolbar button ink drop ripples at 1.25x

ui/views/animation/square_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/square_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/animation/ink_drop_painted_layer_delegates.h"
 #include "ui/views/view.h"
 
+namespace views {
+
 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;
 
@@ skipping 89 matching lines @@
     200,  // ALTERNATE_ACTION_TRIGGERED_TRANSFORM
     200,  // ACTIVATED_CIRCLE_TRANSFORM
     160,  // ACTIVATED_RECT_TRANSFORM
     150,  // DEACTIVATED_FADE_OUT
     200,  // DEACTIVATED_TRANSFORM
 };
 
 // Returns the InkDropState sub animation duration for the given |state|.
 base::TimeDelta GetAnimationDuration(InkDropSubAnimations state) {
   return base::TimeDelta::FromMilliseconds(
-      (views::InkDropRipple::UseFastAnimations()
+      (InkDropRipple::UseFastAnimations()
            ? 1
-           : views::InkDropRipple::kSlowAnimationDurationFactor) *
+           : InkDropRipple::kSlowAnimationDurationFactor) *
       kAnimationDurationInMs[state]);
 }
 
-// Calculates a Transform for a circle layer. The transform will be set up to
-// translate by -|center_offset|, scale, and then translate to the target point
-// defined by |target_center_x| and |target_center_y|.
-gfx::Transform CalculateCircleTransform(const gfx::Vector2dF& center_offset,
-                                        float scale,
-                                        float target_center_x,
-                                        float target_center_y) {
-  gfx::Transform transform;
-  transform.Translate(target_center_x, target_center_y);
-  transform.Scale(scale, scale);
-  transform.Translate(-center_offset.x(), -center_offset.y());
-  return transform;
-}
-
-// Calculates a Transform for a rectangle layer. The transform will be set up to
-// translate by -|center_offset| and then scale by the |x_scale| and |y_scale|
-// factors.
-gfx::Transform CalculateRectTransform(const gfx::Vector2dF& center_offset,
-                                      float x_scale,
-                                      float y_scale) {
-  gfx::Transform transform;
-  transform.Scale(x_scale, y_scale);
-  transform.Translate(-center_offset.x(), -center_offset.y());
-  return transform;
-}
-
 }  // namespace
 
-namespace views {
-
 SquareInkDropRipple::SquareInkDropRipple(const gfx::Size& large_size,
                                          int large_corner_radius,
                                          const gfx::Size& small_size,
                                          int small_corner_radius,
                                          const gfx::Point& center_point,
                                          SkColor color,
                                          float visible_opacity)
     : activated_shape_(ROUNDED_RECT),
       visible_opacity_(visible_opacity),
       large_size_(large_size),
       large_corner_radius_(large_corner_radius),
       small_size_(small_size),
       small_corner_radius_(small_corner_radius),
+      center_point_(center_point),
       circle_layer_delegate_(new CircleLayerDelegate(
           color,
           std::min(large_size_.width(), large_size_.height()) / 2)),
       rect_layer_delegate_(
           new RectangleLayerDelegate(color, gfx::SizeF(large_size_))),
       root_layer_(ui::LAYER_NOT_DRAWN) {
   root_layer_.set_name("SquareInkDropRipple: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();
 }
 
 SquareInkDropRipple::~SquareInkDropRipple() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
 void SquareInkDropRipple::SnapToActivated() {
@@ skipping 51 matching lines @@
         CalculateCircleTransforms(small_size_, &transforms);
         AnimateToTransforms(
             transforms, GetAnimationDuration(HIDDEN_TRANSFORM),
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
             gfx::Tween::EASE_IN_OUT, animation_observer);
       }
       break;
     case InkDropState::ACTION_PENDING:
       DCHECK_EQ(InkDropState::HIDDEN, old_ink_drop_state)
           << " old_ink_drop_state=" << ToString(old_ink_drop_state);
-      ;
       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),
                        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
                        gfx::Tween::EASE_IN, animation_observer);
       CalculateCircleTransforms(large_size_, &transforms);
       AnimateToTransforms(transforms,
@@ skipping 174 matching lines @@
 }
 
 void SquareInkDropRipple::CalculateCircleTransforms(
     const gfx::Size& size,
     InkDropTransforms* transforms_out) const {
   CalculateRectTransforms(size, std::min(size.width(), size.height()) / 2.0f,
                           transforms_out);
 }
 
 void SquareInkDropRipple::CalculateRectTransforms(
-    const gfx::Size& size,
+    const gfx::Size& desired_size,
     float corner_radius,
     InkDropTransforms* transforms_out) const {
-  DCHECK_GE(size.width() / 2.0f, corner_radius)
+  DCHECK_GE(desired_size.width() / 2.0f, corner_radius)
       << "The circle's diameter should not be greater than the total width.";
-  DCHECK_GE(size.height() / 2.0f, corner_radius)
+  DCHECK_GE(desired_size.height() / 2.0f, corner_radius)
       << "The circle's diameter should not be greater than the total height.";
 
+  gfx::SizeF size(desired_size);

[bruthig, 2017/04/12 17:57:39]

nit: Consider renaming as |effective_size|.

[Evan Stade, 2017/04/12 23:48:28]

it's used so often below I wanted to keep it shortish

+  // This function can be called before the layer's been added to a view,
+  // either at construction time or in tests.
+  if (root_layer_.GetCompositor()) {
+    // Modify |desired_size| so that the ripple aligns to pixel bounds.
+    const float dsf = root_layer_.GetCompositor()->device_scale_factor();
+    gfx::RectF ripple_bounds((gfx::PointF(center_point_)), gfx::SizeF());

[bruthig, 2017/04/12 17:57:39]

I'm assuming the 'extra' parenthesis are required...?

[Evan Stade, 2017/04/12 23:48:28]

yes. disambiguates a function call or some such.

+    ripple_bounds.Inset(-gfx::InsetsF(desired_size.height() / 2.0f,
+                                      desired_size.width() / 2.0f));
+    ripple_bounds.Scale(dsf);
+    ripple_bounds = gfx::RectF(gfx::ToEnclosingRect(ripple_bounds));
+    ripple_bounds.Scale(1.0f / dsf);
+    size = ripple_bounds.size();
+  }
+
   // The shapes are drawn such that their center points are not at the origin.
   // Thus we use the CalculateCircleTransform() and CalculateRectTransform()
   // methods to calculate the complex Transforms.
 
   const float circle_scale = std::max(
       kMinimumCircleScale,
       corner_radius / static_cast<float>(circle_layer_delegate_->radius()));
 
   const float circle_target_x_offset = size.width() / 2.0f - corner_radius;
   const float circle_target_y_offset = size.height() / 2.0f - corner_radius;
 
-  const gfx::Vector2dF circle_center_offset =
-      circle_layer_delegate_->GetCenteringOffset();
   (*transforms_out)[TOP_LEFT_CIRCLE] = CalculateCircleTransform(
-      circle_center_offset, circle_scale, -circle_target_x_offset,
-      -circle_target_y_offset);
+      circle_scale, -circle_target_x_offset, -circle_target_y_offset);
+  (*transforms_out)[TOP_RIGHT_CIRCLE] = CalculateCircleTransform(
+      circle_scale, circle_target_x_offset, -circle_target_y_offset);
+  (*transforms_out)[BOTTOM_RIGHT_CIRCLE] = CalculateCircleTransform(
+      circle_scale, circle_target_x_offset, circle_target_y_offset);
+  (*transforms_out)[BOTTOM_LEFT_CIRCLE] = CalculateCircleTransform(
+      circle_scale, -circle_target_x_offset, circle_target_y_offset);
 
-  (*transforms_out)[TOP_RIGHT_CIRCLE] =
-      CalculateCircleTransform(circle_center_offset, circle_scale,
-                               circle_target_x_offset, -circle_target_y_offset);
+  const float rect_delegate_width = rect_layer_delegate_->size().width();
+  const float rect_delegate_height = rect_layer_delegate_->size().height();
 
-  (*transforms_out)[BOTTOM_RIGHT_CIRCLE] =
-      CalculateCircleTransform(circle_center_offset, circle_scale,
-                               circle_target_x_offset, circle_target_y_offset);
-
-  (*transforms_out)[BOTTOM_LEFT_CIRCLE] =
-      CalculateCircleTransform(circle_center_offset, circle_scale,
-                               -circle_target_x_offset, circle_target_y_offset);
-
-  const float rect_delegate_width =
-      static_cast<float>(rect_layer_delegate_->size().width());
-  const float rect_delegate_height =
-      static_cast<float>(rect_layer_delegate_->size().height());
-
-  const gfx::Vector2dF rect_center_offset =
-      rect_layer_delegate_->GetCenteringOffset();
   (*transforms_out)[HORIZONTAL_RECT] = CalculateRectTransform(
-      rect_center_offset,
       std::max(kMinimumRectScale, size.width() / rect_delegate_width),
       std::max(kMinimumRectScale,
                (size.height() - 2.0f * corner_radius) / rect_delegate_height));
 
   (*transforms_out)[VERTICAL_RECT] = CalculateRectTransform(
-      rect_center_offset,
       std::max(kMinimumRectScale,
                (size.width() - 2.0f * corner_radius) / rect_delegate_width),
       std::max(kMinimumRectScale, size.height() / rect_delegate_height));
 }
 
+gfx::Transform SquareInkDropRipple::CalculateCircleTransform(
+    float scale,
+    float target_center_x,
+    float target_center_y) const {
+  gfx::Transform transform;
+  // Offset for the center point of the ripple.
+  transform.Translate(center_point_.x(), center_point_.y());
+  // Move circle to target.
+  transform.Translate(target_center_x, target_center_y);
+  transform.Scale(scale, scale);
+  // Align center point of the painted circle.
+  const gfx::Vector2dF circle_center_offset =
+      circle_layer_delegate_->GetCenteringOffset();
+  transform.Translate(-circle_center_offset.x(), -circle_center_offset.y());
+  return transform;
+}
+
+gfx::Transform SquareInkDropRipple::CalculateRectTransform(
+    float x_scale,
+    float y_scale) const {
+  gfx::Transform transform;
+  transform.Translate(center_point_.x(), center_point_.y());
+  transform.Scale(x_scale, y_scale);
+  const gfx::Vector2dF rect_center_offset =
+      rect_layer_delegate_->GetCenteringOffset();
+  transform.Translate(-rect_center_offset.x(), -rect_center_offset.y());
+  return transform;
+}
+
 void SquareInkDropRipple::GetCurrentTransforms(
     InkDropTransforms* transforms_out) const {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     (*transforms_out)[i] = painted_layers_[i]->transform();
 }
 
 void SquareInkDropRipple::GetActivatedTargetTransforms(
     InkDropTransforms* transforms_out) const {
   switch (activated_shape_) {
     case CIRCLE:
@@ skipping 45 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