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"
@@ skipping 337 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) {
@@ skipping 53 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);
     menu_controller_->ExitMenuRun();
   }
 
- private:
   void DestroyMenuController() {
     if (!menu_controller_)
       return;
 
     if (!owner_->IsClosed())
       owner_->RemoveObserver(menu_controller_);
 
     menu_controller_->showing_ = false;
     menu_controller_->owner_ = nullptr;
     delete menu_controller_;
     menu_controller_ = nullptr;
   }
 
+ private:
   void Init() {
     owner_.reset(new Widget);
     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();
@@ skipping 445 matching lines @@
 
   controller->CancelAll();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(nullptr, delegate->on_menu_closed_menu());
   EXPECT_EQ(0, delegate->on_menu_closed_mouse_event_flags());
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
+// Tests that a when a MenuController has been destroyed, that a menu attempting
+// to cancel does not crash.
+TEST_F(MenuControllerTest, AsynchronousCancelAfterDeletion) {
+  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);
+
+  DestroyMenuController();
+  menu_item()->Cancel();
+}
+
 // Tests that an asynchrnous menu nested within a synchronous menu restores the
 // previous MenuControllerDelegate and synchronous settings.
 TEST_F(MenuControllerTest, AsynchronousNestedDelegate) {
   MenuController* controller = menu_controller();
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   ASSERT_FALSE(IsAsyncRun());
   controller->AddNestedDelegate(nested_delegate.get());
@@ skipping 56 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 214 matching lines @@
   // 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());
 }
 
 }  // namespace test
 }  // namespace views