Index: ui/views/controls/menu/menu_controller_unittest.cc |
diff --git a/ui/views/controls/menu/menu_controller_unittest.cc b/ui/views/controls/menu/menu_controller_unittest.cc |
index 287d5168295cf0817f31c6edb365a0f23885da1b..da53377fb09e1e8ccb7f62975447e12ccfa210b2 100644 |
--- a/ui/views/controls/menu/menu_controller_unittest.cc |
+++ b/ui/views/controls/menu/menu_controller_unittest.cc |
@@ -7,6 +7,7 @@ |
#include "base/callback.h" |
#include "base/logging.h" |
#include "base/macros.h" |
+#include "base/run_loop.h" |
#include "base/single_thread_task_runner.h" |
#include "base/strings/utf_string_conversions.h" |
#include "base/threading/thread_task_runner_handle.h" |
@@ -26,7 +27,6 @@ |
#include "ui/views/controls/menu/menu_host.h" |
#include "ui/views/controls/menu/menu_host_root_view.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" |
@@ -153,46 +153,6 @@ class TestEventHandler : public ui::EventHandler { |
DISALLOW_COPY_AND_ASSIGN(TestEventHandler); |
}; |
-// A wrapper around MenuMessageLoop that can be used to track whether a message |
-// loop is running or not. |
-class TestMenuMessageLoop : public MenuMessageLoop { |
- public: |
- explicit TestMenuMessageLoop(std::unique_ptr<MenuMessageLoop> original); |
- ~TestMenuMessageLoop() override; |
- |
- bool is_running() const { return is_running_; } |
- |
- // MenuMessageLoop: |
- void QuitNow() override; |
- |
- private: |
- // MenuMessageLoop: |
- 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() { |
- is_running_ = true; |
- original_->Run(); |
-} |
- |
-void TestMenuMessageLoop::QuitNow() { |
- is_running_ = false; |
- original_->QuitNow(); |
-} |
- |
#if defined(USE_AURA) |
// A DragDropClient which does not trigger a nested message loop. Instead a |
// callback is triggered during StartDragAndDrop in order to allow testing. |
@@ -316,29 +276,12 @@ class MenuControllerTest : public ViewsTestBase { |
} |
#if defined(OS_LINUX) && defined(USE_X11) |
- void TestEventTargeter() { |
- { |
- // With the |ui::NullEventTargeter| instantiated and assigned we expect |
- // the menu to not handle the key event. |
- aura::ScopedWindowTargeter scoped_targeter( |
- owner()->GetNativeWindow()->GetRootWindow(), |
- std::unique_ptr<ui::EventTargeter>(new ui::NullEventTargeter)); |
- 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_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) |
@@ -367,13 +310,10 @@ class MenuControllerTest : public ViewsTestBase { |
} |
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; |
MenuItemView* run_result = menu_controller()->Run( |
@@ -385,17 +325,13 @@ class MenuControllerTest : public ViewsTestBase { |
// terminated. |
menu_controller()->Cancel(MenuController::EXIT_ALL); |
EXPECT_EQ(MenuController::EXIT_ALL, menu_controller()->exit_type()); |
- EXPECT_FALSE(test_message_loop_->is_running()); |
} |
void TestAsynchronousNestedExitOutermost() { |
- 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; |
MenuItemView* run_result = menu_controller()->Run( |
@@ -407,12 +343,10 @@ class MenuControllerTest : public ViewsTestBase { |
// still running. |
menu_controller()->Cancel(MenuController::EXIT_OUTERMOST); |
EXPECT_EQ(MenuController::EXIT_NONE, menu_controller()->exit_type()); |
- EXPECT_TRUE(test_message_loop_->is_running()); |
// Now, exit the parent menu and check that its message loop is terminated. |
menu_controller()->Cancel(MenuController::EXIT_OUTERMOST); |
EXPECT_EQ(MenuController::EXIT_OUTERMOST, menu_controller()->exit_type()); |
- EXPECT_FALSE(test_message_loop_->is_running()); |
} |
// This nested an asynchronous delegate onto a menu with a nested message |
@@ -421,9 +355,6 @@ class MenuControllerTest : public ViewsTestBase { |
void TestNestedMessageLoopKillsItself( |
TestMenuControllerDelegate* nested_delegate) { |
menu_controller_->AddNestedDelegate(nested_delegate); |
- menu_controller_->SetAsyncRun(true); |
- |
- test_message_loop_->QuitNow(); |
} |
// Tests destroying the active |menu_controller_| and replacing it with a new |
@@ -510,8 +441,6 @@ class MenuControllerTest : public ViewsTestBase { |
return menu_controller_->delegate_; |
} |
- bool IsAsyncRun() { return menu_controller_->async_run_; } |
- |
bool IsShowing() { return menu_controller_->showing_; } |
MenuHost* GetMenuHost(SubmenuView* submenu) { return submenu->host_; } |
@@ -548,27 +477,10 @@ class MenuControllerTest : public ViewsTestBase { |
menu_controller_->OnMouseMoved(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_--; |
- } |
- |
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_)); |
- menu_controller_->message_loop_.reset(test_message_loop_); |
- } |
- |
// Causes the |menu_controller_| to begin dragging. Use TestDragDropClient to |
// avoid nesting message loops. |
void StartDrag() { |
@@ -677,7 +589,6 @@ class MenuControllerTest : public ViewsTestBase { |
std::unique_ptr<TestMenuControllerDelegate> menu_controller_delegate_; |
std::unique_ptr<MenuDelegate> menu_delegate_; |
MenuController* menu_controller_; |
- TestMenuMessageLoop* test_message_loop_; |
DISALLOW_COPY_AND_ASSIGN(MenuControllerTest); |
}; |
@@ -686,16 +597,18 @@ class MenuControllerTest : public ViewsTestBase { |
// 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); |
+ { |
+ // With the |ui::NullEventTargeter| instantiated and assigned we expect |
+ // the menu to not handle the key event. |
+ aura::ScopedWindowTargeter scoped_targeter( |
+ owner()->GetNativeWindow()->GetRootWindow(), |
+ std::unique_ptr<ui::EventTargeter>(new ui::NullEventTargeter)); |
+ PressKey(ui::VKEY_ESCAPE); |
+ base::RunLoop().RunUntilIdle(); |
+ EXPECT_EQ(MenuController::EXIT_NONE, menu_exit_type()); |
+ } |
+ // Now that the targeter has been destroyed, expect to exit the menu |
+ // normally when hitting escape. |
TestAsyncEscapeKey(); |
} |
@@ -717,15 +630,14 @@ TEST_F(MenuControllerTest, TouchIdsReleasedCorrectly) { |
event_generator()->PressTouchId(1); |
event_generator()->ReleaseTouchId(0); |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&MenuControllerTest::ReleaseTouchId, |
- base::Unretained(this), 1)); |
- |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&MenuControllerTest::PressKey, |
- base::Unretained(this), ui::VKEY_ESCAPE)); |
+ 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); |
- RunMenu(); |
+ MenuControllerTest::ReleaseTouchId(1); |
+ TestAsyncEscapeKey(); |
EXPECT_EQ(MenuController::EXIT_ALL, menu_exit_type()); |
EXPECT_EQ(0, test_event_handler.outstanding_touches()); |
@@ -1033,7 +945,6 @@ TEST_F(MenuControllerTest, ChildButtonHotTrackedWhenNested) { |
EXPECT_EQ(button2, GetHotButton()); |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |
controller->Run(owner(), nullptr, menu_item(), gfx::Rect(), |
@@ -1062,7 +973,6 @@ TEST_F(MenuControllerTest, ChildButtonHotTrackedWhenNested) { |
// MenuControllerDelegate when Accept is called. |
TEST_F(MenuControllerTest, AsynchronousAccept) { |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |
@@ -1087,7 +997,6 @@ TEST_F(MenuControllerTest, AsynchronousAccept) { |
// MenuControllerDelegate when CancelAll is called. |
TEST_F(MenuControllerTest, AsynchronousCancelAll) { |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |
@@ -1106,19 +1015,15 @@ TEST_F(MenuControllerTest, AsynchronousCancelAll) { |
EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type()); |
} |
-// Tests that an asynchrnous menu nested within a synchronous menu restores the |
-// previous MenuControllerDelegate and synchronous settings. |
+// Tests that canceling a nested menu restores the previous |
+// MenuControllerDelegate, and notifies each delegate. |
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()); |
- controller->SetAsyncRun(true); |
- |
- EXPECT_TRUE(IsAsyncRun()); |
EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate()); |
int mouse_event_flags = 0; |
@@ -1128,9 +1033,8 @@ TEST_F(MenuControllerTest, AsynchronousNestedDelegate) { |
EXPECT_EQ(run_result, nullptr); |
controller->CancelAll(); |
- EXPECT_FALSE(IsAsyncRun()); |
EXPECT_EQ(delegate, GetCurrentDelegate()); |
- EXPECT_EQ(0, delegate->on_menu_closed_called()); |
+ EXPECT_EQ(1, delegate->on_menu_closed_called()); |
EXPECT_EQ(1, nested_delegate->on_menu_closed_called()); |
EXPECT_EQ(nullptr, nested_delegate->on_menu_closed_menu()); |
EXPECT_EQ(0, nested_delegate->on_menu_closed_mouse_event_flags()); |
@@ -1143,7 +1047,6 @@ TEST_F(MenuControllerTest, AsynchronousNestedDelegate) { |
// and does not notify the controller. |
TEST_F(MenuControllerTest, AsynchronousPerformDrop) { |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
SubmenuView* source = menu_item()->GetSubmenu(); |
MenuItemView* target = source->GetMenuItemAt(0); |
@@ -1168,7 +1071,6 @@ TEST_F(MenuControllerTest, AsynchronousPerformDrop) { |
// MenuControllerDelegate for shutdown. |
TEST_F(MenuControllerTest, AsynchronousDragComplete) { |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
TestDragCompleteThenDestroyOnMenuClosed(); |
controller->OnDragWillStart(); |
@@ -1185,7 +1087,6 @@ TEST_F(MenuControllerTest, AsynchronousDragComplete) { |
// notified when the drag completes. |
TEST_F(MenuControllerTest, AsynchronousCancelDuringDrag) { |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
TestDragCompleteThenDestroyOnMenuClosed(); |
controller->OnDragWillStart(); |
@@ -1202,9 +1103,6 @@ TEST_F(MenuControllerTest, AsynchronousCancelDuringDrag) { |
// 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); |
@@ -1218,9 +1116,6 @@ TEST_F(MenuControllerTest, AsynchronousDragHostDeleted) { |
// MenuController has been destroyed. A MenuHostRootView should not attempt to |
// access a destroyed MenuController. This test should not cause a crash. |
TEST_F(MenuControllerTest, HostReceivesInputBeforeDestruction) { |
- MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
- |
SubmenuView* submenu = menu_item()->GetSubmenu(); |
submenu->ShowAt(owner(), menu_item()->bounds(), false); |
gfx::Point location(submenu->bounds().bottom_right()); |
@@ -1248,13 +1143,8 @@ TEST_F(MenuControllerTest, DoubleAsynchronousNested) { |
std::unique_ptr<TestMenuControllerDelegate> nested_delegate( |
new TestMenuControllerDelegate()); |
- ASSERT_FALSE(IsAsyncRun()); |
- // Sets the run created in SetUp |
- controller->SetAsyncRun(true); |
- |
// Nested run |
controller->AddNestedDelegate(nested_delegate.get()); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |
controller->Run(owner(), nullptr, menu_item(), gfx::Rect(), |
@@ -1266,21 +1156,16 @@ TEST_F(MenuControllerTest, DoubleAsynchronousNested) { |
EXPECT_EQ(1, nested_delegate->on_menu_closed_called()); |
} |
-// Tests that an asynchronous menu nested within a synchronous menu does not |
-// crash when trying to repost events that occur outside of the bounds of the |
-// menu. Instead a proper shutdown should occur. |
+// 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()); |
- ASSERT_FALSE(IsAsyncRun()); |
- |
controller->AddNestedDelegate(nested_delegate.get()); |
- controller->SetAsyncRun(true); |
- |
- EXPECT_TRUE(IsAsyncRun()); |
EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate()); |
MenuItemView* item = menu_item(); |
@@ -1303,9 +1188,8 @@ TEST_F(MenuControllerTest, AsynchronousRepostEvent) { |
// shutdown. This should not crash while attempting to repost the event. |
SetSelectionOnPointerDown(sub_menu, &event); |
- EXPECT_FALSE(IsAsyncRun()); |
EXPECT_EQ(delegate, GetCurrentDelegate()); |
- EXPECT_EQ(0, delegate->on_menu_closed_called()); |
+ EXPECT_EQ(1, delegate->on_menu_closed_called()); |
EXPECT_EQ(1, nested_delegate->on_menu_closed_called()); |
EXPECT_EQ(nullptr, nested_delegate->on_menu_closed_menu()); |
EXPECT_EQ(0, nested_delegate->on_menu_closed_mouse_event_flags()); |
@@ -1319,7 +1203,6 @@ TEST_F(MenuControllerTest, AsynchronousRepostEvent) { |
TEST_F(MenuControllerTest, AsynchronousTouchEventRepostEvent) { |
MenuController* controller = menu_controller(); |
TestMenuControllerDelegate* delegate = menu_controller_delegate(); |
- controller->SetAsyncRun(true); |
// Show a sub menu to target with a touch event. However have the event occur |
// outside of the bounds of the entire menu. |
@@ -1342,32 +1225,6 @@ TEST_F(MenuControllerTest, AsynchronousTouchEventRepostEvent) { |
EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type()); |
} |
-// Tests that if you exit all menus when an asynchrnous menu is nested within a |
-// synchronous menu, the message loop for the parent menu finishes running. |
-TEST_F(MenuControllerTest, AsynchronousNestedExitAll) { |
- InstallTestMenuMessageLoop(); |
- |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&MenuControllerTest::TestAsynchronousNestedExitAll, |
- base::Unretained(this))); |
- |
- RunMenu(); |
-} |
- |
-// Tests that if you exit the nested menu when an asynchrnous menu is nested |
-// within a synchronous menu, the message loop for the parent menu remains |
-// running. |
-TEST_F(MenuControllerTest, AsynchronousNestedExitOutermost) { |
- InstallTestMenuMessageLoop(); |
- |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, |
- base::Bind(&MenuControllerTest::TestAsynchronousNestedExitOutermost, |
- base::Unretained(this))); |
- |
- RunMenu(); |
-} |
- |
// Tests that having the MenuController deleted during RepostEvent does not |
// cause a crash. ASAN bots should not detect use-after-free in MenuController. |
TEST_F(MenuControllerTest, AsynchronousRepostEventDeletesController) { |
@@ -1375,12 +1232,7 @@ TEST_F(MenuControllerTest, AsynchronousRepostEventDeletesController) { |
std::unique_ptr<TestMenuControllerDelegate> nested_delegate( |
new TestMenuControllerDelegate()); |
- ASSERT_FALSE(IsAsyncRun()); |
- |
controller->AddNestedDelegate(nested_delegate.get()); |
- controller->SetAsyncRun(true); |
- |
- EXPECT_TRUE(IsAsyncRun()); |
EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate()); |
MenuItemView* item = menu_item(); |
@@ -1417,12 +1269,8 @@ TEST_F(MenuControllerTest, AsynchronousGestureDeletesController) { |
MenuController* controller = menu_controller(); |
std::unique_ptr<TestMenuControllerDelegate> nested_delegate( |
new TestMenuControllerDelegate()); |
- ASSERT_FALSE(IsAsyncRun()); |
controller->AddNestedDelegate(nested_delegate.get()); |
- controller->SetAsyncRun(true); |
- |
- EXPECT_TRUE(IsAsyncRun()); |
EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate()); |
MenuItemView* item = menu_item(); |
@@ -1450,49 +1298,11 @@ TEST_F(MenuControllerTest, AsynchronousGestureDeletesController) { |
EXPECT_EQ(1, nested_delegate->on_menu_closed_called()); |
} |
-// Tests that when an asynchronous menu is nested, and the nested message loop |
-// is kill not by the MenuController, that the nested menu is notified of |
-// destruction. |
-TEST_F(MenuControllerTest, NestedMessageLoopDiesWithNestedMenu) { |
- menu_controller()->CancelAll(); |
- InstallTestMenuMessageLoop(); |
- std::unique_ptr<TestMenuControllerDelegate> nested_delegate( |
- new TestMenuControllerDelegate()); |
- // This will nest an asynchronous menu, and then kill the nested message loop. |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, |
- base::Bind(&MenuControllerTest::TestNestedMessageLoopKillsItself, |
- base::Unretained(this), nested_delegate.get())); |
- |
- 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::ThreadTaskRunnerHandle::Get()->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 = |
@@ -1507,7 +1317,6 @@ TEST_F(MenuControllerTest, AsynchronousCancelEvent) { |
TEST_F(MenuControllerTest, RunWithoutWidgetDoesntCrash) { |
ExitMenuRun(); |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |
controller->Run(nullptr, nullptr, menu_item(), gfx::Rect(), |
@@ -1538,9 +1347,6 @@ TEST_F(MenuControllerTest, MenuControllerReplacedDuringDrag) { |
// destroy the MenuController. On Windows and Linux this destruction also |
// destroys the Widget used for drag-and-drop, thereby ending the drag. |
TEST_F(MenuControllerTest, CancelAllDuringDrag) { |
- MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
- |
// Build the menu so that the appropriate root window is available to set the |
// drag drop client on. |
AddButtonMenuItems(); |
@@ -1560,7 +1366,6 @@ TEST_F(MenuControllerTest, CancelAllDuringDrag) { |
TEST_F(MenuControllerTest, DestroyedDuringViewsRelease) { |
ExitMenuRun(); |
MenuController* controller = menu_controller(); |
- controller->SetAsyncRun(true); |
int mouse_event_flags = 0; |
MenuItemView* run_result = |