Turn Bookmark Menus Async

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/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/null_event_targeter.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/views/controls/menu/menu_controller_delegate.h"
 #include "ui/views/controls/menu/menu_delegate.h"
+#include "ui/views/controls/menu/menu_host.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_message_loop.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/test/menu_test_utils.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
-#include "ui/views/controls/menu/menu_key_event_handler.h"
+#include "ui/views/controls/menu/menu_pre_target_handler.h"
 #endif
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #undef Bool
 #undef None
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 namespace views {
@@ skipping 108 matching lines @@
   explicit TestMenuMessageLoop(std::unique_ptr<MenuMessageLoop> original);
   ~TestMenuMessageLoop() override;
 
   bool is_running() const { return is_running_; }
 
   // MenuMessageLoop:
   void QuitNow() override;
 
  private:
   // MenuMessageLoop:
-  void Run(MenuController* controller,
-           Widget* owner,
-           bool nested_menu) override;
-  void ClearOwner() override;
+  void Run() override;
 
   std::unique_ptr<MenuMessageLoop> original_;
   bool is_running_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMenuMessageLoop);
 };
 
 TestMenuMessageLoop::TestMenuMessageLoop(
     std::unique_ptr<MenuMessageLoop> original)
     : original_(std::move(original)) {
   DCHECK(original_);
 }
 
 TestMenuMessageLoop::~TestMenuMessageLoop() {}
 
-void TestMenuMessageLoop::Run(MenuController* controller,
-                              Widget* owner,
-                              bool nested_menu) {
+void TestMenuMessageLoop::Run() {
   is_running_ = true;
-  original_->Run(controller, owner, nested_menu);
+  original_->Run();
 }
 
 void TestMenuMessageLoop::QuitNow() {
   is_running_ = false;
   original_->QuitNow();
 }
 
-void TestMenuMessageLoop::ClearOwner() {
-  original_->ClearOwner();
-}
-
 }  // namespace
 
 class TestMenuItemViewShown : public MenuItemView {
  public:
   TestMenuItemViewShown(MenuDelegate* delegate) : MenuItemView(delegate) {
     submenu_ = new SubmenuViewShown(this);
   }
   ~TestMenuItemViewShown() override {}
 
   void SetController(MenuController* controller) {
@@ skipping 42 matching lines @@
       event_generator_->PressKey(ui::VKEY_ESCAPE, 0);
       EXPECT_EQ(MenuController::EXIT_NONE, menu_exit_type());
     }
     // 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_OUTERMOST, 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);
+    EXPECT_EQ(MenuController::EXIT_ALL, menu_controller_->exit_type());
+  }
+#endif  // defined(USE_AURA)
+
   void TestAsynchronousNestedExitAll() {
     ASSERT_TRUE(test_message_loop_->is_running());
 
     std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
         new TestMenuControllerDelegate());
 
     menu_controller()->AddNestedDelegate(nested_delegate.get());
     menu_controller()->SetAsyncRun(true);
 
     int mouse_event_flags = 0;
@@ skipping 101 matching lines @@
   }
 
   internal::MenuControllerDelegate* GetCurrentDelegate() {
     return menu_controller_->delegate_;
   }
 
   bool IsAsyncRun() { return menu_controller_->async_run_; }
 
   bool IsShowing() { return menu_controller_->showing_; }
 
+  MenuHost* GetMenuHost(SubmenuView* submenu) { return submenu->host_; }
+
+  void MenuHostOnDragWillStart(MenuHost* host) { host->OnDragWillStart(); }
+
+  void MenuHostOnDragComplete(MenuHost* host) { host->OnDragComplete(); }
+
   void SelectByChar(base::char16 character) {
     menu_controller_->SelectByChar(character);
   }
 
   void SetDropMenuItem(MenuItemView* target,
                        MenuDelegate::DropPosition position) {
     menu_controller_->SetDropMenuItem(target, position);
   }
 
   void SetIsCombobox(bool is_combobox) {
     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 ProcessMouseMoved(SubmenuView* source, const ui::MouseEvent& event) {
     menu_controller_->OnMouseMoved(source, event);
   }
 
   void RunMenu() {
 #if defined(USE_AURA)
-    std::unique_ptr<MenuKeyEventHandler> key_event_handler(
-        new MenuKeyEventHandler);
+    std::unique_ptr<MenuPreTargetHandler> menu_pre_target_handler(
+        new MenuPreTargetHandler(menu_controller_, owner_.get()));
 #endif
 
     menu_controller_->message_loop_depth_++;
-    menu_controller_->RunMessageLoop(false);
+    menu_controller_->RunMessageLoop();
     menu_controller_->message_loop_depth_--;
   }
 
   void Accept(MenuItemView* item, int event_flags) {
     menu_controller_->Accept(item, event_flags);
   }
 
   void InstallTestMenuMessageLoop() {
     test_message_loop_ =
         new TestMenuMessageLoop(std::move(menu_controller_->message_loop_));
@@ skipping 21 matching lines @@
     for (int i = 0; i < 3; ++i) {
       LabelButton* button =
           new LabelButton(nullptr, base::ASCIIToUTF16("Label"));
       // This is an in-menu button. Hence it must be always focusable.
       button->SetFocusBehavior(View::FocusBehavior::ALWAYS);
       item_view->AddChildView(button);
     }
     menu_item()->GetSubmenu()->ShowAt(owner(), menu_item()->bounds(), false);
   }
 
+  void DestroyMenuItem() { menu_item_.reset(); }
+
   CustomButton* GetHotButton() {
     return menu_controller_->hot_button_;
   }
 
   void SetHotTrackedButton(CustomButton* hot_button) {
     menu_controller_->SetHotTrackedButton(hot_button);
   }
 
   void ExitMenuRun() {
     menu_controller_->SetExitType(MenuController::ExitType::EXIT_OUTERMOST);
@@ skipping 548 matching lines @@
 
   EXPECT_FALSE(controller->drag_in_progress());
   TestMenuControllerDelegate* controller_delegate = menu_controller_delegate();
   EXPECT_EQ(1, controller_delegate->on_menu_closed_called());
   EXPECT_EQ(nullptr, controller_delegate->on_menu_closed_menu());
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             controller_delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
+// Tests that if a menu is destroyed while drag operations are occuring, that
+// the MenuHost does not crash as the drag completes.
+TEST_F(MenuControllerTest, AsynchronousDragHostDeleted) {
+  MenuController* controller = menu_controller();
+  controller->SetAsyncRun(true);
+
+  SubmenuView* submenu = menu_item()->GetSubmenu();
+  submenu->ShowAt(owner(), menu_item()->bounds(), false);
+  MenuHost* host = GetMenuHost(submenu);
+  MenuHostOnDragWillStart(host);
+  submenu->Close();
+  DestroyMenuItem();
+  MenuHostOnDragComplete(host);
+}
+
 // Tets that an asynchronous menu nested within an asynchronous menu closes both
 // menus, and notifies both delegates.
 TEST_F(MenuControllerTest, DoubleAsynchronousNested) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
   // Sets the run created in SetUp
@@ skipping 212 matching lines @@
 
   int result_event_flags = 0;
   // This creates a nested message loop.
   EXPECT_EQ(nullptr, menu_controller()->Run(owner(), nullptr, menu_item(),
                                             gfx::Rect(), MENU_ANCHOR_TOPLEFT,
                                             false, false, &result_event_flags));
   EXPECT_FALSE(menu_controller_delegate()->on_menu_closed_called());
   EXPECT_TRUE(nested_delegate->on_menu_closed_called());
 }
 
+#if defined(USE_AURA)
+// Tests that when a synchronous menu receives a cancel event, that it closes.
+TEST_F(MenuControllerTest, SynchronousCancelEvent) {
+  ExitMenuRun();
+  // Post actual test to run once the menu has created a nested message loop.
+  base::MessageLoopForUI::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MenuControllerTest::TestCancelEvent, base::Unretained(this)));
+  int mouse_event_flags = 0;
+  MenuItemView* run_result = menu_controller()->Run(
+      owner(), nullptr, menu_item(), gfx::Rect(), MENU_ANCHOR_TOPLEFT, false,
+      false, &mouse_event_flags);
+  EXPECT_EQ(run_result, nullptr);
+}
+
+// Tests that when an asynchronous menu receives a cancel event, that it closes.
+TEST_F(MenuControllerTest, AsynchronousCancelEvent) {
+  ExitMenuRun();
+  MenuController* controller = menu_controller();
+  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);
+  TestCancelEvent();
+}
+#endif  // defined(USE_AURA)
+
 }  // namespace test
 }  // namespace views