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

ui/views/controls/menu/menu_host.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 "ui/views/controls/menu/menu_host.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
@@ skipping 60 matching lines @@
     window_->RemoveObserver(this);
     window_ = nullptr;
   }
 
   MenuController* menu_controller_;
   SubmenuView* submenu_;
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(PreMenuEventDispatchHandler);
 };
+
+void TransferGesture(Widget* source, Widget* target) {
+  ui::GestureRecognizer::Get()->TransferEventsTo(
+      source->GetNativeView(), target->GetNativeView(),
+      ui::GestureRecognizer::ShouldCancelTouches::DontCancel);
+}
 #endif  // OS_MACOSX
 
 }  // namespace internal
 
 ////////////////////////////////////////////////////////////////////////////////
 // MenuHost, public:
 
 MenuHost::MenuHost(SubmenuView* submenu)
     : submenu_(submenu),
       destroying_(false),
       ignore_capture_lost_(false) {
   set_auto_release_capture(false);
 }
 
 MenuHost::~MenuHost() {
+  if (owner_)
+    owner_->RemoveObserver(this);
 }
 
 void MenuHost::InitMenuHost(Widget* parent,
                             const gfx::Rect& bounds,
                             View* contents_view,
                             bool do_capture) {
   TRACE_EVENT0("views", "MenuHost::InitMenuHost");
   Widget::InitParams params(Widget::InitParams::TYPE_MENU);
   const MenuController* menu_controller =
       submenu_->GetMenuItem()->GetMenuController();
@@ skipping 14 matching lines @@
   // revert this change once http://crbug.com/125248 is fixed.
   params.force_software_compositing = true;
 #endif
   Init(params);
 
 #if !defined(OS_MACOSX)
   pre_dispatch_handler_.reset(new internal::PreMenuEventDispatchHandler(
       menu_controller, submenu_, GetNativeView()));
 #endif
 
+  if (owner_)
+    owner_->RemoveObserver(this);
+  owner_ = parent;
+  if (owner_)
+    owner_->AddObserver(this);
+
   SetContentsView(contents_view);
   ShowMenuHost(do_capture);
 }
 
 bool MenuHost::IsMenuHostVisible() {
   return IsVisible();
 }
 
 void MenuHost::ShowMenuHost(bool do_capture) {
   // Doing a capture may make us get capture lost. Ignore it while we're in the
   // process of showing.
   base::AutoReset<bool> reseter(&ignore_capture_lost_, true);
   ShowInactive();
   if (do_capture) {
+#if !defined(OS_MACOSX)
+    MenuController* menu_controller =
+        submenu_->GetMenuItem()->GetMenuController();
+    if (menu_controller && menu_controller->send_gesture_events_to_owner()) {
+      // TransferGesture when owner needs gesture events so that the incoming
+      // touch events after MenuHost is created are properly translated into
+      // gesture events instead of being dropped.
+      internal::TransferGesture(owner_, this);
+    } else {
+      ui::GestureRecognizer::Get()->CancelActiveTouchesExcept(nullptr);
+    }
+#else   // defined(OS_MACOSX)
     // Cancel existing touches, so we don't miss some touch release/cancel
     // events due to the menu taking capture.
     ui::GestureRecognizer::Get()->CancelActiveTouchesExcept(nullptr);
+#endif  // !defined(OS_MACOSX)
     native_widget_private()->SetCapture();
   }
 }
 
 void MenuHost::HideMenuHost() {
+#if !defined(OS_MACOSX)
+  MenuController* menu_controller =
+      submenu_->GetMenuItem()->GetMenuController();
+  if (owner_ && menu_controller &&
+      menu_controller->send_gesture_events_to_owner()) {
+    internal::TransferGesture(this, owner_);
+  }
+#endif  // !defined(OS_MACOSX)
   ignore_capture_lost_ = true;
   ReleaseMenuHostCapture();
   Hide();
   ignore_capture_lost_ = false;
 }
 
 void MenuHost::DestroyMenuHost() {
   HideMenuHost();
   destroying_ = true;
   static_cast<MenuHostRootView*>(GetRootView())->ClearSubmenu();
 #if !defined(OS_MACOSX)
   pre_dispatch_handler_.reset();
 #endif
   Close();
 }
 
 void MenuHost::SetMenuHostBounds(const gfx::Rect& bounds) {
   SetBounds(bounds);
 }
 
 void MenuHost::ReleaseMenuHostCapture() {
   if (native_widget_private()->HasCapture())
     native_widget_private()->ReleaseCapture();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// MenuHost, Widget overrides:
+// MenuHost, private:
 
 internal::RootView* MenuHost::CreateRootView() {
   return new MenuHostRootView(this, submenu_);
 }
 
 void MenuHost::OnMouseCaptureLost() {
   if (destroying_ || ignore_capture_lost_)
     return;
   MenuController* menu_controller =
       submenu_->GetMenuItem()->GetMenuController();
@@ skipping 49 matching lines @@
       menu_delegate ? menu_delegate->ShouldCloseOnDragComplete() : should_close;
   }
   menu_controller->OnDragComplete(should_close);
 
   // We may have lost capture in the drag and drop, but are remaining open.
   // Return capture so we get MouseCaptureLost events.
   if (!should_close)
     native_widget_private()->SetCapture();
 }
 
+void MenuHost::OnWidgetDestroying(Widget* widget) {
+  DCHECK_EQ(owner_, widget);
+  owner_->RemoveObserver(this);
+  owner_ = nullptr;
+}
+
 }  // namespace views