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);

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

Will this now always be the responsibility of the View?

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

Yes, the reason being that the InkDropHost could potentially add the ink drop
layer wherever it wants now and it might not always be the case that the View
has to do this.

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

It may be a good idea to include this in a comment somewhere. Needing to call
SetPaintToLayer(true) could be easy to miss for another UI surface that wants
the ripple.

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

Done. See documentation for the InkDropHost.

     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())
+    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));

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

State change?

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

I've omitted setting the ACTIVATED state for the time being because there is no
animation currently to show this and thus I can't be sure it is implemented
correctly.  Once the ripple properly handles that state it will definitely need
to be added in.  Most likely it will be in ShowDropDownMenu though.

For now the ACTION_PENDING circle will be visible until the menu closes.

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

Acknowledged.

     }
   }
 
   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())
+    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(
+            views::InkDropState::ACTION_PENDING);
+        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:

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

We won't receive these if TAP_DOWN is not marked as handled, and the finger
leaves the View's region.

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

Done.

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

Did you verify this? It seems to me that the implementation of
CustomButton::OnGestureEvent() should take care of everything for us already.
And as a general guideline I feel like events should not be modified as a result
of animation state changes (only as a result of already-existing functional
state changes).

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

Well I would be concerned about each usage of the animation requires that
ancestral classes mark gestures appropriately so that we receive the events.

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

I could call LabelButton::OnGestureEvent(...) before the switch statement and
add CHECK(event->handled()) in the ET_GESTURE_TAP_DOWN case.  WDYT?

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

I would prefer that, but I don't think it's necessary. IIRC if a class isn't
already marking TAP_DOWN as handled then it is not guaranteed to receive the
remainder of the gesture sequence and will have functional problems independent
of the ripple animation.

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

Done.

+        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);
+}
+
 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);

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

Can the transition to Hidden be triggered twice for the same gesture?

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

My thinking is that the InkDropAnimationController will be able to transition
from any state, or mid-state, to HIDDEN, and it shouldn't matter if it is called
more than once.  And yes this currently works.

These are the details that will get ironed out in the subsequent work that
actually implements the revamped ripple and its states.

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

Acknowledged.

+
   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";
 }