Implemented prototype for new ink drop specs.

ui/views/animation/ink_drop_animation.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.h"
 
+#include <algorithm>
+
 #include "base/command_line.h"
+#include "base/logging.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/geometry/size.h"
-#include "ui/views/animation/ink_drop_delegate.h"
+#include "ui/gfx/transform_util.h"
 #include "ui/views/view.h"
 
 namespace {
 
-// Animation constants
-const float kMinimumScale = 0.1f;
-const float kMinimumScaleCenteringOffset = 0.5f - kMinimumScale / 2.0f;
+// The minimum scale factor to use when scaling rectangle layers. Smaller values
+// were causing visual anomalies.
+const float kMinimumRectScale = 0.0001f;
 
-const int kHideAnimationDurationFastMs = 100;
-const int kHideAnimationDurationSlowMs = 1000;
+// The minimum scale factor to use when scaling circle layers. Smaller values
+// were causing visual anomalies.
+const float kMinimumCircleScale = 0.001f;
 
-const int kShowInkDropAnimationDurationFastMs = 250;
-const int kShowInkDropAnimationDurationSlowMs = 750;
+// The ink drop color.
+const SkColor kInkDropColor = SK_ColorBLACK;
 
-const int kShowLongPressAnimationDurationFastMs = 250;
-const int kShowLongPressAnimationDurationSlowMs = 2500;
+// The opacity of the ink drop when it is visible.
+const float kVisibleOpacity = 0.12f;
 
-const int kRoundedRectCorners = 5;
-const int kCircleRadius = 30;
+// The opacity of the ink drop when it is not visible.
+const float kHiddenOpacity = 0.0f;
 
-const SkColor kInkDropColor = SK_ColorLTGRAY;
-const SkColor kLongPressColor = SkColorSetRGB(182, 182, 182);
+// Durations for the different InkDropState animations in milliseconds.
+const int kHiddenStateAnimationDurationMs = 1;
+const int kActionPendingStateAnimationDurationMs = 500;
+const int kQuickActionStateAnimationDurationMs = 250;
+const int kSlowActionPendingStateAnimationDurationMs = 500;
+const int kSlowActionStateAnimationDurationMs = 250;
+const int kActivatedStateAnimationDurationMs = 250;
+const int kDeactivatedStateAnimationDurationMs = 250;

[jonross, 2015/08/21 15:14:49]

I think you should still use an array. However have that array be defined in
terms of these constants:

const int kAnimationDurationsMs[static_cast<int>(views::InkDropState::COUNT)] = 

kHiddenStateAnimationDurationMs,
kActionPendingStateAnimationDurationMs,
....
};

Then you can revert the switch on line 66.

However your point on the switch being a compilation check is valid. So I'd be
fine without my suggestion. We can talk when you're back.

[bruthig, 2015/09/03 21:21:04]

Discussed offline, will leave it as-is and see if the OWNERS have any concerns.

 
-// Checks CommandLine switches to determine if the visual feedback should be
-// circular.
-bool UseCircularFeedback() {
-  static bool circular =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          (::switches::kMaterialDesignInkDrop)) !=
-      ::switches::kMaterialDesignInkDropSquare;
-  return circular;
-}
+// A multiplicative factor used to slow down InkDropState animations.
+const int kSlowAnimationDurationFactor = 3;
 
 // Checks CommandLine switches to determine if the visual feedback should have
 // a fast animations speed.
 bool UseFastAnimations() {
   static bool fast =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           (::switches::kMaterialDesignInkDropAnimationSpeed)) !=
       ::switches::kMaterialDesignInkDropAnimationSpeedSlow;
   return fast;
 }
 
+// Returns the InkDropState animation duration for the given |state|.
+base::TimeDelta GetAnimationDuration(views::InkDropState state) {
+  int duration = 0;
+  switch (state) {
+    case views::InkDropState::HIDDEN:
+      duration = kHiddenStateAnimationDurationMs;
+      break;
+    case views::InkDropState::ACTION_PENDING:
+      duration = kActionPendingStateAnimationDurationMs;
+      break;
+    case views::InkDropState::QUICK_ACTION:
+      duration = kQuickActionStateAnimationDurationMs;
+      break;
+    case views::InkDropState::SLOW_ACTION_PENDING:
+      duration = kSlowActionPendingStateAnimationDurationMs;
+      break;
+    case views::InkDropState::SLOW_ACTION:
+      duration = kSlowActionStateAnimationDurationMs;
+      break;
+    case views::InkDropState::ACTIVATED:
+      duration = kActivatedStateAnimationDurationMs;
+      break;
+    case views::InkDropState::DEACTIVATED:
+      duration = kDeactivatedStateAnimationDurationMs;
+      break;
+  }
+
+  return base::TimeDelta::FromMilliseconds(
+      (UseFastAnimations() ? 1 : kSlowAnimationDurationFactor) * duration);
+}
+
 }  // namespace
 
 namespace views {
 
-// An animation observer that should be set on animations of the provided
-// ui::Layer. Can be used to either start a hide animation, or to trigger one
-// upon completion of the current animation.
-//
-// Sequential animations with PreemptionStrategy::ENQUEUE_NEW_ANIMATION cannot
-// be used as the observed animation can complete before user input is received
-// which determines if the hide animation should run.
-class AppearAnimationObserver : public ui::LayerAnimationObserver {
+// Base ui::LayerDelegate stub that can be extended to paint shapes of a
+// specific color.
+class BasePaintedLayerDelegate : public ui::LayerDelegate {
  public:
-  // Will automatically start a hide animation of |layer| if |hide| is true.
-  // Otherwise StartHideAnimation() or HideNowIfDoneOrOnceCompleted() must be
-  // called.
-  AppearAnimationObserver(ui::Layer* layer, bool hide);
-  ~AppearAnimationObserver() override;
-
-  // Returns true during both the appearing animation, and the hiding animation.
-  bool IsAnimationActive();
-
-  // Starts a hide animation, preempting any current animations on |layer_|.
-  void StartHideAnimation();
-
-  // Starts a hide animation if |layer_| is no longer animating. Otherwise the
-  // hide animation will be started once the current animation is completed.
-  void HideNowIfDoneOrOnceCompleted();
-
-  // Hides |background_layer| (without animation) after the current animation
-  // completes.
-  void SetBackgroundToHide(ui::Layer* background_layer);
+  explicit BasePaintedLayerDelegate(SkColor color);
+  ~BasePaintedLayerDelegate() override;
+
+  SkColor color() const { return color_; }
+
+  // ui::LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override;
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override;
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override;
+  base::Closure PrepareForLayerBoundsChange() override;
 
  private:
-  // ui::ImplicitAnimationObserver:
-  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override;
-  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override;
-  void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) override {}
-
-  bool RequiresNotificationWhenAnimatorDestroyed() const override;
-
-  // The ui::Layer being observed, which hide animations will be set on.
-  ui::Layer* layer_;
-
-  // Optional ui::Layer which will be hidden upon the completion of animating
-  // |layer_|
-  ui::Layer* background_layer_;
-
-  // If true the hide animation will immediately be scheduled upon completion of
-  // the observed animation.
-  bool hide_;
-
-  DISALLOW_COPY_AND_ASSIGN(AppearAnimationObserver);
+  // The color to paint.
+  SkColor color_;
+
+  DISALLOW_COPY_AND_ASSIGN(BasePaintedLayerDelegate);
 };
 
-AppearAnimationObserver::AppearAnimationObserver(ui::Layer* layer, bool hide)
-    : layer_(layer), background_layer_(nullptr), hide_(hide) {}
-
-AppearAnimationObserver::~AppearAnimationObserver() {
-  StopObserving();
-}
-
-bool AppearAnimationObserver::IsAnimationActive() {
-  // Initial animation ongoing
-  if (!attached_sequences().empty())
-    return true;
-  // Maintain the animation until told to hide.
-  if (!hide_)
-    return true;
-
-  // Check the state of the triggered hide animation
-  return layer_->GetAnimator()->IsAnimatingProperty(
-             ui::LayerAnimationElement::OPACITY) &&
-         layer_->GetTargetOpacity() == 0.0f &&
-         layer_->GetAnimator()->IsAnimatingProperty(
-             ui::LayerAnimationElement::VISIBILITY) &&
-         !layer_->GetTargetVisibility();
-}
-
-void AppearAnimationObserver::StartHideAnimation() {
-  if (background_layer_)
-    background_layer_->SetVisible(false);
-  if (!layer_->GetTargetVisibility())
+BasePaintedLayerDelegate::BasePaintedLayerDelegate(SkColor color)
+    : color_(color) {}
+
+BasePaintedLayerDelegate::~BasePaintedLayerDelegate() {}
+
+void BasePaintedLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {}
+
+void BasePaintedLayerDelegate::OnDelegatedFrameDamage(
+    const gfx::Rect& damage_rect_in_dip) {}
+
+void BasePaintedLayerDelegate::OnDeviceScaleFactorChanged(
+    float device_scale_factor) {}
+
+base::Closure BasePaintedLayerDelegate::PrepareForLayerBoundsChange() {
+  return base::Closure();
+}
+
+// A BasePaintedLayerDelegate that paints a circle of the specified color and
+// radius.
+class CircleLayerDelegate : public BasePaintedLayerDelegate {
+ public:
+  CircleLayerDelegate(SkColor color, int radius);
+  ~CircleLayerDelegate() override;
+
+  int radius() const { return radius_; }
+
+  // ui::LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override;
+
+ private:
+  // The radius of the circle.
+  int radius_;
+
+  DISALLOW_COPY_AND_ASSIGN(CircleLayerDelegate);
+};
+
+CircleLayerDelegate::CircleLayerDelegate(SkColor color, int radius)
+    : BasePaintedLayerDelegate(color), radius_(radius) {}
+
+CircleLayerDelegate::~CircleLayerDelegate() {}
+
+void CircleLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {
+  SkPaint paint;
+  paint.setColor(color());
+  paint.setFlags(SkPaint::kAntiAlias_Flag);
+  paint.setStyle(SkPaint::kFill_Style);
+
+  ui::PaintRecorder recorder(context, gfx::Size(radius_, radius_));
+  gfx::Canvas* canvas = recorder.canvas();
+
+  gfx::Point center_point = gfx::Point(radius_, radius_);
+  canvas->DrawCircle(center_point, radius_, paint);
+}
+
+// A BasePaintedLayerDelegate that paints a rectangle of the specified color and
+// size.
+class RectangleLayerDelegate : public BasePaintedLayerDelegate {
+ public:
+  RectangleLayerDelegate(SkColor color, gfx::Size size);
+  ~RectangleLayerDelegate() override;
+
+  gfx::Size size() const { return size_; }
+
+  // ui::LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override;
+
+ private:
+  // The size of the rectangle.
+  gfx::Size size_;
+
+  DISALLOW_COPY_AND_ASSIGN(RectangleLayerDelegate);
+};
+
+RectangleLayerDelegate::RectangleLayerDelegate(SkColor color, gfx::Size size)
+    : BasePaintedLayerDelegate(color), size_(size) {}
+
+RectangleLayerDelegate::~RectangleLayerDelegate() {}
+
+void RectangleLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {
+  SkPaint paint;
+  paint.setColor(color());
+  paint.setFlags(SkPaint::kAntiAlias_Flag);
+  paint.setStyle(SkPaint::kFill_Style);
+
+  ui::PaintRecorder recorder(context, size_);
+  gfx::Canvas* canvas = recorder.canvas();
+  canvas->DrawRect(gfx::Rect(0, 0, size_.width(), size_.height()), paint);
+}
+
+InkDropAnimation::InkDropAnimation(const gfx::Size& large_size,
+                                   int large_corner_radius,
+                                   const gfx::Size& small_size,
+                                   int small_corner_radius)
+    : 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,
+          std::min(large_size_.width(), large_size_.height()) / 2)),
+      rect_layer_delegate_(
+          new RectangleLayerDelegate(kInkDropColor, large_size_)),
+      root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
+      ink_drop_state_(InkDropState::HIDDEN) {
+  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_));
+
+  ResetTransformsToMinSize();
+
+  SetOpacity(kHiddenOpacity);
+}
+
+InkDropAnimation::~InkDropAnimation() {}
+
+void InkDropAnimation::AnimateToState(InkDropState state) {
+  if (ink_drop_state_ == state)
     return;
 
-  ui::ScopedLayerAnimationSettings animation(layer_->GetAnimator());
-  animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
-      UseFastAnimations() ? kHideAnimationDurationFastMs
-                          : kHideAnimationDurationSlowMs));
-  animation.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  layer_->SetOpacity(0.0f);
-  layer_->SetVisible(false);
-}
-
-void AppearAnimationObserver::HideNowIfDoneOrOnceCompleted() {
-  hide_ = true;
-  if (attached_sequences().empty())
-    StartHideAnimation();
-}
-
-void AppearAnimationObserver::SetBackgroundToHide(ui::Layer* background_layer) {
-  background_layer_ = background_layer;
-}
-
-void AppearAnimationObserver::OnLayerAnimationEnded(
-    ui::LayerAnimationSequence* sequence) {
-  if (hide_)
-    StartHideAnimation();
-}
-
-void AppearAnimationObserver::OnLayerAnimationAborted(
-    ui::LayerAnimationSequence* sequence) {
-  if (hide_)
-    StartHideAnimation();
-}
-
-bool AppearAnimationObserver::RequiresNotificationWhenAnimatorDestroyed()
-    const {
-  // Ensures that OnImplicitAnimationsCompleted is called even if the observed
-  // animation is deleted. Allows for setting the proper state on |layer_|.
-  return true;
-}
-
-InkDropAnimation::InkDropAnimation()
-    : root_layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
-      ink_drop_layer_(new ui::Layer()),
-      appear_animation_observer_(nullptr),
-      long_press_layer_(new ui::Layer()),
-      long_press_animation_observer_(nullptr),
-      ink_drop_bounds_(0, 0, 0, 0) {
-  ink_drop_delegate_.reset(new InkDropDelegate(ink_drop_layer_.get(),
-                                               kInkDropColor, kCircleRadius,
-                                               kRoundedRectCorners));
-  long_press_delegate_.reset(new InkDropDelegate(long_press_layer_.get(),
-                                                 kLongPressColor, kCircleRadius,
-                                                 kRoundedRectCorners));
-
-  SetupAnimationLayer(long_press_layer_.get(), long_press_delegate_.get());
-  SetupAnimationLayer(ink_drop_layer_.get(), ink_drop_delegate_.get());
-
-  root_layer_->Add(ink_drop_layer_.get());
-  root_layer_->Add(long_press_layer_.get());
-}
-
-InkDropAnimation::~InkDropAnimation() {}
-
-void InkDropAnimation::AnimateToState(InkDropState state) {
-  // TODO(bruthig): Do not transition if we are already in |state| and restrict
-  // any state transition that don't make sense or wouldn't look visually
-  // appealing.
+  if (ink_drop_state_ == InkDropState::HIDDEN &&
+      state != InkDropState::HIDDEN) {
+    ResetTransformsToMinSize();
+    SetOpacity(kVisibleOpacity);
+  }
+
+  InkDropTransforms transforms;
+
   switch (state) {
     case InkDropState::HIDDEN:
-      AnimateHide();
+      ink_drop_state_ = state;
+      GetCurrentTansforms(transforms);
+      AnimateToTransforms(transforms, kHiddenOpacity,
+                          GetAnimationDuration(InkDropState::HIDDEN),
+                          ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
       break;
     case InkDropState::ACTION_PENDING:
-      AnimateTapDown();
+      ink_drop_state_ = state;
+      CalculateCircleTransforms(large_size_, transforms);
+      AnimateToTransforms(transforms, kVisibleOpacity,
+                          GetAnimationDuration(InkDropState::ACTION_PENDING),
+                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       break;
     case InkDropState::QUICK_ACTION:
-      AnimateTapDown();
-      AnimateHide();
+      ink_drop_state_ = state;
+      CalculateCircleTransforms(large_size_, transforms);
+      AnimateToTransforms(transforms, kHiddenOpacity,
+                          GetAnimationDuration(InkDropState::QUICK_ACTION),
+                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      AnimateToState(InkDropState::HIDDEN);
+      break;
+    case InkDropState::SLOW_ACTION_PENDING:
+      ink_drop_state_ = state;
+      CalculateRectTransforms(small_size_, small_corner_radius_, transforms);
+      AnimateToTransforms(
+          transforms, kVisibleOpacity,
+          GetAnimationDuration(InkDropState::SLOW_ACTION_PENDING),
+          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       break;
     case InkDropState::SLOW_ACTION:
-      AnimateLongPress();
+      ink_drop_state_ = state;
+      CalculateRectTransforms(large_size_, large_corner_radius_, transforms);
+      AnimateToTransforms(transforms, kHiddenOpacity,
+                          GetAnimationDuration(InkDropState::SLOW_ACTION),
+                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      AnimateToState(InkDropState::HIDDEN);
       break;
     case InkDropState::ACTIVATED:
-      AnimateLongPress();
+      ink_drop_state_ = state;
+      CalculateRectTransforms(small_size_, small_corner_radius_, transforms);
+      AnimateToTransforms(transforms, kVisibleOpacity,
+                          GetAnimationDuration(InkDropState::ACTIVATED),
+                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      break;
+    case InkDropState::DEACTIVATED:
+      ink_drop_state_ = state;
+      CalculateRectTransforms(large_size_, large_corner_radius_, transforms);
+      AnimateToTransforms(transforms, kHiddenOpacity,
+                          GetAnimationDuration(InkDropState::DEACTIVATED),
+                          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      AnimateToState(InkDropState::HIDDEN);
       break;
   }
 }
 
-void InkDropAnimation::SetInkDropSize(const gfx::Size& size) {
-  SetInkDropBounds(gfx::Rect(ink_drop_bounds_.origin(), size));
-}
-
-gfx::Rect InkDropAnimation::GetInkDropBounds() const {
-  return ink_drop_bounds_;
-}
-
-void InkDropAnimation::SetInkDropBounds(const gfx::Rect& bounds) {
-  ink_drop_bounds_ = bounds;
-  SetLayerBounds(ink_drop_layer_.get());
-  SetLayerBounds(long_press_layer_.get());
-}
-
-void InkDropAnimation::AnimateTapDown() {
-  if ((appear_animation_observer_ &&
-       appear_animation_observer_->IsAnimationActive()) ||
-      (long_press_animation_observer_ &&
-       long_press_animation_observer_->IsAnimationActive())) {
-    // Only one animation at a time. Subsequent tap downs are ignored until the
-    // current animation completes.
-    return;
+void InkDropAnimation::AnimateToTransforms(
+    InkDropTransforms transforms,
+    float opacity,
+    base::TimeDelta duration,
+    ui::LayerAnimator::PreemptionStrategy preemption_strategy) {
+  ui::LayerAnimator* root_animator = root_layer_->GetAnimator();
+  ui::ScopedLayerAnimationSettings root_animation(root_animator);
+  root_animation.SetPreemptionStrategy(preemption_strategy);
+  ui::LayerAnimationElement* root_element =
+      ui::LayerAnimationElement::CreateOpacityElement(opacity, duration);
+  ui::LayerAnimationSequence* root_sequence =
+      new ui::LayerAnimationSequence(root_element);
+  root_animator->StartAnimation(root_sequence);
+
+  for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i) {
+    AnimateToTransform(painted_layers_[i].get(), transforms[i], duration,
+                       preemption_strategy);
   }
-  appear_animation_observer_.reset(
-      new AppearAnimationObserver(ink_drop_layer_.get(), false));
-  AnimateShow(ink_drop_layer_.get(), appear_animation_observer_.get(),
-              base::TimeDelta::FromMilliseconds(
-                  (UseFastAnimations() ? kShowInkDropAnimationDurationFastMs
-                                       : kShowInkDropAnimationDurationSlowMs)));
-}
-
-void InkDropAnimation::AnimateHide() {
-  if (appear_animation_observer_ &&
-      appear_animation_observer_->IsAnimationActive()) {
-    appear_animation_observer_->HideNowIfDoneOrOnceCompleted();
-  } else if (long_press_animation_observer_) {
-    long_press_animation_observer_->HideNowIfDoneOrOnceCompleted();
-  }
-}
-
-void InkDropAnimation::AnimateLongPress() {
-  // Only one animation at a time. Subsequent long presses are ignored until the
-  // current animation completes.
-  if (long_press_animation_observer_ &&
-      long_press_animation_observer_->IsAnimationActive()) {
-    return;
-  }
-  appear_animation_observer_.reset();
-  long_press_animation_observer_.reset(
-      new AppearAnimationObserver(long_press_layer_.get(), false));
-  long_press_animation_observer_->SetBackgroundToHide(ink_drop_layer_.get());
-  AnimateShow(long_press_layer_.get(), long_press_animation_observer_.get(),
-              base::TimeDelta::FromMilliseconds(
-                  UseFastAnimations() ? kShowLongPressAnimationDurationFastMs
-                                      : kShowLongPressAnimationDurationSlowMs));
-}
-
-void InkDropAnimation::AnimateShow(ui::Layer* layer,
-                                   AppearAnimationObserver* observer,
-                                   base::TimeDelta duration) {
-  layer->SetVisible(true);
-  layer->SetOpacity(1.0f);
-
-  float start_x = ink_drop_bounds_.x() +
-                  layer->bounds().width() * kMinimumScaleCenteringOffset;
-  float start_y = ink_drop_bounds_.y() +
-                  layer->bounds().height() * kMinimumScaleCenteringOffset;
-
-  gfx::Transform initial_transform;
-  initial_transform.Translate(start_x, start_y);
-  initial_transform.Scale(kMinimumScale, kMinimumScale);
-  layer->SetTransform(initial_transform);
-
+}
+
+void InkDropAnimation::AnimateToTransform(
+    ui::Layer* layer,
+    const gfx::Transform& target_transform,
+    base::TimeDelta duration,
+    ui::LayerAnimator::PreemptionStrategy preemption_strategy) {
   ui::LayerAnimator* animator = layer->GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
-  animation.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-
-  gfx::Transform target_transform;
-  target_transform.Translate(ink_drop_bounds_.x(), ink_drop_bounds_.y());
+  animation.SetPreemptionStrategy(preemption_strategy);
   ui::LayerAnimationElement* element =
       ui::LayerAnimationElement::CreateTransformElement(target_transform,
                                                         duration);
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(element);
-  sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
-void InkDropAnimation::SetLayerBounds(ui::Layer* layer) {
-  bool circle = UseCircularFeedback();
-  gfx::Size size = ink_drop_bounds_.size();
-  float circle_width = circle ? 2.0f * kCircleRadius : size.width();
-  float circle_height = circle ? 2.0f * kCircleRadius : size.height();
-  float circle_x = circle ? (size.width() - circle_width) * 0.5f : 0;
-  float circle_y = circle ? (size.height() - circle_height) * 0.5f : 0;
-  layer->SetBounds(gfx::Rect(circle_x, circle_y, circle_width, circle_height));
-}
-
-void InkDropAnimation::SetupAnimationLayer(ui::Layer* layer,
-                                           InkDropDelegate* delegate) {
+void InkDropAnimation::ResetTransformsToMinSize() {
+  InkDropTransforms transforms;
+  // Using a size of 0x0 creates visual anomalies.
+  CalculateCircleTransforms(gfx::Size(1, 1), transforms);
+  SetTransforms(transforms);
+}
+
+void InkDropAnimation::SetTransforms(InkDropTransforms transforms) {
+  for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
+    painted_layers_[i]->SetTransform(transforms[i]);
+}
+
+void InkDropAnimation::SetOpacity(float opacity) {
+  root_layer_->SetOpacity(opacity);
+}
+
+void InkDropAnimation::CalculateCircleTransforms(
+    const gfx::SizeF size,
+    InkDropTransforms transforms) const {
+  CalculateRectTransforms(size, std::min(size.width(), size.height()) / 2.0f,
+                          transforms);
+}
+
+void InkDropAnimation::CalculateRectTransforms(
+    const gfx::SizeF size,
+    float corner_radius,
+    InkDropTransforms transforms) const {
+  // TODO(bruthig): Add some documentation.
+  const float circle_radius = circle_layer_delegate_->radius();
+  const float corner_scale =
+      std::max(kMinimumCircleScale, corner_radius / circle_radius);
+  const float corner_circle_x_offset = size.width() / 2.0f - corner_radius;
+  const float corner_circle_y_offset = size.height() / 2.0f - corner_radius;
+
+  transforms[TOP_LEFT_CIRCLE].Translate(circle_radius - corner_circle_x_offset,
+                                        circle_radius - corner_circle_y_offset);
+  transforms[TOP_LEFT_CIRCLE].Scale(corner_scale, corner_scale);
+  transforms[TOP_LEFT_CIRCLE].Translate(-circle_radius, -circle_radius);
+
+  transforms[TOP_RIGHT_CIRCLE].Translate(
+      circle_radius + corner_circle_x_offset,
+      circle_radius - corner_circle_y_offset);
+  transforms[TOP_RIGHT_CIRCLE].Scale(corner_scale, corner_scale);
+  transforms[TOP_RIGHT_CIRCLE].Translate(-circle_radius, -circle_radius);
+
+  transforms[BOTTOM_RIGHT_CIRCLE].Translate(
+      circle_radius + corner_circle_x_offset,
+      circle_radius + corner_circle_y_offset);
+  transforms[BOTTOM_RIGHT_CIRCLE].Scale(corner_scale, corner_scale);
+  transforms[BOTTOM_RIGHT_CIRCLE].Translate(-circle_radius, -circle_radius);
+
+  transforms[BOTTOM_LEFT_CIRCLE].Translate(
+      circle_radius - corner_circle_x_offset,
+      circle_radius + corner_circle_y_offset);
+  transforms[BOTTOM_LEFT_CIRCLE].Scale(corner_scale, corner_scale);
+  transforms[BOTTOM_LEFT_CIRCLE].Translate(-circle_radius, -circle_radius);
+
+  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 float horizontal_rect_x_scale =
+      std::max(kMinimumRectScale, size.width() / rect_delegate_width);
+  const float horizontal_rect_y_scale =
+      std::max(kMinimumRectScale,
+               (size.height() - 2.0f * corner_radius) / rect_delegate_height);
+
+  transforms[HORIZONTAL_RECT].Scale(horizontal_rect_x_scale,
+                                    horizontal_rect_y_scale);
+  transforms[HORIZONTAL_RECT] = TransformAboutPivot(
+      painted_layers_[HORIZONTAL_RECT]->bounds().CenterPoint(),
+      transforms[HORIZONTAL_RECT]);
+
+  const float vertical_rect_x_scale =
+      std::max(kMinimumRectScale,
+               (size.width() - 2.0f * corner_radius) / rect_delegate_width);
+  const float vertical_rect_y_scale =
+      std::max(kMinimumRectScale, size.height() / rect_delegate_height);
+
+  transforms[VERTICAL_RECT].Scale(vertical_rect_x_scale, vertical_rect_y_scale);
+  transforms[VERTICAL_RECT] = TransformAboutPivot(
+      painted_layers_[VERTICAL_RECT]->bounds().CenterPoint(),
+      transforms[VERTICAL_RECT]);
+}
+
+void InkDropAnimation::GetCurrentTansforms(InkDropTransforms transforms) const {
+  for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
+    transforms[i] = painted_layers_[i]->GetTargetTransform();
+}
+
+void InkDropAnimation::SetOrigin(const gfx::Point& origin) {
+  gfx::Rect bounds = root_layer_->bounds();
+  bounds.set_origin(origin);
+  root_layer_->SetBounds(bounds);
+}
+
+void InkDropAnimation::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:
+    case VERTICAL_RECT:
+      delegate = rect_layer_delegate_.get();
+      break;
+    case PAINTED_SHAPE_COUNT:
+      NOTREACHED() << "PAINTED_SHAPE_COUNT is not an actual shape type.";
+      break;
+  }
+
+  ui::Layer* layer = new ui::Layer();
+  root_layer_->Add(layer);
+
+  layer->SetBounds(gfx::Rect(large_size_));
   layer->SetFillsBoundsOpaquely(false);
   layer->set_delegate(delegate);
-  layer->SetVisible(false);
-  layer->SetBounds(gfx::Rect());
-  delegate->set_should_render_circle(UseCircularFeedback());
+  layer->SetVisible(true);
+  layer->SetOpacity(1.0);
+  layer->SetMasksToBounds(false);
+
+  painted_layers_[painted_shape].reset(layer);
 }
 
 }  // namespace views