Cleanup MenuRunner API

ui/views/controls/menu/menu_runner_cocoa_unittest.mm

 // 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.
 
 #import "ui/views/controls/menu/menu_runner_impl_cocoa.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 96 matching lines @@
       runner_ = NULL;
     }
 
     parent_->CloseNow();
     ViewsTestBase::TearDown();
   }
 
   int IsAsync() const { return GetParam() == MenuType::VIEWS; }
 
   // Runs the menu after registering |callback| as the menu open callback.
-  MenuRunner::RunResult RunMenu(const base::Closure& callback) {
+  void RunMenu(const base::Closure& callback) {
     if (IsAsync()) {
       // Cancelling an async menu under MenuController::OpenMenuImpl() (which
       // invokes WillShowMenu()) will cause a UAF when that same function tries
       // to show the menu. So post a task instead.
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
     } else {
       menu_->set_menu_open_callback(
           base::Bind(&MenuRunnerCocoaTest::RunMenuWrapperCallback,
                      base::Unretained(this), callback));
     }
 
-    // Always pass ASYNC, even though native menus will be sync.
-    int run_types = MenuRunner::CONTEXT_MENU | MenuRunner::ASYNC;
-    return MaybeRunAsync(runner_->RunMenuAt(parent_, nullptr, gfx::Rect(),
-                                            MENU_ANCHOR_TOPLEFT, run_types));
+    runner_->RunMenuAt(parent_, nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT,
+                       MenuRunner::CONTEXT_MENU);
+    MaybeRunAsync();
   }
 
   // Runs then cancels a combobox menu and captures the frame of the anchoring
   // view.
-  MenuRunner::RunResult RunMenuAt(const gfx::Rect& anchor) {
+  void RunMenuAt(const gfx::Rect& anchor) {
     last_anchor_frame_ = NSZeroRect;
 
     // Should be one child (the compositor layer) before showing, and it should
     // go up by one (the anchor view) while the menu is shown.
     EXPECT_EQ(1u, [[parent_->GetNativeView() subviews] count]);
 
     base::Closure callback =
         base::Bind(&MenuRunnerCocoaTest::ComboboxRunMenuAtCallback,
                    base::Unretained(this));
     if (IsAsync())
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
     else
       menu_->set_menu_open_callback(callback);
 
-    MenuRunner::RunResult result = MaybeRunAsync(
-        runner_->RunMenuAt(parent_, nullptr, anchor, MENU_ANCHOR_TOPLEFT,
-                           MenuRunner::COMBOBOX | MenuRunner::ASYNC));
+    runner_->RunMenuAt(parent_, nullptr, anchor, MENU_ANCHOR_TOPLEFT,
+                       MenuRunner::COMBOBOX);
+    MaybeRunAsync();
 
     // Ensure the anchor view is removed.
     EXPECT_EQ(1u, [[parent_->GetNativeView() subviews] count]);
-    return result;
   }
 
   void MenuCancelCallback() {
     runner_->Cancel();
     if (IsAsync()) {
       // Async menus report their cancellation immediately.
       EXPECT_FALSE(runner_->IsRunning());
     } else {
       // For a synchronous menu, MenuRunner::IsRunning() should return true
       // immediately after MenuRunner::Cancel() since the menu message loop has
@@ skipping 37 matching lines @@
       ASSERT_EQ(2u, [subviews count]);
       last_anchor_frame_ = [[subviews objectAtIndex:1] frame];
     } else {
       EXPECT_EQ(1u, [subviews count]);
     }
     runner_->Cancel();
   }
 
   // Run a nested message loop so that async and sync menus can be tested the
   // same way.
-  MenuRunner::RunResult MaybeRunAsync(MenuRunner::RunResult run_result) {
+  void MaybeRunAsync() {
     if (!IsAsync())
-      return run_result;
+      return;
 
-    // Async menus should always return NORMAL_EXIT.
-    EXPECT_EQ(MenuRunner::NORMAL_EXIT, run_result);
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, quit_closure_, TestTimeouts::action_timeout());
     run_loop.Run();
 
     // |quit_closure_| should be run by QuitAsyncRunLoop(), not the timeout.
     EXPECT_TRUE(quit_closure_.is_null());
-    return run_result;
   }
 
   void QuitAsyncRunLoop() {
     if (!IsAsync()) {
       EXPECT_TRUE(quit_closure_.is_null());
       return;
     }
     ASSERT_FALSE(quit_closure_.is_null());
     quit_closure_.Run();
     quit_closure_.Reset();
   }
 
   void MenuCloseCallback() {
     ++menu_close_count_;
     QuitAsyncRunLoop();
   }
 
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuRunnerCocoaTest);
 };
 
 TEST_P(MenuRunnerCocoaTest, RunMenuAndCancel) {
   base::TimeTicks min_time = ui::EventTimeForNow();
 
-  MenuRunner::RunResult result = RunMenu(base::Bind(
-      &MenuRunnerCocoaTest::MenuCancelCallback, base::Unretained(this)));
+  RunMenu(base::Bind(&MenuRunnerCocoaTest::MenuCancelCallback,
+                     base::Unretained(this)));
 
   EXPECT_EQ(1, menu_close_count_);
-  EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
   EXPECT_FALSE(runner_->IsRunning());
 
   if (GetParam() == MenuType::VIEWS) {
     // MenuItemView's MenuRunnerImpl gets the closing time from MenuController::
     // closing_event_time(). This is is reset on show, but only updated when an
     // event closes the menu -- not a cancellation.
     EXPECT_EQ(runner_->GetClosingEventTime(), base::TimeTicks());
   } else {
     EXPECT_GE(runner_->GetClosingEventTime(), min_time);
   }
   EXPECT_LE(runner_->GetClosingEventTime(), ui::EventTimeForNow());
 
   // Cancel again.
   runner_->Cancel();
   EXPECT_FALSE(runner_->IsRunning());
   EXPECT_EQ(1, menu_close_count_);
 }
 
 TEST_P(MenuRunnerCocoaTest, RunMenuAndDelete) {
-  MenuRunner::RunResult result = RunMenu(base::Bind(
-      &MenuRunnerCocoaTest::MenuDeleteCallback, base::Unretained(this)));
+  RunMenu(base::Bind(&MenuRunnerCocoaTest::MenuDeleteCallback,
+                     base::Unretained(this)));
   // Note the close callback is NOT invoked for deleted menus.
   EXPECT_EQ(0, menu_close_count_);
-
-  // Async menus always return NORMAL from RunMenuAt().
-  if (GetParam() == MenuType::VIEWS)
-    EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
-  else
-    EXPECT_EQ(MenuRunner::MENU_DELETED, result);
 }
 
 // Ensure a menu can be safely released immediately after a call to Cancel() in
 // the same run loop iteration.
 TEST_P(MenuRunnerCocoaTest, DestroyAfterCanceling) {
-  MenuRunner::RunResult result =
-      RunMenu(base::Bind(&MenuRunnerCocoaTest::MenuCancelAndDeleteCallback,
-                         base::Unretained(this)));
+  RunMenu(base::Bind(&MenuRunnerCocoaTest::MenuCancelAndDeleteCallback,
+                     base::Unretained(this)));
 
   if (IsAsync()) {
-    EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
     EXPECT_EQ(1, menu_close_count_);
   } else {
-    EXPECT_EQ(MenuRunner::MENU_DELETED, result);
     // For a synchronous menu, the deletion happens before the cancel can be
     // processed, so the close callback will not be invoked.
     EXPECT_EQ(0, menu_close_count_);
   }
 }
 
 TEST_P(MenuRunnerCocoaTest, RunMenuTwice) {
   for (int i = 0; i < 2; ++i) {
-    MenuRunner::RunResult result = RunMenu(base::Bind(
-        &MenuRunnerCocoaTest::MenuCancelCallback, base::Unretained(this)));
-    EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
+    RunMenu(base::Bind(&MenuRunnerCocoaTest::MenuCancelCallback,
+                       base::Unretained(this)));
     EXPECT_FALSE(runner_->IsRunning());
     EXPECT_EQ(i + 1, menu_close_count_);
   }
 }
 
 TEST_P(MenuRunnerCocoaTest, CancelWithoutRunning) {
   runner_->Cancel();
   EXPECT_FALSE(runner_->IsRunning());
   EXPECT_EQ(base::TimeTicks(), runner_->GetClosingEventTime());
   EXPECT_EQ(0, menu_close_count_);
@@ skipping 53 matching lines @@
   EXPECT_EQ(combobox_rect.right(), last_anchor_frame_.origin.x);
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         MenuRunnerCocoaTest,
                         ::testing::Values(MenuType::NATIVE, MenuType::VIEWS),
                         &MenuTypeToString);
 
 }  // namespace test
 }  // namespace views