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

ui/views/controls/menu/menu_controller_unittest.cc

 // Copyright 2014 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_controller.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 136 matching lines @@
     }
   }
 
   int outstanding_touches() const { return outstanding_touches_; }
 
  private:
   int outstanding_touches_;
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
+// A test widget that counts gesture events.
+class GestureTestWidget : public Widget {
+ public:
+  GestureTestWidget() : gesture_count_(0) {}
+
+  void OnGestureEvent(ui::GestureEvent* event) override { gesture_count_++; }
+
+  int gesture_count() const { return gesture_count_; }
+
+ private:
+  int gesture_count_;
+  DISALLOW_COPY_AND_ASSIGN(GestureTestWidget);
+};
+
 #if defined(USE_AURA)
 // A DragDropClient which does not trigger a nested run loop. Instead a
 // callback is triggered during StartDragAndDrop in order to allow testing.
 class TestDragDropClient : public aura::client::DragDropClient {
  public:
   explicit TestDragDropClient(const base::Closure& callback)
       : start_drag_and_drop_callback_(callback), drag_in_progress_(false) {}
   ~TestDragDropClient() override {}
 
   // aura::client::DragDropClient:
@@ skipping 289 matching lines @@
 
   // Causes the |menu_controller_| to begin dragging. Use TestDragDropClient to
   // avoid nesting message loops.
   void StartDrag() {
     const gfx::Point location;
     menu_controller_->state_.item = menu_item()->GetSubmenu()->GetMenuItemAt(0);
     menu_controller_->StartDrag(
         menu_item()->GetSubmenu()->GetMenuItemAt(0)->CreateSubmenu(), location);
   }
 
-  Widget* owner() { return owner_.get(); }
+  GestureTestWidget* owner() { return owner_.get(); }
   ui::test::EventGenerator* event_generator() { return event_generator_.get(); }
   TestMenuItemViewShown* menu_item() { return menu_item_.get(); }
   TestMenuDelegate* menu_delegate() { return menu_delegate_.get(); }
   TestMenuControllerDelegate* menu_controller_delegate() {
     return menu_controller_delegate_.get();
   }
   MenuController* menu_controller() { return menu_controller_; }
   const MenuItemView* pending_state_item() const {
       return menu_controller_->pending_state_.item;
   }
@@ skipping 36 matching lines @@
 
     if (!owner_->IsClosed())
       owner_->RemoveObserver(menu_controller_);
 
     menu_controller_->showing_ = false;
     menu_controller_->owner_ = nullptr;
     delete menu_controller_;
     menu_controller_ = nullptr;
   }
 
+  int CountOwnerOnGestureEvent() { return owner_->gesture_count(); }
+
  private:
   void Init() {
-    owner_.reset(new Widget);
+    owner_ = base::MakeUnique<GestureTestWidget>();
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     owner_->Init(params);
     event_generator_.reset(
         new ui::test::EventGenerator(owner_->GetNativeWindow()));
     owner_->Show();
 
     SetupMenuItem();
     SetupMenuController();
   }
@@ skipping 14 matching lines @@
     menu_controller_->owner_ = owner_.get();
     menu_controller_->showing_ = true;
     menu_controller_->SetSelection(
         menu_item_.get(), MenuController::SELECTION_UPDATE_IMMEDIATELY);
     menu_item_->SetController(menu_controller_);
   }
 
   // Not owned.
   DestructingTestViewsDelegate* test_views_delegate_;
 
-  std::unique_ptr<Widget> owner_;
+  std::unique_ptr<GestureTestWidget> owner_;
   std::unique_ptr<ui::test::EventGenerator> event_generator_;
   std::unique_ptr<TestMenuItemViewShown> menu_item_;
   std::unique_ptr<TestMenuControllerDelegate> menu_controller_delegate_;
   std::unique_ptr<TestMenuDelegate> menu_delegate_;
   MenuController* menu_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuControllerTest);
 };
 
 #if defined(OS_LINUX) && defined(USE_X11)
@@ skipping 533 matching lines @@
   // Nested run
   controller->AddNestedDelegate(nested_delegate.get());
   controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
                   MENU_ANCHOR_TOPLEFT, false, false);
 
   controller->CancelAll();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
+#if !defined(OS_MACOSX)
+TEST_F(MenuControllerTest, PreserveGestureForOwner) {
+  MenuController* controller = menu_controller();
+  MenuItemView* item = menu_item();
+  controller->Run(owner(), nullptr, item, gfx::Rect(),
+                  MENU_ANCHOR_FIXED_BOTTOMCENTER, false, false);
+  SubmenuView* sub_menu = item->GetSubmenu();
+  sub_menu->ShowAt(owner(), gfx::Rect(0, 0, 100, 100), true);
+
+  gfx::Point location(sub_menu->bounds().bottom_left().x(),
+                      sub_menu->bounds().bottom_left().y() + 10);
+  ui::GestureEvent event(location.x(), location.y(), 0, ui::EventTimeForNow(),
+                         ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
+
+  // Gesture events should not be forwarded if the flag is not set.
+  EXPECT_EQ(CountOwnerOnGestureEvent(), 0);
+  EXPECT_FALSE(controller->send_gesture_events_to_owner());
+  controller->OnGestureEvent(sub_menu, &event);
+  EXPECT_EQ(CountOwnerOnGestureEvent(), 0);
+
+  // The menu's owner should receive gestures triggered outside the menu.
+  controller->set_send_gesture_events_to_owner(true);
+  controller->OnGestureEvent(sub_menu, &event);
+  EXPECT_EQ(CountOwnerOnGestureEvent(), 1);
+
+  ui::GestureEvent event2(location.x(), location.y(), 0, ui::EventTimeForNow(),
+                          ui::GestureEventDetails(ui::ET_GESTURE_END));
+
+  controller->OnGestureEvent(sub_menu, &event2);
+  EXPECT_EQ(CountOwnerOnGestureEvent(), 2);
+
+  // ET_GESTURE_END resets the |send_gesture_events_to_owner_| flag, so futher
+  // gesture events should not be sent to the owner.
+  controller->OnGestureEvent(sub_menu, &event2);
+  EXPECT_EQ(CountOwnerOnGestureEvent(), 2);
+}
+#endif  // !defined(OS_MACOSX)
+
 // Tests that a nested menu does not crash when trying to repost events that
 // occur outside of the bounds of the menu. Instead a proper shutdown should
 // occur.
 TEST_F(MenuControllerTest, AsynchronousRepostEvent) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   controller->AddNestedDelegate(nested_delegate.get());
@@ skipping 336 matching lines @@
   ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, release_location,
                                release_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   ProcessMouseReleased(sub_menu, release_event);
 }
 
 #endif  // defined(USE_AURA)
 
 }  // namespace test
 }  // namespace views