MenuController Do Not SetSelection to Empty Items on Drag

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/single_thread_task_runner.h"
@@ skipping 260 matching lines @@
  public:
   TestMenuItemViewShown(MenuDelegate* delegate) : MenuItemView(delegate) {
     submenu_ = new SubmenuViewShown(this);
   }
   ~TestMenuItemViewShown() override {}
 
   void SetController(MenuController* controller) {
     set_controller(controller);
   }
 
+  void AddEmptyMenusForTest() { AddEmptyMenus(); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(TestMenuItemViewShown);
 };
 
 class MenuControllerTest : public ViewsTestBase {
  public:
   MenuControllerTest() : menu_controller_(nullptr) {
   }
 
   ~MenuControllerTest() override {}
@@ skipping 38 matching lines @@
     // Now that the targeter has been destroyed, expect to exit the menu
     // normally when hitting escape.
     event_generator_->PressKey(ui::VKEY_ESCAPE, 0);
     EXPECT_EQ(MenuController::EXIT_ALL, menu_exit_type());
   }
 
   // Verifies that a non-nested menu fully closes when receiving an escape key.
   void TestAsyncEscapeKey() {
     ui::KeyEvent event(ui::EventType::ET_KEY_PRESSED, ui::VKEY_ESCAPE, 0);
     menu_controller_->OnWillDispatchKeyEvent(&event);
-    EXPECT_EQ(MenuController::EXIT_ALL, menu_exit_type());
   }
 
 #endif  // defined(OS_LINUX) && defined(USE_X11)
 
 #if defined(USE_AURA)
   // Verifies that an open menu receives a cancel event, and closes.
   void TestCancelEvent() {
     EXPECT_EQ(MenuController::EXIT_NONE, menu_controller_->exit_type());
     ui::CancelModeEvent cancel_event;
     event_generator_->Dispatch(&cancel_event);
@@ skipping 102 matching lines @@
         &MenuControllerTest::DestroyMenuController, base::Unretained(this)));
     menu_controller_->ExitAsyncRun();
   }
 
  protected:
   void SetPendingStateItem(MenuItemView* item) {
     menu_controller_->pending_state_.item = item;
     menu_controller_->pending_state_.submenu_open = true;
   }
 
+  void SetState(MenuItemView* item) {
+    menu_controller_->state_.item = item;
+    menu_controller_->state_.submenu_open = true;
+  }
+
   void ResetSelection() {
     menu_controller_->SetSelection(
         nullptr,
         MenuController::SELECTION_EXIT |
         MenuController::SELECTION_UPDATE_IMMEDIATELY);
   }
 
   void IncrementSelection() {
     menu_controller_->IncrementSelection(
         MenuController::INCREMENT_SELECTION_DOWN);
@@ skipping 65 matching lines @@
     menu_controller_->set_is_combobox(is_combobox);
   }
 
   void SetSelectionOnPointerDown(SubmenuView* source,
                                  const ui::LocatedEvent* event) {
     menu_controller_->SetSelectionOnPointerDown(source, event);
   }
 
   // Note that coordinates of events passed to MenuController must be in that of
   // the MenuScrollViewContainer.
+  void ProcessMousePressed(SubmenuView* source, const ui::MouseEvent& event) {
+    menu_controller_->OnMousePressed(source, event);
+  }
+
+  void ProcessMouseDragged(SubmenuView* source, const ui::MouseEvent& event) {
+    menu_controller_->OnMouseDragged(source, event);
+  }
+
   void ProcessMouseMoved(SubmenuView* source, const ui::MouseEvent& event) {
     menu_controller_->OnMouseMoved(source, event);
   }
 
+  void ProcessMouseReleased(SubmenuView* source, const ui::MouseEvent& event) {
+    menu_controller_->OnMouseReleased(source, event);
+  }
+
   void RunMenu() {
 #if defined(USE_AURA)
     std::unique_ptr<MenuPreTargetHandler> menu_pre_target_handler(
         new MenuPreTargetHandler(menu_controller_, owner_.get()));
 #endif
 
     menu_controller_->message_loop_depth_++;
     menu_controller_->RunMessageLoop();
     menu_controller_->message_loop_depth_--;
   }
@@ skipping 13 matching lines @@
   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(); }
   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;
   }
   MenuController::ExitType menu_exit_type() const {
     return menu_controller_->exit_type_;
   }
@@ skipping 74 matching lines @@
     menu_item_->SetController(menu_controller_);
   }
 
   // Not owned.
   DestructingTestViewsDelegate* test_views_delegate_;
 
   std::unique_ptr<Widget> 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<MenuDelegate> menu_delegate_;
+  std::unique_ptr<TestMenuDelegate> menu_delegate_;
   MenuController* menu_controller_;
   TestMenuMessageLoop* test_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuControllerTest);
 };
 
 #if defined(OS_LINUX) && defined(USE_X11)
 // Tests that an event targeter which blocks events will be honored by the menu
 // event dispatcher.
 TEST_F(MenuControllerTest, EventTargeter) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MenuControllerTest::TestEventTargeter,
                             base::Unretained(this)));
   RunMenu();
 }
 
 // Tests that an non-nested menu receiving an escape key will fully shut. This
 // should not crash by attempting to retarget the key to an inner menu.
 TEST_F(MenuControllerTest, AsyncEscapeKey) {
   menu_controller()->SetAsyncRun(true);
   TestAsyncEscapeKey();
+  EXPECT_EQ(MenuController::EXIT_ALL, menu_exit_type());
 }
 
 #endif  // defined(OS_LINUX) && defined(USE_X11)
 
 #if defined(USE_X11)
 // Tests that touch event ids are released correctly. See crbug.com/439051 for
 // details. When the ids aren't managed correctly, we get stuck down touches.
 TEST_F(MenuControllerTest, TouchIdsReleasedCorrectly) {
   TestEventHandler test_event_handler;
   owner()->GetNativeWindow()->GetRootWindow()->AddPreTargetHandler(
@@ skipping 853 matching lines @@
   controller->SetAsyncRun(true);
 
   int mouse_event_flags = 0;
   MenuItemView* run_result =
       controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
                       MENU_ANCHOR_TOPLEFT, false, false, &mouse_event_flags);
   EXPECT_EQ(run_result, nullptr);
   TestDestroyedDuringViewsRelease();
 }
 
+// Tests that when a context menu is opened above an empty menu item, and a
+// right-click occurs over the empty item, that the bottom menu is not hidden,
+// that a request to relaunch the context menu is received, and that
+// subsequently pressing ESC does not crash the browser.
+TEST_F(MenuControllerTest, RepostEventToEmptyMenuItem) {
+  // Setup a submenu. Additionally hook up appropriate Widget and View
+  // containers, with bounds, so that hit testing works.
+  MenuController* controller = menu_controller();
+  controller->SetAsyncRun(true);
+  MenuItemView* base_menu = menu_item();
+  base_menu->SetBounds(0, 0, 200, 200);
+  SubmenuView* base_submenu = base_menu->GetSubmenu();
+  base_submenu->SetBounds(0, 0, 200, 200);
+  base_submenu->ShowAt(owner(), gfx::Rect(0, 0, 200, 200), false);
+  GetMenuHost(base_submenu)
+      ->SetContentsView(base_submenu->GetScrollViewContainer());
+
+  // Build the submenu to have an empty menu item. Additionally hook up
+  // appropriate Widget and View containersm with counds, so that hit testing
+  // works.
+  std::unique_ptr<TestMenuDelegate> sub_menu_item_delegate =
+      base::MakeUnique<TestMenuDelegate>();
+  std::unique_ptr<TestMenuItemViewShown> sub_menu_item =
+      base::MakeUnique<TestMenuItemViewShown>(sub_menu_item_delegate.get());
+  sub_menu_item->AddEmptyMenusForTest();
+  sub_menu_item->SetController(controller);
+  sub_menu_item->SetBounds(0, 50, 50, 50);
+  base_submenu->AddChildView(sub_menu_item.get());
+  SubmenuView* sub_menu_view = sub_menu_item->GetSubmenu();
+  sub_menu_view->SetBounds(0, 50, 50, 50);
+  sub_menu_view->ShowAt(owner(), gfx::Rect(0, 50, 50, 50), false);
+  GetMenuHost(sub_menu_view)
+      ->SetContentsView(sub_menu_view->GetScrollViewContainer());
+
+  // Set that the last selection target was the item which launches the submenu,
+  // as the empty item can never become a target.
+  SetPendingStateItem(sub_menu_item.get());
+
+  // Nest a context menu.
+  std::unique_ptr<TestMenuDelegate> nested_menu_delegate_1 =
+      base::MakeUnique<TestMenuDelegate>();
+  std::unique_ptr<TestMenuItemViewShown> nested_menu_item_1 =
+      base::MakeUnique<TestMenuItemViewShown>(nested_menu_delegate_1.get());
+  nested_menu_item_1->SetBounds(0, 0, 100, 100);
+  nested_menu_item_1->SetController(controller);
+  std::unique_ptr<TestMenuControllerDelegate> nested_controller_delegate_1 =
+      base::MakeUnique<TestMenuControllerDelegate>();
+  controller->AddNestedDelegate(nested_controller_delegate_1.get());
+  int mouse_event_flags = 0;
+  MenuItemView* run_result = controller->Run(
+      owner(), nullptr, nested_menu_item_1.get(), gfx::Rect(150, 50, 100, 100),
+      MENU_ANCHOR_TOPLEFT, true, false, &mouse_event_flags);
+  EXPECT_EQ(run_result, nullptr);
+
+  // Press down outside of the context menu, and within the empty menu item.
+  // This should close the first context menu.
+  gfx::Point press_location(sub_menu_view->bounds().CenterPoint());
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, press_location,
+                             press_location, ui::EventTimeForNow(),
+                             ui::EF_RIGHT_MOUSE_BUTTON, 0);
+  ProcessMousePressed(nested_menu_item_1->GetSubmenu(), press_event);
+  EXPECT_EQ(nested_controller_delegate_1->on_menu_closed_called(), 1);
+  EXPECT_EQ(menu_controller_delegate(), GetCurrentDelegate());
+
+  // While the current state is the menu item which launched the sub menu, cause
+  // a drag in the empty menu item. This should not hide the menu.
+  SetState(sub_menu_item.get());
+  press_location.Offset(-5, 0);
+  ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, press_location,
+                            press_location, ui::EventTimeForNow(),
+                            ui::EF_RIGHT_MOUSE_BUTTON, 0);
+  ProcessMouseDragged(sub_menu_view, drag_event);
+  EXPECT_EQ(menu_delegate()->will_hide_menu_count(), 0);
+
+  // Release the mouse in the empty menu item, triggering a context menu
+  // request.
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, press_location,
+                               press_location, ui::EventTimeForNow(),
+                               ui::EF_RIGHT_MOUSE_BUTTON, 0);
+  ProcessMouseReleased(sub_menu_view, release_event);
+  EXPECT_EQ(sub_menu_item_delegate->show_context_menu_count(), 1);
+  EXPECT_EQ(sub_menu_item_delegate->show_context_menu_source(),
+            sub_menu_item.get());
+
+  // Nest a context menu.
+  std::unique_ptr<TestMenuDelegate> nested_menu_delegate_2 =
+      base::MakeUnique<TestMenuDelegate>();
+  std::unique_ptr<TestMenuItemViewShown> nested_menu_item_2 =
+      base::MakeUnique<TestMenuItemViewShown>(nested_menu_delegate_2.get());
+  nested_menu_item_2->SetBounds(0, 0, 100, 100);
+  nested_menu_item_2->SetController(controller);
+
+  std::unique_ptr<TestMenuControllerDelegate> nested_controller_delegate_2 =
+      base::MakeUnique<TestMenuControllerDelegate>();
+  controller->AddNestedDelegate(nested_controller_delegate_2.get());
+  run_result = controller->Run(
+      owner(), nullptr, nested_menu_item_2.get(), gfx::Rect(150, 50, 100, 100),
+      MENU_ANCHOR_TOPLEFT, true, false, &mouse_event_flags);
+  EXPECT_EQ(run_result, nullptr);
+
+  // The escapce key should only close the nested menu. SelectByChar should not
+  // crash.
+  TestAsyncEscapeKey();
+  EXPECT_EQ(nested_controller_delegate_2->on_menu_closed_called(), 1);
+  EXPECT_EQ(menu_controller_delegate(), GetCurrentDelegate());
+}
+
 #endif  // defined(USE_AURA)
 
 }  // namespace test
 }  // namespace views