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_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.h"
+#include "ui/views/animation/ink_drop_animation_controller_impl.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 80 matching lines @@
   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);
 };
 
 AppearAnimationObserver::AppearAnimationObserver(ui::Layer* layer, bool hide)
-    : layer_(layer), background_layer_(nullptr), hide_(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.
@@ skipping 47 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;
+InkDropAnimationControllerImpl::InkDropAnimationControllerImpl(
+    InkDropHost* ink_drop_host)
+    : InkDropAnimationController(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),
+      ink_drop_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_);

[sadrul, 2015/08/17 14:33:06]

This does not pass ownership of |ink_drop_layer_|, |long_press_layer_| layers,
right? Are these leaking?

[bruthig, 2015/08/17 17:43:39]

The LayerTreeOwner will delete all the roots descendants as well so this
shouldn't be leaking.  But, this did make me realize that we might have an issue
if an ink drop ripple is active when the screen rotates because the screen
rotation animation is creating a copy of the full layer tree.  I will have to
think more about this...

 
-  // 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() {
+InkDropAnimationControllerImpl::~InkDropAnimationControllerImpl() {
+  // 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.

[sadrul, 2015/08/17 14:33:06]

Update the comment (e.g. 'Change this to be called when Ink Drop becomes
hidden.')

[bruthig, 2015/08/17 17:43:39]

Done.

+  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 InkDropAnimationControllerImpl::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.
+  switch (state) {
+    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 InkDropAnimationControllerImpl::SetInkDropSize(const gfx::Size& size) {
+  SetInkDropBounds(gfx::Rect(ink_drop_bounds_.x(), ink_drop_bounds_.y(),
+                             size.width(), size.height()));

[sadrul, 2015/08/17 14:33:06]

gfx::Rect(ink_drop_bounds_.origin(), size())

[bruthig, 2015/08/17 17:43:39]

Done.

 }
 
-void InkDropDelegate::OnDeviceScaleFactorChanged(float device_scale_factor) {
+gfx::Rect InkDropAnimationControllerImpl::GetInkDropBounds() const {
+  return ink_drop_bounds_;
 }
 
-base::Closure InkDropDelegate::PrepareForLayerBoundsChange() {
-  return base::Closure();
+void InkDropAnimationControllerImpl::SetInkDropBounds(const gfx::Rect& bounds) {
+  ink_drop_bounds_ = bounds;
+  SetLayerBounds(ink_drop_layer_);
+  SetLayerBounds(long_press_layer_);
 }
 
-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::AnimateTapDown() {
+void InkDropAnimationControllerImpl::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_)
+void InkDropAnimationControllerImpl::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 InkDropAnimationController::AnimateLongPress() {
+void InkDropAnimationControllerImpl::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());
+void InkDropAnimationControllerImpl::AnimateShow(
+    ui::Layer* layer,
+    AppearAnimationObserver* observer,
+    base::TimeDelta duration) {
   layer->SetVisible(true);
   layer->SetOpacity(1.0f);
 
-  float start_x = layer->bounds().width() * kMinimumScaleCenteringOffset;
-  float start_y = layer->bounds().height() * kMinimumScaleCenteringOffset;
+  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);
 
   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(ink_drop_bounds_.x(), ink_drop_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 InkDropAnimationControllerImpl::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 InkDropAnimationController::SetupAnimationLayer(
-    ui::Layer* parent,
+void InkDropAnimationControllerImpl::SetupAnimationLayer(
     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