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 624 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 994 matching lines @@
     case SHELF_ALIGNMENT_LEFT:
       context_menu_point.SetPoint(shelf_bounds.x() + kShelfSize, point.y());
       break;
     case SHELF_ALIGNMENT_RIGHT:
       context_menu_point.SetPoint(shelf_bounds.right() - kShelfSize, point.y());
       break;
   }
   last_pressed_index_ = -1;
 
   const ShelfItem* item = ShelfItemForView(source);
-  if (!item) {
+  if (!item || item->type == TYPE_APP_LIST) {
     ShellPort::Get()->ShowContextMenu(context_menu_point, source_type);
     return;
   }
 
   std::unique_ptr<ui::MenuModel> context_menu_model(
       Shell::Get()->shell_delegate()->CreateContextMenu(wm_shelf_, item));
   if (!context_menu_model)
     return;
 
   context_menu_id_ = item ? item->id : ShelfID();
@@ skipping 10 matching lines @@
   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;
+
+  // Shelf items can only be dragged if the shelf is not autohide.

[msw, 2017/05/17 23:03:30]

nit: s/autohide/in auto-hide/ (or 'is not auto-hidden')

[minch1, 2017/05/26 23:01:11]

update the comment according to next comment.

+  if (wm_shelf()->auto_hide_behavior() == SHELF_AUTO_HIDE_BEHAVIOR_NEVER)

[msw, 2017/05/17 23:03:30]

It's not clear to me how the comment above relates to this code... can you
explain this a bit more?

[minch1, 2017/05/18 17:42:57]

We cannot drag the shelf items when the shelf is auto-hidden (for the SCROLL
events, before open the context menu.) I want to keep the same behavior as
SCROLL events. So, if shelf is auto-hidden, we will not transfer events from
owner to the menu host. Then, shelf items can not be dragged after the context
menu is created.
Set |run_types| here, then, in menu_runner_impl.cc will
|set_owner_needs_gesture_events| according to the |run_types|. Then, in MenuHost
we can know whether we need to transfer events or not.

[msw, 2017/05/18 20:42:20]

Why won't the shelf itself correctly ignore drag touch events when it's in an
auto-hide mode (ie. we shouldn't change the menu's run type based on shelf
state, the shelf itself should handle/ignore gesture events correctly depending
on its internal state). If you need to keep this, add an explanatory comment in
code, like "Shelf items can not be dragged if the shelf is not autohide."

[minch1, 2017/05/26 23:01:11]

Done.

+    run_types |= views::MenuRunner::OWNER_NEEDS_DRAG;
+
   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.
   WmWindow* window = WmWindow::Get(source->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 32 matching lines @@
   }
 
   // NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
   launcher_menu_runner_->RunMenuAt(source->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 66 matching lines @@
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash