Cleanup MenuRunner API

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 580 matching lines @@
       &test_event_handler);
 
   std::vector<int> devices;
   devices.push_back(1);
   ui::SetUpTouchDevicesForTest(devices);
 
   event_generator()->PressTouchId(0);
   event_generator()->PressTouchId(1);
   event_generator()->ReleaseTouchId(0);
 
-  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);
+  menu_controller()->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                         MENU_ANCHOR_TOPLEFT, false, false);
 
   MenuControllerTest::ReleaseTouchId(1);
   TestAsyncEscapeKey();
 
   EXPECT_EQ(MenuController::EXIT_ALL, menu_exit_type());
   EXPECT_EQ(0, test_event_handler.outstanding_touches());
 
   owner()->GetNativeWindow()->GetRootWindow()->RemovePreTargetHandler(
       &test_event_handler);
 }
@@ skipping 290 matching lines @@
   // Increment twice to move selection to |button2|.
   IncrementSelection();
   IncrementSelection();
   EXPECT_EQ(5, pending_state_item()->GetCommand());
   EXPECT_FALSE(button1->IsHotTracked());
   EXPECT_TRUE(button2->IsHotTracked());
   EXPECT_FALSE(button3->IsHotTracked());
   EXPECT_EQ(button2, GetHotButton());
 
   MenuController* controller = menu_controller();
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
 
   // |button2| should stay in hot-tracked state but menu controller should not
   // track it anymore (preventing resetting hot-tracked state when changing
   // selection while a nested run is active).
   EXPECT_TRUE(button2->IsHotTracked());
   EXPECT_EQ(nullptr, GetHotButton());
 
   // Setting hot-tracked button while nested should get reverted when nested
   // menu run ends.
   SetHotTrackedButton(button1);
   EXPECT_TRUE(button1->IsHotTracked());
   EXPECT_EQ(button1, GetHotButton());
 
   ExitMenuRun();
   EXPECT_FALSE(button1->IsHotTracked());
   EXPECT_TRUE(button2->IsHotTracked());
   EXPECT_EQ(button2, GetHotButton());
 }
 
 // Tests that a menu opened asynchronously, will notify its
 // MenuControllerDelegate when Accept is called.
 TEST_F(MenuControllerTest, AsynchronousAccept) {
   MenuController* controller = menu_controller();
-
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
   EXPECT_EQ(0, delegate->on_menu_closed_called());
 
   MenuItemView* accepted = menu_item()->GetSubmenu()->GetMenuItemAt(0);
   const int kEventFlags = 42;
   Accept(accepted, kEventFlags);
 
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(accepted, delegate->on_menu_closed_menu());
   EXPECT_EQ(kEventFlags, delegate->on_menu_closed_mouse_event_flags());
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             delegate->on_menu_closed_notify_type());
 }
 
 // Tests that a menu opened asynchronously, will notify its
 // MenuControllerDelegate when CancelAll is called.
 TEST_F(MenuControllerTest, AsynchronousCancelAll) {
   MenuController* controller = menu_controller();
 
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
   TestMenuControllerDelegate* delegate = menu_controller_delegate();
   EXPECT_EQ(0, delegate->on_menu_closed_called());
 
   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 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());
 
   controller->AddNestedDelegate(nested_delegate.get());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
 
   controller->CancelAll();
   EXPECT_EQ(delegate, GetCurrentDelegate());
   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());
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             nested_delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
@@ skipping 94 matching lines @@
 // 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());
 
   // Nested run
   controller->AddNestedDelegate(nested_delegate.get());
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
 
   controller->CancelAll();
   EXPECT_EQ(1, delegate->on_menu_closed_called());
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
 // 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());
 
   controller->AddNestedDelegate(nested_delegate.get());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
   MenuItemView* item = menu_item();
-  int mouse_event_flags = 0;
-  MenuItemView* run_result =
-      controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
-                      false, false, &mouse_event_flags);
-  EXPECT_EQ(run_result, nullptr);
+  controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                  false, false);
 
   // Show a sub menu to target with a pointer selection. However have the event
   // occur outside of the bounds of the entire menu.
   SubmenuView* sub_menu = item->GetSubmenu();
   sub_menu->ShowAt(owner(), item->bounds(), false);
   gfx::Point location(sub_menu->bounds().bottom_right());
   location.Offset(1, 1);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, location, location,
                        ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
 
@@ skipping 42 matching lines @@
 // cause a crash. ASAN bots should not detect use-after-free in MenuController.
 TEST_F(MenuControllerTest, AsynchronousRepostEventDeletesController) {
   MenuController* controller = menu_controller();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   controller->AddNestedDelegate(nested_delegate.get());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
   MenuItemView* item = menu_item();
-  int mouse_event_flags = 0;
-  MenuItemView* run_result =
-      controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
-                      false, false, &mouse_event_flags);
-  EXPECT_EQ(run_result, nullptr);
+  controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                  false, false);
 
   // Show a sub menu to target with a pointer selection. However have the event
   // occur outside of the bounds of the entire menu.
   SubmenuView* sub_menu = item->GetSubmenu();
   sub_menu->ShowAt(owner(), item->bounds(), true);
   gfx::Point location(sub_menu->bounds().bottom_right());
   location.Offset(1, 1);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, location, location,
                        ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
 
@@ skipping 13 matching lines @@
 // cause a crash. ASAN bots should not detect use-after-free in MenuController.
 TEST_F(MenuControllerTest, AsynchronousGestureDeletesController) {
   MenuController* controller = menu_controller();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
 
   controller->AddNestedDelegate(nested_delegate.get());
   EXPECT_EQ(nested_delegate.get(), GetCurrentDelegate());
 
   MenuItemView* item = menu_item();
-  int mouse_event_flags = 0;
-  MenuItemView* run_result =
-      controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
-                      false, false, &mouse_event_flags);
-  EXPECT_EQ(run_result, nullptr);
+  controller->Run(owner(), nullptr, item, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                  false, false);
 
   // Show a sub menu to target with a tap event.
   SubmenuView* sub_menu = item->GetSubmenu();
   sub_menu->ShowAt(owner(), gfx::Rect(0, 0, 100, 100), true);
 
   gfx::Point location(sub_menu->bounds().CenterPoint());
   ui::GestureEvent event(location.x(), location.y(), 0, ui::EventTimeForNow(),
                          ui::GestureEventDetails(ui::ET_GESTURE_TAP));
 
   // This will lead to MenuController being deleted during the processing of the
   // gesture event. The remainder of this test, and TearDown should not crash.
   DestroyMenuControllerOnMenuClosed(nested_delegate.get());
   controller->OnGestureEvent(sub_menu, &event);
 
   // Close to remove observers before test TearDown
   sub_menu->Close();
   EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
 }
 
 #if defined(USE_AURA)
 // Tests that when an asynchronous menu receives a cancel event, that it closes.
 TEST_F(MenuControllerTest, AsynchronousCancelEvent) {
   ExitMenuRun();
   MenuController* controller = menu_controller();
-
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
   EXPECT_EQ(MenuController::EXIT_NONE, controller->exit_type());
   ui::CancelModeEvent cancel_event;
   event_generator()->Dispatch(&cancel_event);
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
 // Tests that if a menu is ran without a widget, that MenuPreTargetHandler does
 // not cause a crash.
 TEST_F(MenuControllerTest, RunWithoutWidgetDoesntCrash) {
   ExitMenuRun();
   MenuController* controller = menu_controller();
-  int mouse_event_flags = 0;
-  MenuItemView* run_result =
-      controller->Run(nullptr, nullptr, menu_item(), gfx::Rect(),
-                      MENU_ANCHOR_TOPLEFT, false, false, &mouse_event_flags);
-  EXPECT_EQ(run_result, nullptr);
+  controller->Run(nullptr, nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
 }
 
 // Tests that if a MenuController is destroying during drag/drop, and another
 // MenuController becomes active, that the exiting of drag does not cause a
 // crash.
 TEST_F(MenuControllerTest, MenuControllerReplacedDuringDrag) {
   // Build the menu so that the appropriate root window is available to set the
   // drag drop client on.
   AddButtonMenuItems();
   TestDragDropClient drag_drop_client(
@@ skipping 24 matching lines @@
                                       ->GetRootWindow(),
                                   &drag_drop_client);
   StartDrag();
 }
 
 // Tests that when releasing the ref on ViewsDelegate and MenuController is
 // deleted, that shutdown occurs without crashing.
 TEST_F(MenuControllerTest, DestroyedDuringViewsRelease) {
   ExitMenuRun();
   MenuController* controller = menu_controller();
-
-  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);
+  controller->Run(owner(), nullptr, menu_item(), gfx::Rect(),
+                  MENU_ANCHOR_TOPLEFT, false, false);
   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.
@@ skipping 30 matching lines @@
   // 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);
+  controller->Run(owner(), nullptr, nested_menu_item_1.get(),
+                  gfx::Rect(150, 50, 100, 100), MENU_ANCHOR_TOPLEFT, true,
+                  false);
 
   SubmenuView* nested_menu_submenu = nested_menu_item_1->GetSubmenu();
   nested_menu_submenu->SetBounds(0, 0, 100, 100);
   nested_menu_submenu->ShowAt(owner(), gfx::Rect(0, 0, 100, 100), false);
   GetMenuHost(nested_menu_submenu)
       ->SetContentsView(nested_menu_submenu->GetScrollViewContainer());
 
   // 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());
@@ skipping 28 matching lines @@
   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);
+  controller->Run(owner(), nullptr, nested_menu_item_2.get(),
+                  gfx::Rect(150, 50, 100, 100), MENU_ANCHOR_TOPLEFT, true,
+                  false);
 
   // 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