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"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/resource/material_design/material_design_controller.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/animation/ink_drop_animation_controller.h"
+#include "ui/views/animation/ink_drop_animation_controller_factory.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/widget/widget.h"
 
 ToolbarButton::ToolbarButton(views::ButtonListener* listener,
                              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()) {
-    ink_drop_animation_controller_.reset(
-        new views::InkDropAnimationController(this));
-    layer()->SetFillsBoundsOpaquely(false);
-    image()->SetPaintToLayer(true);
-    image()->SetFillsBoundsOpaquely(false);
-  }
-#endif  // defined(OS_CHROMEOS)
-
+  SetPaintToLayer(true);
+  // TODO(bruthig): |ink_drop_animation_controller_| has to be initialized after
+  // SetPaintToLayer(true) becuase the InkDropAnimationControllerImpl
+  // constructor calls back in to AddInkDropLayer() to add the ink drop layer to
+  // layer(). This will be reworked so the InkDropAnimationController will call
+  // AddInkDropLayer() right before the ink drop becomes visible and then
+  // |ink_drop_animation_controller_| can be initialized in the initializer
+  // list.
+  ink_drop_animation_controller_ = views::InkDropAnimationControllerFactory::
+      CreateInkDropAnimationController(this);
+  layer()->SetFillsBoundsOpaquely(false);
+  image()->SetPaintToLayer(true);
+  image()->SetFillsBoundsOpaquely(false);

[tdanderson, 2015/08/11 19:07:40]

Do you still want to call lines 46-48 if the MD flag is turned off?

[jonross, 2015/08/11 20:34:46]

If the factory is abstracting MD, should 46-48 possibly be triggered by the
controller?

[bruthig, 2015/08/12 15:26:40]

They don't need to be called but they didn't seem to have any visual effect so I
left them in originally.  I've wrapped them in an 'if' now.

[bruthig, 2015/08/12 15:26:40]

I don't think the factory can in all general cases set up the InkDropHost
correctly. First it wouldn't make any sense for the
InkDropHost/InkDropAnimationControllerFactory to know anything about the image()
in the ToolbarButton.  This is not something that applies to all
Views/InkDropHosts. Similarly the SetFillsBoundsOpaquely() might not apply to
all InkDropHosts either.

[jonross, 2015/08/12 18:12:56]

True, but could the InkDropHost implement a method that the controller calls?

Could help clearly define what is ink drop related, vs needed for general MD
work.

   set_context_menu_controller(this);
 }
 
 ToolbarButton::~ToolbarButton() {
 }
 
 void ToolbarButton::Init() {
   SetFocusable(false);
   SetAccessibilityFocusable(true);
   image()->EnableCanvasFlippingForRTLUI(true);
@@ skipping 22 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();
+  LayoutInkDrop();

[jonross, 2015/08/11 20:34:46]

Thoughts on having this changed to:

virtual void InkDropHost::LayoutInkDrop() {}

Then:

InkDropAnimationController calling it?

[bruthig, 2015/08/12 15:26:40]

Please see thread about this here:
https://codereview.chromium.org/1280953003/diff/40001/chrome/browser/ui/views...

Additionally, I would like to point out that the InkDropAnimationController
wouldn't be able to call LayoutInkDrop() at the appropriate times because it is
not observing layout or bounds changes anyway.

+}
+
 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));
   }
+
+  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();
+
+  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;
   }
 
   LabelButton::OnGestureEvent(event);
+
+  switch (event->type()) {
+    case ui::ET_GESTURE_TAP_DOWN:
+      ink_drop_animation_controller_->AnimateToState(
+          views::InkDropState::ACTION_PENDING);
+      CHECK(event->handled()) << "event should be marked handled so that "

[tdanderson, 2015/08/11 19:07:41]

I'm still on the fence about whether this is needed / a good idea. I'm leaning
toward how you had it before (animation before call to superclass) but without
an explicit call to mark the event as handled. See what happens during ONWNERs
review.

[jonross, 2015/08/11 20:34:46]

This is just ensuring that it is handled. A valid check IMO. Otherwise there is
no guarantee that we'll see subsequent events. That could lead to partially
completed animations on controls.

+                                 "subsequent gestures are received.";
+      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;
+  }
 }
 
 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);
 }
 
 scoped_ptr<views::LabelButtonBorder>
@@ skipping 15 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;
   }
 
+  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_->SetInkDropSize(gfx::Size(width(), height()));
+}
+
 const char* ToolbarButton::GetClassName() const {
   return "ToolbarButton";
 }