Add MD ink drop ripple to shelf app items

ash/shelf/shelf_view.cc

 // 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.
 
 #include "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/ash_switches.h"
@@ skipping 51 matching lines @@
 namespace ash {
 
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM = 0;
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT = 1;
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT = 2;
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT = 3;
 
 // Default amount content is inset on the left edge.
 const int kDefaultLeadingInset = 8;
 
-// Minimum distance before drag starts.
-const int kMinimumDragDistance = 8;
-
 // Additional spacing for the left and right side of icons.
 const int kHorizontalIconSpacing = 2;
 
 // Inset for items which do not have an icon.
 const int kHorizontalNoIconInsetSpacing =
     kHorizontalIconSpacing + kDefaultLeadingInset;
 
 // The proportion of the shelf space reserved for non-panel icons. Panels
 // may flow into this space but will be put into the overflow bubble if there
 // is contention for the space.
@@ skipping 270 matching lines @@
     view_->layer()->SetOpacity(1.0f);
   }
 
  private:
   ShelfView* shelf_view_;
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
+// static
+const int ShelfView::kMinimumDragDistance = 8;
+
 ShelfView::ShelfView(ShelfModel* model,
                      ShelfDelegate* delegate,
                      WmShelf* wm_shelf,
                      Shelf* shelf)
     : model_(model),
       delegate_(delegate),
       wm_shelf_(wm_shelf),
       shelf_(shelf),
       view_model_(new views::ViewModel),
       first_visible_index_(0),
@@ skipping 12 matching lines @@
       got_deleted_(nullptr),
       drag_and_drop_item_pinned_(false),
       drag_and_drop_shelf_id_(0),
       drag_replaced_view_(nullptr),
       dragged_off_shelf_(false),
       snap_back_from_rip_off_view_(nullptr),
       item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       overflow_mode_(false),
       main_shelf_(nullptr),
       dragged_off_from_overflow_to_shelf_(false),
-      is_repost_event_(false),
+      is_repost_event_on_same_item_(false),
       last_pressed_index_(-1) {
   DCHECK(model_);
   DCHECK(wm_shelf_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
 }
 
 ShelfView::~ShelfView() {
@@ skipping 303 matching lines @@
       // to animate back to its correct location.
       AnimateToIdealBounds();
     } else {
       drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
     }
   }
 
   drag_and_drop_shelf_id_ = 0;
 }
 
+bool ShelfView::ShouldEventActivateButton(View* view, const ui::Event& event) {
+  if (dragging())
+    return false;
+
+  // Ignore if we are already in a pointer event sequence started with a repost
+  // event on the same shelf item. See crbug.com/343005 for more detail.
+  if (is_repost_event_on_same_item_)
+    return false;
+
+  // Don't activate the item twice on double-click. Otherwise the window starts
+  // animating open due to the first click, then immediately minimizes due to
+  // the second click. The user most likely intended to open or minimize the
+  // item once, not do both.
+  if (event.flags() & ui::EF_IS_DOUBLE_CLICK)
+    return false;
+
+  // Ignore if this is a repost event on the last pressed shelf item.
+  int index = view_model_->GetIndexOfView(view);
+  if (index == -1)
+    return false;
+  return !IsRepostEvent(event) || last_pressed_index_ != index;
+}
+
 void ShelfView::PointerPressedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   if (drag_view_)
     return;
 
   int index = view_model_->GetIndexOfView(view);
-  if (index == -1)
-    return;
+  if (index == -1 || view_model_->view_size() <= 1)
+    return;  // View is being deleted, ignore request.
 
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(model_->items()[index].id);
-  if (view_model_->view_size() <= 1 || !item_delegate->IsDraggable())
-    return;  // View is being deleted or not draggable, ignore request.
+  if (!item_delegate->IsDraggable())
+    return;  // View is not draggable, ignore request.
 
   // Only when the repost event occurs on the same shelf item, we should ignore
   // the call in ShelfView::ButtonPressed(...).
-  is_repost_event_ = IsRepostEvent(event) && (last_pressed_index_ == index);
+  is_repost_event_on_same_item_ =
+      IsRepostEvent(event) && (last_pressed_index_ == index);
 
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   drag_view_ = static_cast<ShelfButton*>(view);
   drag_origin_ = gfx::Point(event.x(), event.y());
   UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
                             shelf_->SelectValueForShelfAlignment(
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT),
                             SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
 }
 
 void ShelfView::PointerDraggedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   // To prepare all drag types (moving an item in the shelf and dragging off),
   // we should check the x-axis and y-axis offset.
   if (!dragging() && drag_view_ &&
       ((std::abs(event.x() - drag_origin_.x()) >= kMinimumDragDistance) ||
        (std::abs(event.y() - drag_origin_.y()) >= kMinimumDragDistance))) {
     PrepareForDrag(pointer, event);
   }
   if (drag_pointer_ == pointer)
     ContinueDrag(event);
 }
 
 void ShelfView::PointerReleasedOnButton(views::View* view,
                                         Pointer pointer,
                                         bool canceled) {
-  // Reset |is_repost_event| to false.
-  is_repost_event_ = false;
+  is_repost_event_on_same_item_ = false;
 
   if (canceled) {
     CancelDrag(-1);
   } else if (drag_pointer_ == pointer) {
     FinalizeRipOffDrag(false);
     drag_pointer_ = NONE;
     AnimateToIdealBounds();
   }
   // If the drag pointer is NONE, no drag operation is going on and the
   // drag_view can be released.
@@ skipping 210 matching lines @@
 views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
   views::View* view = nullptr;
   switch (item.type) {
     case TYPE_BROWSER_SHORTCUT:
     case TYPE_APP_SHORTCUT:
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
     case TYPE_DIALOG:
     case TYPE_APP_PANEL:
     case TYPE_IME_MENU: {
-      ShelfButton* button = new ShelfButton(this);
+      ShelfButton* button = new ShelfButton(this, this);
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
-      view = new AppListButton(this);
+      view = new AppListButton(this, this);
       break;
     }
 
     case TYPE_UNDEFINED:
       return nullptr;
   }
 
   view->set_context_menu_controller(this);
   ConfigureChildView(view);
   return view;
@@ skipping 23 matching lines @@
   ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[start_drag_index_].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // Move the view to the front so that it appears on top of other views.
   ReorderChildView(drag_view_, -1);
   bounds_animator_->StopAnimatingView(drag_view_);
+
+  drag_view_->OnDragStarted();
 }
 
 void ShelfView::ContinueDrag(const ui::LocatedEvent& event) {
   // Due to a syncing operation the application might have been removed.
   // Bail if it is gone.
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
 
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(model_->items()[current_index].id);
@@ skipping 605 matching lines @@
 void ShelfView::ShelfItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
   // When cancelling a drag due to a shelf item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
-void ShelfView::ButtonPressed(views::Button* sender, const ui::Event& event) {
-  // Do not handle mouse release during drag.
-  if (dragging())
-    return;
-
+void ShelfView::ButtonPressed(views::Button* sender,
+                              const ui::Event& event,
+                              views::InkDrop* ink_drop) {
   if (sender == overflow_button_) {
     ToggleOverflowBubble();
     shelf_button_pressed_metric_tracker_.ButtonPressed(
         event, sender, ShelfItemDelegate::kNoAction);
     return;
   }
 
-  int view_index = view_model_->GetIndexOfView(sender);
-  // May be -1 while in the process of animating closed.
-  if (view_index == -1)
-    return;
-
-  // If the menu was just closed by the same event as this one, we ignore
-  // the call and don't open the menu again. See crbug.com/343005 for more
-  // detail.
-  if (is_repost_event_)
+  // None of the checks in ShouldEventActivateButton() affects overflow button.
+  // So, it is safe to be checked after handling overflow button.
+  if (!ShouldEventActivateButton(sender, event))
     return;
 
   // Record the index for the last pressed shelf item.
-  last_pressed_index_ = view_index;
-
-  // Don't activate the item twice on double-click. Otherwise the window starts
-  // animating open due to the first click, then immediately minimizes due to
-  // the second click. The user most likely intended to open or minimize the
-  // item once, not do both.
-  if (event.flags() & ui::EF_IS_DOUBLE_CLICK)
-    return;
+  last_pressed_index_ = view_model_->GetIndexOfView(sender);
+  DCHECK_LT(-1, last_pressed_index_);
 
   {
     ScopedTargetRootWindow scoped_target(
         sender->GetWidget()->GetNativeView()->GetRootWindow());
     // Slow down activation animations if shift key is pressed.
     std::unique_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
     if (event.IsShiftDown()) {
       slowing_animations.reset(new ui::ScopedAnimationDurationScaleMode(
-            ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
+          ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
     }
 
     // Collect usage statistics before we decide what to do with the click.
-    switch (model_->items()[view_index].type) {
+    switch (model_->items()[last_pressed_index_].type) {
       case TYPE_APP_SHORTCUT:
       case TYPE_WINDOWED_APP:
       case TYPE_PLATFORM_APP:
       case TYPE_BROWSER_SHORTCUT:
         Shell::GetInstance()->metrics()->RecordUserMetricsAction(
             UMA_LAUNCHER_CLICK_ON_APP);
         break;
 
       case TYPE_APP_LIST:
         Shell::GetInstance()->metrics()->RecordUserMetricsAction(
             UMA_LAUNCHER_CLICK_ON_APPLIST_BUTTON);
         break;
 
       case TYPE_APP_PANEL:
       case TYPE_DIALOG:
       case TYPE_IME_MENU:
         break;
 
       case TYPE_UNDEFINED:
         NOTREACHED() << "ShelfItemType must be set.";
         break;
     }
 
     ShelfItemDelegate::PerformedAction performed_action =
-        item_manager_->GetShelfItemDelegate(model_->items()[view_index].id)
+        item_manager_
+            ->GetShelfItemDelegate(model_->items()[last_pressed_index_].id)
             ->ItemSelected(event);
 
     shelf_button_pressed_metric_tracker_.ButtonPressed(event, sender,
                                                        performed_action);
 
-    if (performed_action != ShelfItemDelegate::kNewWindowCreated)
-      ShowListMenuForView(model_->items()[view_index], sender, event);
+    if (performed_action == ShelfItemDelegate::kNewWindowCreated ||
+        !ShowListMenuForView(model_->items()[last_pressed_index_], sender,
+                             event, ink_drop)) {
+      ink_drop->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
+    }
   }
 }
 
-void ShelfView::ShowListMenuForView(const ShelfItem& item,
+bool ShelfView::ShowListMenuForView(const ShelfItem& item,
                                     views::View* source,
-                                    const ui::Event& event) {
+                                    const ui::Event& event,
+                                    views::InkDrop* ink_drop) {
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(item.id);
   std::unique_ptr<ui::MenuModel> list_menu_model(
       item_delegate->CreateApplicationMenu(event.flags()));
 
   // Make sure we have a menu and it has at least two items in addition to the
   // application title and the 3 spacing separators.
   if (!list_menu_model.get() || list_menu_model->GetItemCount() <= 5)
-    return;
+    return false;
 
+  ink_drop->AnimateToState(views::InkDropState::ACTIVATED);
   context_menu_id_ = item.id;
   ShowMenu(list_menu_model.get(), source, gfx::Point(), false,
            ui::GetMenuSourceTypeForEvent(event));
+  // Menu is run synchronously, the menu is closed now and we need to go to
+  // the deactivated state.
+  ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
+  return true;
 }
 
 void ShelfView::ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
+  last_pressed_index_ = -1;
+
   const ShelfItem* item = ShelfItemForView(source);
   if (!item) {
     Shell::GetInstance()->ShowContextMenu(point, source_type);
     return;
   }
 
   std::unique_ptr<ui::MenuModel> context_menu_model(
       Shell::GetInstance()->delegate()->CreateContextMenu(wm_shelf_, item));
   if (!context_menu_model)
     return;
@@ skipping 89 matching lines @@
       }
       snap_back_from_rip_off_view_ = nullptr;
     }
   }
 }
 
 bool ShelfView::IsRepostEvent(const ui::Event& event) {
   if (closing_event_time_.is_null())
     return false;
 
-  base::TimeTicks last_closing_event_time = closing_event_time_;
-  closing_event_time_ = base::TimeTicks();
   // If the current (press down) event is a repost event, the time stamp of
   // these two events should be the same.
-  return last_closing_event_time == event.time_stamp();
+  return closing_event_time_ == event.time_stamp();
 }
 
 const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
   const int view_index = view_model_->GetIndexOfView(view);
   return (view_index < 0) ? nullptr : &(model_->items()[view_index]);
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash