Enhance the material design ripple API so the ripple's state can be controlled by it's owning View.

ui/views/animation/ink_drop_animation_controller.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.h"
 
 #include "base/command_line.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/events/event.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/views/animation/ink_drop_delegate.h"
+#include "ui/views/animation/ink_drop_host.h"
 #include "ui/views/view.h"
 
 namespace {
 
 // Animation constants
 const float kMinimumScale = 0.1f;
 const float kMinimumScaleCenteringOffset = 0.5f - kMinimumScale / 2.0f;
 
 const int kHideAnimationDurationFastMs = 100;
 const int kHideAnimationDurationSlowMs = 1000;
@@ skipping 149 matching lines @@
     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;
 }
 
-// Renders the visual feedback. Will render a circle if |circle_| is true,
-// otherwise renders a rounded rectangle.
-class InkDropDelegate : public ui::LayerDelegate {
- public:
-  InkDropDelegate(ui::Layer* layer, SkColor color);
-  ~InkDropDelegate() override;
+InkDropAnimationController::InkDropAnimationController(
+    InkDropHost* ink_drop_host)
+    : ink_drop_host_(ink_drop_host),
+      layer_tree_(new ui::Layer()),
+      ink_drop_layer_(new ui::Layer()),
+      ink_drop_delegate_(new InkDropDelegate(ink_drop_layer_,
+                                             kInkDropColor,
+                                             kCircleRadius,
+                                             kRoundedRectCorners)),
+      appear_animation_observer_(nullptr),
+      long_press_layer_(new ui::Layer()),
+      long_press_delegate_(new InkDropDelegate(long_press_layer_,
+                                               kLongPressColor,
+                                               kCircleRadius,
+                                               kRoundedRectCorners)),
+      long_press_animation_observer_(nullptr),
+      bounds_(0, 0, 0, 0) {
+  SetupAnimationLayer(long_press_layer_, long_press_delegate_.get());
+  SetupAnimationLayer(ink_drop_layer_, ink_drop_delegate_.get());
 
-  // Sets the visual style of the feedback.
-  void set_should_render_circle(bool should_render_circle) {
-    should_render_circle_ = should_render_circle;
-  }
+  layer_tree_.root()->Add(ink_drop_layer_);
+  layer_tree_.root()->Add(long_press_layer_);
 
-  // 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:
-  // The ui::Layer being rendered to.
-  ui::Layer* layer_;
-
-  // The color to paint.
-  SkColor color_;
-
-  // When true renders a circle, otherwise renders a rounded rectangle.
-  bool should_render_circle_;
-
-  DISALLOW_COPY_AND_ASSIGN(InkDropDelegate);
-};
-
-InkDropDelegate::InkDropDelegate(ui::Layer* layer, SkColor color)
-    : layer_(layer), color_(color), should_render_circle_(true) {
+  ink_drop_host_->AddInkDropLayer(layer_tree_.root());
 }
 
-InkDropDelegate::~InkDropDelegate() {
+InkDropAnimationController::~InkDropAnimationController() {
+  // TODO(bruthig): Currently this virtual function is going to be called during
+  // ToolbarButton's destructor, is that ok?? This should hopefully change and
+  // be called when the Ink Drop becomes hidden.
+  ink_drop_host_->RemoveInkDropLayer(layer_tree_.root());
 }
 
-void InkDropDelegate::OnPaintLayer(const ui::PaintContext& context) {
-  SkPaint paint;
-  paint.setColor(color_);
-  paint.setFlags(SkPaint::kAntiAlias_Flag);
-  paint.setStyle(SkPaint::kFill_Style);
-
-  gfx::Rect bounds = layer_->bounds();
-
-  ui::PaintRecorder recorder(context, layer_->size());
-  gfx::Canvas* canvas = recorder.canvas();
-  if (should_render_circle_) {
-    gfx::Point midpoint(bounds.width() * 0.5f, bounds.height() * 0.5f);
-    canvas->DrawCircle(midpoint, kCircleRadius, paint);
-  } else {
-    canvas->DrawRoundRect(bounds, kRoundedRectCorners, paint);
+void InkDropAnimationController::AnimateToState(InkDropState state) {
+  switch (state) {

[jonross, 2015/08/07 17:14:31]

Do we need to restrict state transitions?

I think we should track the current state, and not transition to it if we are
already in it.

[bruthig, 2015/08/07 22:00:45]

All the work for state transitions and the visuals for each state will come in a
subsequent review.  But yes you are right, we will most likely need to only
allow certain state transitions.  And when we do I plan to provide a mechanism
for clients to determine what the current state is and potentially events for
when the animation reaches the different states.

My current plan, in a subsequent review of course, is to add an InkDropAnimation
class that will manages the lifetime of the many ripple layers, animating them,
the state, etc.  i.e. A lot of the work that the InkDropAnimationController is
currently doing.  I envision the InkDropAnimationController becoming very thin
and delegating many of the current methods off to this new
InkDropAnimationController.  The InkDropAnimationController's main
responsibility will then become acquiring and releasing the InkDropAnimation
from an InkDropAnimationPool object and attaching/removing it from the
InkDropHost.

[jonross, 2015/08/10 20:32:02]

A good plan. Do we have this noted in the bug? Or should we add a todo?

[bruthig, 2015/08/10 21:57:15]

Hmmm I'm not sure either of those two places are a good spot for speculative
design.

[tdanderson, 2015/08/11 12:57:36]

If you're fairly sure of what you're going to be doing in a follow-up CL, I
think a brief TODO might be appropriate - no need to go into too much detail
though.

[bruthig, 2015/08/11 14:31:10]

Done.

+    case InkDropState::HIDDEN:
+      AnimateHide();
+      break;
+    case InkDropState::ACTION_PENDING:
+      AnimateTapDown();
+      break;
+    case InkDropState::QUICK_ACTION:
+      AnimateTapDown();
+      AnimateHide();
+      break;
+    case InkDropState::SLOW_ACTION:
+      AnimateLongPress();
+      break;
+    case InkDropState::ACTIVATED:
+      AnimateLongPress();
+      break;
   }
 }
 
-void InkDropDelegate::OnDelegatedFrameDamage(
-    const gfx::Rect& damage_rect_in_dip) {
+void InkDropAnimationController::SetSize(const gfx::Size& size) {
+  SetBounds(gfx::Rect(bounds().x(), bounds().y(), size.width(), size.height()));
 }
 
-void InkDropDelegate::OnDeviceScaleFactorChanged(float device_scale_factor) {
-}
-
-base::Closure InkDropDelegate::PrepareForLayerBoundsChange() {
-  return base::Closure();
-}
-
-InkDropAnimationController::InkDropAnimationController(views::View* view)
-    : ink_drop_layer_(new ui::Layer()),
-      ink_drop_delegate_(
-          new InkDropDelegate(ink_drop_layer_.get(), kInkDropColor)),
-      appear_animation_observer_(nullptr),
-      long_press_layer_(new ui::Layer()),
-      long_press_delegate_(
-          new InkDropDelegate(long_press_layer_.get(), kLongPressColor)),
-      long_press_animation_observer_(nullptr),
-      view_(view) {
-  view_->SetPaintToLayer(true);
-  view_->AddPreTargetHandler(this);
-  ui::Layer* layer = view_->layer();
-  layer->SetMasksToBounds(!UseCircularFeedback());
-  SetupAnimationLayer(layer, long_press_layer_.get(),
-                      long_press_delegate_.get());
-  SetupAnimationLayer(layer, ink_drop_layer_.get(), ink_drop_delegate_.get());
-  ink_drop_delegate_->set_should_render_circle(UseCircularFeedback());
-}
-
-InkDropAnimationController::~InkDropAnimationController() {
-  view_->RemovePreTargetHandler(this);
+void InkDropAnimationController::SetBounds(const gfx::Rect& bounds) {
+  bounds_ = bounds;
+  SetLayerBounds(ink_drop_layer_);
+  SetLayerBounds(long_press_layer_);
 }
 
 void InkDropAnimationController::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;
   }
   appear_animation_observer_.reset(
-      new AppearAnimationObserver(ink_drop_layer_.get(), false));
-  AnimateShow(ink_drop_layer_.get(), appear_animation_observer_.get(),
-              UseCircularFeedback(),
+      new AppearAnimationObserver(ink_drop_layer_, false));
+  AnimateShow(ink_drop_layer_, appear_animation_observer_.get(),
               base::TimeDelta::FromMilliseconds(
                   (UseFastAnimations() ? kShowInkDropAnimationDurationFastMs
                                        : kShowInkDropAnimationDurationSlowMs)));
 }
 
 void InkDropAnimationController::AnimateHide() {
-  if (appear_animation_observer_)
+  if (appear_animation_observer_ &&
+      appear_animation_observer_->IsAnimationActive()) {
     appear_animation_observer_->HideNowIfDoneOrOnceCompleted();
+  } else if (long_press_animation_observer_) {
+    long_press_animation_observer_->HideNowIfDoneOrOnceCompleted();
+  }
 }
 
 void InkDropAnimationController::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(), true));
-  long_press_animation_observer_->SetBackgroundToHide(ink_drop_layer_.get());
-  AnimateShow(long_press_layer_.get(), long_press_animation_observer_.get(),
-              true,
+      new AppearAnimationObserver(long_press_layer_, false));
+  long_press_animation_observer_->SetBackgroundToHide(ink_drop_layer_);
+  AnimateShow(long_press_layer_, long_press_animation_observer_.get(),
               base::TimeDelta::FromMilliseconds(
                   UseFastAnimations() ? kShowLongPressAnimationDurationFastMs
                                       : kShowLongPressAnimationDurationSlowMs));
 }
 
 void InkDropAnimationController::AnimateShow(ui::Layer* layer,
                                              AppearAnimationObserver* observer,
-                                             bool circle,
                                              base::TimeDelta duration) {
-  SetLayerBounds(layer, circle, view_->width(), view_->height());
   layer->SetVisible(true);
   layer->SetOpacity(1.0f);
 
-  float start_x = layer->bounds().width() * kMinimumScaleCenteringOffset;
-  float start_y = layer->bounds().height() * kMinimumScaleCenteringOffset;
+  float start_x =
+      bounds_.x() + layer->bounds().width() * kMinimumScaleCenteringOffset;
+  float start_y =
+      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);
 
   ui::LayerAnimator* animator = layer->GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
-  gfx::Transform identity_transform;
+  gfx::Transform target_transform;
+  target_transform.Translate(bounds_.x(), bounds_.y());
   ui::LayerAnimationElement* element =
-      ui::LayerAnimationElement::CreateTransformElement(identity_transform,
+      ui::LayerAnimationElement::CreateTransformElement(target_transform,
                                                         duration);
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(element);
   sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
-void InkDropAnimationController::SetLayerBounds(ui::Layer* layer,
-                                                bool circle,
-                                                int width,
-                                                int height) {
-  float circle_width = circle ? 2.0f * kCircleRadius : width;
-  float circle_height = circle ? 2.0f * kCircleRadius : height;
-  float circle_x = circle ? (width - circle_width) * 0.5f : 0;
-  float circle_y = circle ? (height - circle_height) * 0.5f : 0;
+void InkDropAnimationController::SetLayerBounds(ui::Layer* layer) {
+  bool circle = UseCircularFeedback();
+  gfx::Size size = 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 InkDropAnimationController::SetupAnimationLayer(
-    ui::Layer* parent,
     ui::Layer* layer,
     InkDropDelegate* delegate) {
   layer->SetFillsBoundsOpaquely(false);
   layer->set_delegate(delegate);
   layer->SetVisible(false);
   layer->SetBounds(gfx::Rect());
-  parent->Add(layer);
-  parent->StackAtBottom(layer);
-}
-
-void InkDropAnimationController::OnGestureEvent(ui::GestureEvent* event) {
-  if (event->target() != view_)
-    return;
-
-  switch (event->type()) {
-    case ui::ET_GESTURE_TAP_DOWN:
-      AnimateTapDown();
-      break;
-    case ui::ET_GESTURE_LONG_PRESS:
-      AnimateLongPress();
-      break;
-    case ui::ET_GESTURE_END:
-    case ui::ET_GESTURE_TAP_CANCEL:
-    case ui::ET_GESTURE_TAP:
-      AnimateHide();
-      break;
-    default:
-      break;
-  }
+  delegate->set_should_render_circle(UseCircularFeedback());
 }
 
 }  // namespace views