Make shelf item can be dragged when context menu is opened.

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_constants.h"
@@ skipping 654 matching lines @@
   // 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 (IsShowingMenu())
+    launcher_menu_runner_->Cancel();
   if (drag_view_)
     return;
 
   int index = view_model_->GetIndexOfView(view);
   if (index == -1 || view_model_->view_size() <= 1)
     return;  // View is being deleted, ignore request.
 
   if (view == GetAppListButton())
     return;  // View is not draggable, ignore request.
 
@@ skipping 1041 matching lines @@
     }
   }
   // The menu clears |scoped_root_window_for_new_windows_| in OnMenuClosed.
   if (!IsShowingMenu())
     scoped_root_window_for_new_windows_.reset();
 }
 
 void ShelfView::AfterGetContextMenuItems(
     const ShelfID& shelf_id,
     const gfx::Point& point,
+    views::View* source,
     ui::MenuSourceType source_type,
     std::vector<mojom::MenuItemPtr> menu_items) {
   context_menu_id_ = shelf_id;
   const int64_t display_id = GetDisplayIdForView(this);
   ShowMenu(base::MakeUnique<ShelfContextMenuModel>(
                std::move(menu_items), model_->GetShelfItemDelegate(shelf_id),
                display_id),
-           nullptr /* source */, point, true /* context_menu */, source_type,
+           source, point, true /* context_menu */, source_type,
            nullptr /* ink_drop */);
 }
 
 void ShelfView::ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
   gfx::Point context_menu_point = point;
   aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
 
   // Align the context menu to the edge of the shelf for touch events.
@@ skipping 27 matching lines @@
     ShowMenu(base::MakeUnique<ShelfContextMenuModel>(
                  std::vector<mojom::MenuItemPtr>(), nullptr, display_id),
              source, context_menu_point, true, source_type, nullptr);
     return;
   }
 
   // Get any custom entries; show the context menu in AfterGetContextMenuItems.
   model_->GetShelfItemDelegate(item->id)->GetContextMenuItems(
       display_id, base::Bind(&ShelfView::AfterGetContextMenuItems,
                              weak_factory_.GetWeakPtr(), item->id,
-                             context_menu_point, source_type));
+                             context_menu_point, source, source_type));
 }
 
 void ShelfView::ShowMenu(std::unique_ptr<ui::MenuModel> menu_model,
                          views::View* source,
                          const gfx::Point& click_point,
                          bool context_menu,
                          ui::MenuSourceType source_type,
                          views::InkDrop* ink_drop) {
   menu_model_ = std::move(menu_model);
   menu_model_adapter_.reset(new views::MenuModelAdapter(
       menu_model_.get(),
       base::Bind(&ShelfView::OnMenuClosed, base::Unretained(this), ink_drop)));
 
   closing_event_time_ = base::TimeTicks();
   int run_types = 0;
   if (context_menu)
     run_types |=
         views::MenuRunner::CONTEXT_MENU | views::MenuRunner::FIXED_ANCHOR;
+
+  // Selected shelf items with context menu opened can only be dragged if the
+  // shelf is not in auto-hide.
+  const ShelfItem* item = ShelfItemForView(source);
+  if (context_menu && item && item->type != TYPE_APP_LIST &&
+      shelf()->auto_hide_behavior() == SHELF_AUTO_HIDE_BEHAVIOR_NEVER) {
+    run_types |= views::MenuRunner::SEND_GESTURE_EVENTS_TO_OWNER;
+  }
+
   launcher_menu_runner_.reset(
       new views::MenuRunner(menu_model_adapter_->CreateMenu(), run_types));
 
   // Place new windows on the same display as the button that spawned the menu.
   aura::Window* window = GetWidget()->GetNativeWindow();
   scoped_root_window_for_new_windows_.reset(
       new ScopedRootWindowForNewWindows(window->GetRootWindow()));
 
   views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
   gfx::Rect anchor = gfx::Rect(click_point, gfx::Size());
@@ skipping 33 matching lines @@
   }
 
   // NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
   launcher_menu_runner_->RunMenuAt(GetWidget(), nullptr, anchor, menu_alignment,
                                    source_type);
 }
 
 void ShelfView::OnMenuClosed(views::InkDrop* ink_drop) {
   context_menu_id_ = ShelfID();
 
-  // Hide the hide overflow bubble after showing a context menu for its items.
-  if (owner_overflow_bubble_)
-    owner_overflow_bubble_->Hide();
-
   closing_event_time_ = launcher_menu_runner_->closing_event_time();
 
   if (ink_drop)
     ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
 
   launcher_menu_runner_.reset();
   menu_model_adapter_.reset();
   menu_model_.reset();
   scoped_root_window_for_new_windows_.reset();
 
@@ skipping 72 matching lines @@
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash