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.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_TOOLBAR_TOOLBAR_BUTTON_H_
 #define CHROME_BROWSER_UI_VIEWS_TOOLBAR_TOOLBAR_BUTTON_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "ui/views/animation/ink_drop_host.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/button/label_button.h"
 
 namespace ui {
 class MenuModel;
 }
 
 namespace views {
 class InkDropAnimationController;
 class MenuRunner;
 }
 
 // This class provides basic drawing and mouse-over behavior for buttons
 // appearing in the toolbar.
 class ToolbarButton : public views::LabelButton,
-                      public views::ContextMenuController {
+                      public views::ContextMenuController,
+                      public views::InkDropHost {
  public:
   // Takes ownership of the |model|, which can be null if no menu
   // is to be shown.
   ToolbarButton(views::ButtonListener* listener, ui::MenuModel* model);
   ~ToolbarButton() override;
 
   // Set up basic mouseover border behavior.
   // Should be called before first paint.
   void Init();
 
   // Methods for handling ButtonDropDown-style menus.
   void ClearPendingMenu();
   bool IsMenuShowing() const;
 
   // views::LabelButton:
   gfx::Size GetPreferredSize() const override;
+  void Layout() override;
   bool OnMousePressed(const ui::MouseEvent& event) override;
   bool OnMouseDragged(const ui::MouseEvent& event) override;
   void OnMouseReleased(const ui::MouseEvent& event) override;
   // Showing the drop down results in a MouseCaptureLost, we need to ignore it.
   void OnMouseCaptureLost() override;
   void OnMouseExited(const ui::MouseEvent& event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
   void GetAccessibleState(ui::AXViewState* state) override;
   scoped_ptr<views::LabelButtonBorder> CreateDefaultBorder() const override;
 
   // views::ContextMenuController:
   void ShowContextMenuForView(View* source,
                               const gfx::Point& point,
                               ui::MenuSourceType source_type) override;
 
+  // views::InkDropHost:
+  void AddInkDropLayer(ui::Layer* ink_drop_layer) override;
+  void RemoveInkDropLayer(ui::Layer* ink_drop_layer) override;
+
  protected:
   // Overridden from CustomButton. Returns true if the button should become
   // pressed when a user holds the mouse down over the button. For this
   // implementation, both left and right mouse buttons can trigger a change
   // to the PUSHED state.
   bool ShouldEnterPushedState(const ui::Event& event) override;
 
   // Returns if menu should be shown. Override this to change default behavior.
   virtual bool ShouldShowMenu();
 
   // Function to show the dropdown menu.
   virtual void ShowDropDownMenu(ui::MenuSourceType source_type);
 
+  views::InkDropAnimationController* ink_drop_animation_controller() {
+    return ink_drop_animation_controller_.get();
+  }
+
+  // Performs a layout of the ink drop. i.e. Set's the ink drop's size and/or

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

nit: Set's -> Sets

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

Done.

+  // bounds.
+  virtual void LayoutInkDrop();

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

Would it be more appropriate for this to be pure virtual in InkDropHost? Also,
it may be good to include more details about how this should be implemented and
to include a note to say that any class which owns an InkDropAnimationController
should call this method from within Layout() as you have done in this CL.

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

What is your reasoning to move it to InkDropHost?
I'm hesitant to move LayoutInkDrop to InkDropHost for a couple of:

1) The InkDropHost does not necessarily have to be the same class that owns the
IDAC.  e.g. A container view might be more capable and responsible for defining
the InkDrop's bounds and it's child view would be the host.  e.g. A container
view could own multiple IDAC's because it has to sync some animations between
them for some reason, and its child Views would actually be the InkDropHosts.

2) A class that inherits InkDropHost can easily host more than one ink drop.  It
would be odd if we had to implement InkDropHost::SetInkDropBounds if it was
hosting multiple ink drops.  It will be much more flexible if these two concepts
are not coupled together.

I agree more details and documentation are needed and I was planning to add them
to the InkDropAnimationController once all the details have been
implemented/added.

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

My understanding was that every class which implements IDH will have to specify
logic to lay out its ink drop (and will also have to make a call to
LayoutInkDrop() from its Layout()). So for that reason it felt reasonable to
move that into the interface.
I see. My assumption was that you were intending for a class to own an IDAC if
and only if it implemented IDH.
OK, fair enough.

+
  private:
   // views::LabelButton:
   const char* GetClassName() const override;
 
   // The model that populates the attached menu.
   scoped_ptr<ui::MenuModel> model_;
 
   // Indicates if menu is currently showing.
   bool menu_showing_;
 
   // Y position of mouse when left mouse button is pressed
   int y_position_on_lbuttondown_;
 
   // Menu runner to display drop down menu.
   scoped_ptr<views::MenuRunner> menu_runner_;
 
   // Animation controller for the ink drop ripple effect.
   scoped_ptr<views::InkDropAnimationController> ink_drop_animation_controller_;
 
   // A factory for tasks that show the dropdown context menu for the button.
   base::WeakPtrFactory<ToolbarButton> show_menu_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarButton);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TOOLBAR_TOOLBAR_BUTTON_H_