Add MD ink drop ripple to shelf app items

ash/shelf/shelf_view.h

 // Copyright (c) 2012 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 ASH_SHELF_SHELF_VIEW_H_
 #define ASH_SHELF_SHELF_VIEW_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_model_observer.h"
 #include "ash/shelf/shelf_button_pressed_metric_tracker.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "ui/app_list/views/app_list_drag_and_drop_host.h"
 #include "ui/views/animation/bounds_animator_observer.h"
+#include "ui/views/animation/ink_drop_state.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/view.h"
 #include "ui/views/view_model.h"
 
 namespace ui {
 class MenuModel;
 }
 
@@ skipping 19 matching lines @@
 class ShelfViewTestAPI;
 }
 
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT;
 
 class ASH_EXPORT ShelfView : public views::View,
                              public ShelfModelObserver,
-                             public views::ButtonListener,

[James Cook, 2016/06/13 19:55:35]

optional: You could also introduce an InkDropButtonListener class that has the
ButtonPressed() signature you need. That would reduce the amount of coupling
with ShelfView and provide an example of what you want ButtonListener to look
like eventually.

[mohsen, 2016/06/14 06:24:38]

Good idea. Done.

                              public views::ContextMenuController,
                              public views::FocusTraversable,
                              public views::BoundsAnimatorObserver,
                              public app_list::ApplicationDragAndDropHost {
  public:
   ShelfView(ShelfModel* model,
             ShelfDelegate* delegate,
             WmShelf* wm_shelf,
             Shelf* shelf);
   ~ShelfView() override;
@@ skipping 59 matching lines @@
                            const gfx::Vector2d& cursor_offset_from_center,
                            float scale_factor) override;
   void UpdateDragIconProxy(
       const gfx::Point& location_in_screen_coordinates) override;
   void DestroyDragIconProxy() override;
   bool StartDrag(const std::string& app_id,
                  const gfx::Point& location_in_screen_coordinates) override;
   bool Drag(const gfx::Point& location_in_screen_coordinates) override;
   void EndDrag(bool cancel) override;
 
+  // Returns true if the event on the shelf item is not going to activate the
+  // item. Used to determine whether a pending ink drop should be shown or not.
+  bool ShouldIgnoreEventOnButton(views::View* view, const ui::Event& event);

[James Cook, 2016/06/13 19:55:35]

Consider inverting the boolean sense of this and calling it
ShouldEventActivateButton() or something similar.

[mohsen, 2016/06/14 06:24:38]

Done.

+
   // The shelf buttons use the Pointer interface to enable item reordering.
   enum Pointer { NONE, DRAG_AND_DROP, MOUSE, TOUCH };
   void PointerPressedOnButton(views::View* view,
                               Pointer pointer,
                               const ui::LocatedEvent& event);
   void PointerDraggedOnButton(views::View* view,
                               Pointer pointer,
                               const ui::LocatedEvent& event);
   void PointerReleasedOnButton(views::View* view,
                                Pointer pointer,
                                bool canceled);
 
+  // TODO(mohsen): |ink_drop| is used to do appropriate ink drop animation based
+  // on the action performed. A better approach would be to return a value
+  // indicating the type of action performed such that the button can animate
+  // the ink drop. Currently it is not possible because showing menu is
+  // synchronous and blocks the call. Fix this after menu is converted to

[James Cook, 2016/06/13 19:55:35]

Are you actually planning to convert menus to be async? Everywhere or just in
the shelf? If that's not actually on the radar for someone I would remove that
part of the comment.

[mohsen, 2016/06/14 06:24:38]

Yes, there is a plan to convert all menus to be async.

+  // asynchronous. Long-term, the return value can be merged into
+  // ButtonListener.
+  void ButtonPressed(views::Button* sender,
+                     const ui::Event& event,
+                     views::InkDrop* ink_drop);
+
   // Return the view model for test purposes.
   const views::ViewModel* view_model_for_test() const {
     return view_model_.get();
   }
 
  private:
   friend class ash::test::ShelfViewTestAPI;
 
   class FadeOutAnimationDelegate;
   class StartFadeAnimationDelegate;
@@ skipping 107 matching lines @@
 
   // Overridden from ui::EventHandler:
   void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from ShelfModelObserver:
   void ShelfItemAdded(int model_index) override;
   void ShelfItemRemoved(int model_index, ShelfID id) override;
   void ShelfItemChanged(int model_index, const ShelfItem& old_item) override;
   void ShelfItemMoved(int start_index, int target_index) override;
 
-  // Overridden from views::ButtonListener:
-  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
-
   // Show a list of all running items for this shelf |item|; it only shows a
   // menu if there are multiple running items. |source| specifies the view
   // responsible for showing the menu, and the bubble will point towards it.
   // The |event_flags| are the flags of the event which triggered this menu.
-  void ShowListMenuForView(const ShelfItem& item,
+  // Returns |true| if a menu is shown.
+  bool ShowListMenuForView(const ShelfItem& item,
                            views::View* source,
-                           const ui::Event& event);
+                           const ui::Event& event,
+                           views::InkDrop* ink_drop);
 
   // Overridden from views::ContextMenuController:
   void ShowContextMenuForView(views::View* source,
                               const gfx::Point& point,
                               ui::MenuSourceType source_type) override;
 
   // Show either a context or normal click menu of given |menu_model|.
   // If |context_menu| is set, the displayed menu is a context menu and not
   // a menu listing one or more running applications.
   // The |click_point| is only used for |context_menu|'s.
@@ skipping 132 matching lines @@
   bool overflow_mode_;
 
   // Holds a pointer to main ShelfView when a ShelfView is in overflow mode.
   ShelfView* main_shelf_;
 
   // True when ripped item from overflow bubble is entered into Shelf.
   bool dragged_off_from_overflow_to_shelf_;
 
   // True if the event is a repost event from a event which has just closed the
   // menu of the same shelf item.
-  bool is_repost_event_;
+  bool is_repost_event_on_same_item_;
 
   // Record the index for the last pressed shelf item. This variable is used to
   // check if a repost event occurs on the same shelf item as previous one. If
   // so, the repost event should be ignored.
   int last_pressed_index_;
 
   // Tracks UMA metrics based on shelf button press actions.
   ShelfButtonPressedMetricTracker shelf_button_pressed_metric_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfView);
 };
 
 }  // namespace ash
 
 #endif  // ASH_SHELF_SHELF_VIEW_H_