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

chrome/browser/ui/views/toolbar/toolbar_button.cc

 // Copyright 2013 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 "chrome/browser/ui/views/toolbar/toolbar_button.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 18 matching lines @@
                              ui::MenuModel* model)
     : views::LabelButton(listener, base::string16()),
       model_(model),
       menu_showing_(false),
       y_position_on_lbuttondown_(0),
       show_menu_factory_(this) {
 #if defined(OS_CHROMEOS)
   // The ink drop animation is only targeted at ChromeOS because there is
   // concern it will conflict with OS level touch feedback in a bad way.
   if (ui::MaterialDesignController::IsModeMaterial()) {
+    SetPaintToLayer(true);
     ink_drop_animation_controller_.reset(
         new views::InkDropAnimationController(this));
     layer()->SetFillsBoundsOpaquely(false);
     image()->SetPaintToLayer(true);
     image()->SetFillsBoundsOpaquely(false);
   }
 #endif  // defined(OS_CHROMEOS)
 
   set_context_menu_controller(this);
 }
@@ skipping 30 matching lines @@
     ui::ThemeProvider* provider = GetThemeProvider();
     if (provider && provider->UsingSystemTheme()) {
       int inset = provider->GetDisplayProperty(
           ThemeProperties::PROPERTY_TOOLBAR_BUTTON_BORDER_INSET);
       size.Enlarge(2 * inset, 2 * inset);
     }
   }
   return size;
 }
 
+void ToolbarButton::Layout() {
+  LabelButton::Layout();
+  if (ui::MaterialDesignController::IsModeMaterial())
+    LayoutInkDrop();
+}
+
 bool ToolbarButton::OnMousePressed(const ui::MouseEvent& event) {
   if (enabled() && ShouldShowMenu() &&
       IsTriggerableEvent(event) && HitTestPoint(event.location())) {
     // Store the y pos of the mouse coordinates so we can use them later to
     // determine if the user dragged the mouse down (which should pop up the
     // drag down menu immediately, instead of waiting for the timer)
     y_position_on_lbuttondown_ = event.y();
 
     // Schedule a task that will show the menu.
     const int kMenuTimerDelay = 500;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&ToolbarButton::ShowDropDownMenu,
                               show_menu_factory_.GetWeakPtr(),
                               ui::GetMenuSourceTypeForEvent(event)),
         base::TimeDelta::FromMilliseconds(kMenuTimerDelay));
   }
+
+  if (ui::MaterialDesignController::IsModeMaterial())

[tdanderson, 2015/08/10 16:31:01]

nit: use {} since body is more than one line.

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

Done.

+    ink_drop_animation_controller_->AnimateToState(
+        views::InkDropState::ACTION_PENDING);
+
   return LabelButton::OnMousePressed(event);
 }
 
 bool ToolbarButton::OnMouseDragged(const ui::MouseEvent& event) {
   bool result = LabelButton::OnMouseDragged(event);
 
   if (show_menu_factory_.HasWeakPtrs()) {
     // If the mouse is dragged to a y position lower than where it was when
     // clicked then we should not wait for the menu to appear but show
     // it immediately.
     if (event.y() > y_position_on_lbuttondown_ + GetHorizontalDragThreshold()) {
       show_menu_factory_.InvalidateWeakPtrs();
       ShowDropDownMenu(ui::GetMenuSourceTypeForEvent(event));
     }
   }
 
   return result;
 }
 
 void ToolbarButton::OnMouseReleased(const ui::MouseEvent& event) {
   if (IsTriggerableEvent(event) ||
       (event.IsRightMouseButton() && !HitTestPoint(event.location()))) {
     LabelButton::OnMouseReleased(event);
   }
 
   if (IsTriggerableEvent(event))
     show_menu_factory_.InvalidateWeakPtrs();
+
+  if (ui::MaterialDesignController::IsModeMaterial())

[tdanderson, 2015/08/10 16:31:01]

What do you think of containing all of the IsModeMaterial() checks inside of
IDAC (by way of early returns / no-ops) instead of requiring each host to
include the check in multiple places?

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

I've implemented this with a factory, take a look see.  I'm thinking a
InkDropAnimationController test double might be useful here.

+    ink_drop_animation_controller_->AnimateToState(views::InkDropState::HIDDEN);
 }
 
 void ToolbarButton::OnMouseCaptureLost() {
 }
 
 void ToolbarButton::OnMouseExited(const ui::MouseEvent& event) {
   // Starting a drag results in a MouseExited, we need to ignore it.
   // A right click release triggers an exit event. We want to
   // remain in a PUSHED state until the drop down menu closes.
   if (state_ != STATE_DISABLED && !InDrag() && state_ != STATE_PRESSED)
     SetState(STATE_NORMAL);
 }
 
 void ToolbarButton::OnGestureEvent(ui::GestureEvent* event) {
   if (menu_showing_) {
     // While dropdown menu is showing the button should not handle gestures.
     event->StopPropagation();
     return;
   }
 
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    switch (event->type()) {
+      case ui::ET_GESTURE_TAP_DOWN:
+        ink_drop_animation_controller_->AnimateToState(

[tdanderson, 2015/08/10 16:31:01]

[I think this is a repeat of one of Jon's questions...]

Are there ever any times where the call site of AnimateToState() would actually
need to know about the current/previous state its controller is/was in, or can
that always be derived from the members of the host? One example that comes to
mind is how to handle the animation for pressing down on the back button but
then moving your finger off in the cases where the history menu is shown vs. not
shown.

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

Yes I can imagine that it would be very useful for an IDAC owner to know the
IDAC's animation state.  At this point I wasn't sure if the IDAC would be the
best place to track this state but I was planning to add something in the later
patch set that better defines all the ink drops states.  I'm thinking it would
best be tracked in the unborn 'InkDropLayer' class...

+            views::InkDropState::ACTION_PENDING);
+        event->SetHandled();
+        break;
+      case ui::ET_GESTURE_LONG_PRESS:
+        ink_drop_animation_controller_->AnimateToState(
+            views::InkDropState::SLOW_ACTION);
+        break;
+      case ui::ET_GESTURE_TAP:
+        ink_drop_animation_controller_->AnimateToState(
+            views::InkDropState::QUICK_ACTION);
+        break;
+      case ui::ET_GESTURE_END:
+      case ui::ET_GESTURE_TAP_CANCEL:
+        ink_drop_animation_controller_->AnimateToState(
+            views::InkDropState::HIDDEN);
+        break;
+      default:
+        break;
+    }
+  }
+
   LabelButton::OnGestureEvent(event);
 }
 
 void ToolbarButton::GetAccessibleState(ui::AXViewState* state) {
   CustomButton::GetAccessibleState(state);
   state->role = ui::AX_ROLE_BUTTON_DROP_DOWN;
   state->default_action = l10n_util::GetStringUTF16(IDS_APP_ACCACTION_PRESS);
   state->AddStateFlag(ui::AX_STATE_HASPOPUP);
 }
 
@@ skipping 32 matching lines @@
 void ToolbarButton::ShowContextMenuForView(View* source,
                                            const gfx::Point& point,
                                            ui::MenuSourceType source_type) {
   if (!enabled())
     return;
 
   show_menu_factory_.InvalidateWeakPtrs();
   ShowDropDownMenu(source_type);
 }
 
+void ToolbarButton::AddInkDropLayer(ui::Layer* ink_drop_layer) {
+  layer()->Add(ink_drop_layer);
+  layer()->StackAtBottom(ink_drop_layer);
+}
+
+void ToolbarButton::RemoveInkDropLayer(ui::Layer* ink_drop_layer) {
+  layer()->Remove(ink_drop_layer);

[tdanderson, 2015/08/10 16:31:01]

How will the implementations of AddInkDropLayer() and RemoveInkDropLayer()
differ between InkDropHosts? In other words, do these really need to be pure
virtual?

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

The most important thing that I can see changing between different
implementations is the z-layer ordering but I can imagine some host's doing some
more advanced things like adding the layer to a child/parent view's layer or
something like that.
We could definitely entertain the idea of having a default implementation in
some views::View higher up in the hierarchy though.

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

OK, sounds good to leave as is and have it evolve as needed.

+}
+
 bool ToolbarButton::ShouldEnterPushedState(const ui::Event& event) {
   // Enter PUSHED state on press with Left or Right mouse button or on taps.
   // Remain in this state while the context menu is open.
   return event.type() == ui::ET_GESTURE_TAP ||
          event.type() == ui::ET_GESTURE_TAP_DOWN ||
          (event.IsMouseEvent() && ((ui::EF_LEFT_MOUSE_BUTTON |
              ui::EF_RIGHT_MOUSE_BUTTON) & event.flags()) != 0);
 }
 
 bool ToolbarButton::ShouldShowMenu() {
@@ skipping 64 matching lines @@
     views::MenuRunner::RunResult result =
         menu_runner_->RunMenuAt(GetWidget(),
                                 NULL,
                                 gfx::Rect(menu_position, gfx::Size(0, 0)),
                                 views::MENU_ANCHOR_TOPLEFT,
                                 source_type);
     if (result == views::MenuRunner::MENU_DELETED)
       return;
   }
 
+  if (ui::MaterialDesignController::IsModeMaterial())
+    ink_drop_animation_controller_->AnimateToState(views::InkDropState::HIDDEN);
+
   menu_showing_ = false;
 
   // Need to explicitly clear mouse handler so that events get sent
   // properly after the menu finishes running. If we don't do this, then
   // the first click to other parts of the UI is eaten.
   SetMouseHandler(NULL);
 
   // Set the state back to normal after the drop down menu is closed.
   if (state_ != STATE_DISABLED)
     SetState(STATE_NORMAL);
 }
 
+void ToolbarButton::LayoutInkDrop() {
+  ink_drop_animation_controller_->SetSize(gfx::Size(width(), height()));
+}
+
 const char* ToolbarButton::GetClassName() const {
   return "ToolbarButton";
 }