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);
+    SetPaintToLayer(true);
     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() {
 }
 
 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();
+}
+
 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);

[Peter Kasting, 2015/08/12 20:04:31]

Nit: Since all these arms call AnimateToState(), this would be simpler if you
can remove the CHECK (see next comment):

  ...
  views::InkDropState state = HIDDEN;
  switch (event->type()) {
    case ui::ET_GESTURE_TAP_DOWN:
      state = views::InkDropState::ACTION_PENDING;
      break;
    case ui::ET_GESTURE_LONG_PRESS:
      state = views::InkDropState::SLOW_ACTION;
      break;
    case ui::ET_GESTURE_TAP:
      state = views::InkDropState::QUICK_ACTION;
      break;
    case ui::ET_GESTURE_END:
    case ui::ET_GESTURE_TAP_CANCEL:
      break;  // Use HIDDEN.
    default:
      return;
  }
  ink_drop_animation_controller_->AnimateToState(state);
}

[bruthig, 2015/08/13 15:15:45]

I don't think your suggestion will work here anyhow, i.e. the ink drop will be
hidden on an ET_GESTURE_SCROLL_BEGIN which is not what we want in this case.
Keep in mind this code is going to be updated as the actual animation states are
flushed out in a subsequent review.

[Peter Kasting, 2015/08/13 18:34:08]

No it won't; see how the "default" case returns rather than allowing fallthrough
to the animate call.
Are you saying you'll be adding more functionality beyond the function call? 
Will it be happening after the function call?  If those aren't both "yes" this
suggestion will still work in the future.  (But see comment below)

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

Whoops, I missed that.  Fixed.

+      CHECK(event->handled()) << "event should be marked handled so that "
+                                 "subsequent gestures are received.";

[Peter Kasting, 2015/08/12 20:04:32]

Are you trying to catch a particular bug with this CHECK?  Normally we avoid
CHECKs in the codebase unless there's a security issue or it's a short-term
thing to track down some kind of bug.

[bruthig, 2015/08/13 15:15:45]

Originally this was suppposed to detect breaking changes to parent classes (and
probably should have been a DCHECK as opposed to a CHECK), however, tdanderson@,
jonross@, and I discussed offline and decided to explicitly set the event as
handled.  This will ensure that the subsequent events in the pipeline are
properly handled and not be dependent on the ancestor classes.

[Peter Kasting, 2015/08/13 18:34:08]

Why not SetHandled() on the other events too?  In any case this deserves a
comment about what it's doing, and especially one to explain why this case
differs from the others if necessary.

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

Done.

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

[Peter Kasting, 2015/08/12 20:04:32]

Nit: Just pass size()

[bruthig, 2015/08/13 15:15:45]

Done.

+}
+
 const char* ToolbarButton::GetClassName() const {
   return "ToolbarButton";
 }