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);
+    // TODO(bruthig): Only set the layer when the ink drop is active.

[sadrul, 2015/08/18 17:51:49]

Make sure there's a blocking crbug for this.

[bruthig, 2015/08/18 19:04:38]

Created www.crbug.com/522175

+    SetLayer(new ui::Layer(ui::LAYER_NOT_DRAWN));

[sadrul, 2015/08/18 17:51:49]

You should use SetPaintToLayer() instead.

[bruthig, 2015/08/18 19:04:38]

Done.

     image()->SetPaintToLayer(true);
     image()->SetFillsBoundsOpaquely(false);
   }
-#endif  // defined(OS_CHROMEOS)
+  // 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);
   set_context_menu_controller(this);
 }
 
 ToolbarButton::~ToolbarButton() {
+  // Explicitly delete the ink_drop_animation_controller_ because it may call
+  // RemoveInkDropLayer().

[Peter Kasting, 2015/08/17 21:18:15]

Is that actually a problem?  It seems like that call ought to work fine even
when made during the normal destruction sequence.

I would rather not do this explicitly unless we actually need to do so for
correctness' sake.

[bruthig, 2015/08/18 19:04:38]

Originally I added this at sadrul@'s request but I have removed it.
sadrul@, WDYT?

[sadrul, 2015/08/18 19:52:38]

Reaching into virtual functions during destruction make me nervous. But I don't
feel strongly enough about it.

+  ink_drop_animation_controller_.reset();
 }
 
 void ToolbarButton::Init() {
   SetFocusable(false);
   SetAccessibilityFocusable(true);
   image()->EnableCanvasFlippingForRTLUI(true);
 }
 
 void ToolbarButton::ClearPendingMenu() {
   show_menu_factory_.InvalidateWeakPtrs();
@@ skipping 18 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();
+}
+
 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);
+
+  views::InkDropState ink_drop_state = views::InkDropState::HIDDEN;
+  switch (event->type()) {
+    case ui::ET_GESTURE_TAP_DOWN:
+      ink_drop_state = views::InkDropState::ACTION_PENDING;
+      // The ui::ET_GESTURE_TAP_DOWN event needs to be marked as handled so that
+      // subsequent events for the gesture are sent to |this|.
+      event->SetHandled();
+      break;
+    case ui::ET_GESTURE_LONG_PRESS:
+      ink_drop_state = views::InkDropState::SLOW_ACTION;
+      break;
+    case ui::ET_GESTURE_TAP:
+      ink_drop_state = views::InkDropState::QUICK_ACTION;
+      break;
+    case ui::ET_GESTURE_END:
+    case ui::ET_GESTURE_TAP_CANCEL:
+      ink_drop_state = views::InkDropState::HIDDEN;
+      break;
+    default:
+      return;
+  }
+  ink_drop_animation_controller_->AnimateToState(ink_drop_state);
 }
 
 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);

[sadrul, 2015/08/18 17:51:49]

Maybe SetPaintToLayer etc. should be moved in here (and again in
RemoveInkDropLayer() below)? Would that address the TODO?

[bruthig, 2015/08/18 19:04:38]

This will address the TODO at this level anyway.  The IDAC will still need to be
changed to add and remove the ink drop layer only when they are active.  This is
tracked by www.crbug.com/522175 .

+  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(size());
+}
+
 const char* ToolbarButton::GetClassName() const {
   return "ToolbarButton";
 }