Cleanup MenuRunner API

ui/views/controls/menu/menu_runner_unittest.cc

 // Copyright 2015 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_runner.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 99 matching lines @@
   owner_->Init(params);
   owner_->Show();
 }
 
 void MenuRunnerTest::TearDown() {
   owner_->CloseNow();
   ViewsTestBase::TearDown();
 }
 
 // Tests that MenuRunner is still running after the call to RunMenuAt when
-// initialized with MenuRunner::ASYNC, and that MenuDelegate is notified upon
+// initialized with , and that MenuDelegate is notified upon
 // the closing of the menu.
 TEST_F(MenuRunnerTest, AsynchronousRun) {
-  InitMenuRunner(MenuRunner::ASYNC);
+  InitMenuRunner(0);
   MenuRunner* runner = menu_runner();
-  MenuRunner::RunResult result = runner->RunMenuAt(
-      owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+  runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                    ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(runner->IsRunning());
 
   runner->Cancel();
   EXPECT_FALSE(runner->IsRunning());
   TestMenuDelegate* delegate = menu_delegate();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(nullptr, delegate->on_menu_closed_menu());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
 }
 
 // Tests that when a menu is run asynchronously, key events are handled properly
 // by testing that Escape key closes the menu.
 TEST_F(MenuRunnerTest, AsynchronousKeyEventHandling) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
   if (IsMus())
     return;
 
-  InitMenuRunner(MenuRunner::ASYNC);
+  InitMenuRunner(0);
   MenuRunner* runner = menu_runner();
-  MenuRunner::RunResult result = runner->RunMenuAt(
-      owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+  runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                    ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(runner->IsRunning());
 
   ui::test::EventGenerator generator(GetContext(), owner()->GetNativeWindow());
   generator.PressKey(ui::VKEY_ESCAPE, 0);
   EXPECT_FALSE(runner->IsRunning());
   TestMenuDelegate* delegate = menu_delegate();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(nullptr, delegate->on_menu_closed_menu());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
 }
 
 // Tests that a key press on a US keyboard layout activates the correct menu
 // item.
 TEST_F(MenuRunnerTest, LatinMnemonic) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
   if (IsMus())
     return;
 
-  InitMenuRunner(MenuRunner::ASYNC);
+  InitMenuRunner(0);
   MenuRunner* runner = menu_runner();
-  MenuRunner::RunResult result = runner->RunMenuAt(
-      owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+  runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                    ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(runner->IsRunning());
 
   ui::test::EventGenerator generator(GetContext(), owner()->GetNativeWindow());
   generator.PressKey(ui::VKEY_O, 0);
   EXPECT_FALSE(runner->IsRunning());
   TestMenuDelegate* delegate = menu_delegate();
   EXPECT_EQ(1, delegate->execute_command_id());
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_NE(nullptr, delegate->on_menu_closed_menu());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
 }
 
 // Tests that a key press on a non-US keyboard layout activates the correct menu
 // item.
 TEST_F(MenuRunnerTest, NonLatinMnemonic) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
   if (IsMus())
     return;
 
-  InitMenuRunner(MenuRunner::ASYNC);
+  InitMenuRunner(0);
   MenuRunner* runner = menu_runner();
-  MenuRunner::RunResult result = runner->RunMenuAt(
-      owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+  runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                    ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(runner->IsRunning());
 
   ui::test::EventGenerator generator(GetContext(), owner()->GetNativeWindow());
   ui::KeyEvent key_press(0x062f, ui::VKEY_N, 0);
   generator.Dispatch(&key_press);
   EXPECT_FALSE(runner->IsRunning());
   TestMenuDelegate* delegate = menu_delegate();
   EXPECT_EQ(2, delegate->execute_command_id());
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_NE(nullptr, delegate->on_menu_closed_menu());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
 }
 
 // Tests that attempting to nest a menu within a drag-and-drop menu does not
 // cause a crash. Instead the drag and drop action should be canceled, and the
 // new menu should be openned.
 TEST_F(MenuRunnerTest, NestingDuringDrag) {
   InitMenuRunner(MenuRunner::FOR_DROP);
   MenuRunner* runner = menu_runner();
-  MenuRunner::RunResult result = runner->RunMenuAt(
-      owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+  runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                    ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(runner->IsRunning());
 
   std::unique_ptr<TestMenuDelegate> nested_delegate(new TestMenuDelegate);
   MenuItemView* nested_menu = new MenuItemView(nested_delegate.get());
   std::unique_ptr<MenuRunner> nested_runner(
-      new MenuRunner(nested_menu, MenuRunner::IS_NESTED | MenuRunner::ASYNC));
-  result = nested_runner->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                    MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+      new MenuRunner(nested_menu, MenuRunner::IS_NESTED));
+  nested_runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                           ui::MENU_SOURCE_NONE);
   EXPECT_TRUE(nested_runner->IsRunning());
   EXPECT_FALSE(runner->IsRunning());
   TestMenuDelegate* delegate = menu_delegate();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_NE(nullptr, delegate->on_menu_closed_menu());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
 }
 
 namespace {
 
 // An EventHandler that launches a menu in response to a mouse press.
 class MenuLauncherEventHandler : public ui::EventHandler {
  public:
   MenuLauncherEventHandler(MenuRunner* runner, Widget* owner)
       : runner_(runner), owner_(owner) {}
   ~MenuLauncherEventHandler() override {}
@@ skipping 43 matching lines @@
     widget_ = new Widget;
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
     widget_->Init(params);
     widget_->Show();
     widget_->SetSize(gfx::Size(300, 300));
 
     event_count_view_ = new EventCountView();
     event_count_view_->SetBounds(0, 0, 300, 300);
     widget_->GetRootView()->AddChildView(event_count_view_);
 
-    InitMenuRunner(MenuRunner::ASYNC);
+    InitMenuRunner(0);
   }
 
   void TearDown() override {
     widget_->CloseNow();
     MenuRunnerTest::TearDown();
   }
 
  private:
   Widget* widget_ = nullptr;
   EventCountView* event_count_view_ = nullptr;
@@ skipping 62 matching lines @@
 }
 
 typedef MenuRunnerTest MenuRunnerImplTest;
 
 // Tests that when nested menu runners are destroyed out of order, that
 // MenuController is not accessed after it has been destroyed. This should not
 // crash on ASAN bots.
 TEST_F(MenuRunnerImplTest, NestedMenuRunnersDestroyedOutOfOrder) {
   internal::MenuRunnerImpl* menu_runner =
       new internal::MenuRunnerImpl(menu_item_view());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT,
-            menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                   MENU_ANCHOR_TOPLEFT, MenuRunner::ASYNC));
+  menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, 0);
 
   std::unique_ptr<TestMenuDelegate> menu_delegate2(new TestMenuDelegate);
   MenuItemView* menu_item_view2 = new MenuItemView(menu_delegate2.get());
   menu_item_view2->AppendMenuItemWithLabel(1, base::ASCIIToUTF16("One"));
 
   internal::MenuRunnerImpl* menu_runner2 =
       new internal::MenuRunnerImpl(menu_item_view2);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT,
-            menu_runner2->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                    MENU_ANCHOR_TOPLEFT,
-                                    MenuRunner::ASYNC | MenuRunner::IS_NESTED));
+  menu_runner2->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                          MenuRunner::IS_NESTED);
 
   // Hide the controller so we can test out of order destruction.
   MenuControllerTestApi menu_controller;
   menu_controller.SetShowing(false);
 
   // This destroyed MenuController
   menu_runner->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
                             nullptr, 0);
 
   // This should not access the destroyed MenuController
   menu_runner2->Release();
   menu_runner->Release();
 }
 
 // Tests that when there are two separate MenuControllers, and the active one is
 // deleted first, that shutting down the MenuRunner of the original
 // MenuController properly closes its controller. This should not crash on ASAN
 // bots.
 TEST_F(MenuRunnerImplTest, MenuRunnerDestroyedWithNoActiveController) {
   internal::MenuRunnerImpl* menu_runner =
       new internal::MenuRunnerImpl(menu_item_view());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT,
-            menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                   MENU_ANCHOR_TOPLEFT, MenuRunner::ASYNC));
+  menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, 0);
 
   // Hide the menu, and clear its item selection state.
   MenuControllerTestApi menu_controller;
   menu_controller.SetShowing(false);
   menu_controller.ClearState();
 
   std::unique_ptr<TestMenuDelegate> menu_delegate2(new TestMenuDelegate);
   MenuItemView* menu_item_view2 = new MenuItemView(menu_delegate2.get());
   menu_item_view2->AppendMenuItemWithLabel(1, base::ASCIIToUTF16("One"));
 
   internal::MenuRunnerImpl* menu_runner2 =
       new internal::MenuRunnerImpl(menu_item_view2);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT,
-            menu_runner2->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                    MENU_ANCHOR_TOPLEFT,
-                                    MenuRunner::ASYNC | MenuRunner::FOR_DROP));
+  menu_runner2->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                          MenuRunner::FOR_DROP);
 
   EXPECT_NE(menu_controller.controller(), MenuController::GetActiveInstance());
   menu_controller.SetShowing(true);
 
   // Close the runner with the active menu first.
   menu_runner2->Release();
   // Even though there is no active menu, this should still cleanup the
   // controller that it created.
   menu_runner->Release();
 
@@ skipping 38 matching lines @@
   views_delegate_ = views_delegate.get();
   set_views_delegate(std::move(views_delegate));
   MenuRunnerTest::SetUp();
 }
 
 // Tests that when ViewsDelegate is released that a nested Cancel of the
 // MenuRunner does not occur.
 TEST_F(MenuRunnerDestructionTest, MenuRunnerDestroyedDuringReleaseRef) {
   internal::MenuRunnerImpl* menu_runner =
       new internal::MenuRunnerImpl(menu_item_view());
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT,
-            menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(),
-                                   MENU_ANCHOR_TOPLEFT, MenuRunner::ASYNC));
+  menu_runner->RunMenuAt(owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, 0);
 
   views_delegate()->set_menu_runner(menu_runner);
 
   base::WeakPtr<internal::MenuRunnerImpl> ref(MenuRunnerAsWeakPtr(menu_runner));
   MenuControllerTestApi menu_controller;
   // This will release the ref on ViewsDelegate. The test version will release
   // |menu_runner| simulating device shutdown.
   menu_controller.controller()->CancelAll();
   // Both the |menu_runner| and |menu_controller| should have been deleted.
   EXPECT_EQ(nullptr, ref);
   EXPECT_EQ(nullptr, menu_controller.controller());
 }
 
 }  // namespace test
 }  // namespace views