Refactor Menus to Support Asynchronous running

Refactor MenuRunner and MenuController to provide support for menus ran without a nested message loop.

Updated MenuDelegate and MenuControllerDelegate with a callback OnMenuClosed to notify delegates of asynchronous menu closure. Refactored DropMenuClosed in both delegates to use OnMenuClosed instead.

TEST=MenuControllerTest.AsynchronousAccept, MenuControllerTest.AsynchronousCancelAll, MenuRunnerTest.AsynchronousRun, manual testing of menus on device. Ran views_unittests, browser_tests, unit_tests
BUG=557132

Review URL: https://codereview.chromium.org/1473233003

Cr-Commit-Position: refs/heads/master@{#362006}

1 files changed, 133 insertions, 0 deletions

diff --git a/ui/views/controls/menu/menu_runner_unittest.cc b/ui/views/controls/menu/menu_runner_unittest.cc
new file mode 100644
index 0000000..4d45b14
--- /dev/null
+++ b/ui/views/controls/menu/menu_runner_unittest.cc
@@ -0,0 +1,133 @@
+// 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 "base/memory/scoped_ptr.h"
+#include "ui/base/ui_base_types.h"
+#include "ui/views/controls/menu/menu_delegate.h"
+#include "ui/views/controls/menu/menu_item_view.h"
+#include "ui/views/controls/menu/menu_types.h"
+#include "ui/views/test/views_test_base.h"
+#include "ui/views/widget/widget.h"
+
+namespace views {
+namespace test {
+
+// Implementation of MenuDelegate that only reports the values of calls to
+// OnMenuClosed.
+class TestMenuDelegate : public MenuDelegate {
+ public:
+  TestMenuDelegate();
+  ~TestMenuDelegate() override;
+
+  int on_menu_closed_called() { return on_menu_closed_called_; }
+  MenuItemView* on_menu_closed_menu() { return on_menu_closed_menu_; }
+  MenuRunner::RunResult on_menu_closed_run_result() {
+    return on_menu_closed_run_result_;
+  }
+
+  // MenuDelegate:
+  void OnMenuClosed(MenuItemView* menu, MenuRunner::RunResult result) override;
+
+ private:
+  // The number of times OnMenuClosed was called.
+  int on_menu_closed_called_;
+
+  // The values of the last call to OnMenuClosed.
+  MenuItemView* on_menu_closed_menu_;
+  MenuRunner::RunResult on_menu_closed_run_result_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestMenuDelegate);
+};
+
+TestMenuDelegate::TestMenuDelegate()
+    : on_menu_closed_called_(0),
+      on_menu_closed_menu_(nullptr),
+      on_menu_closed_run_result_(MenuRunner::MENU_DELETED) {}
+
+TestMenuDelegate::~TestMenuDelegate() {}
+
+void TestMenuDelegate::OnMenuClosed(MenuItemView* menu,
+                                    MenuRunner::RunResult result) {
+  on_menu_closed_called_++;
+  on_menu_closed_menu_ = menu;
+  on_menu_closed_run_result_ = result;
+}
+
+class MenuRunnerTest : public ViewsTestBase {
+ public:
+  MenuRunnerTest();
+  ~MenuRunnerTest() override;
+
+  // Initializes a MenuRunner with |run_types|. It takes ownership of
+  // |menu_item_view_|.
+  void InitMenuRunner(int32 run_types);
+
+  MenuItemView* menu_item_view() { return menu_item_view_; }
+  TestMenuDelegate* menu_delegate() { return menu_delegate_.get(); }
+  MenuRunner* menu_runner() { return menu_runner_.get(); }
+  Widget* owner() { return owner_.get(); }
+
+  // ViewsTestBase:
+  void SetUp() override;
+  void TearDown() override;
+
+ private:
+  // Owned by MenuRunner.
+  MenuItemView* menu_item_view_;
+
+  scoped_ptr<TestMenuDelegate> menu_delegate_;
+  scoped_ptr<MenuRunner> menu_runner_;
+  scoped_ptr<Widget> owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(MenuRunnerTest);
+};
+
+MenuRunnerTest::MenuRunnerTest() {}
+
+MenuRunnerTest::~MenuRunnerTest() {}
+
+void MenuRunnerTest::InitMenuRunner(int32 run_types) {
+  menu_runner_.reset(new MenuRunner(menu_item_view_, run_types));
+}
+
+void MenuRunnerTest::SetUp() {
+  ViewsTestBase::SetUp();
+  menu_delegate_.reset(new TestMenuDelegate);
+  menu_item_view_ = new MenuItemView(menu_delegate_.get());
+
+  owner_.reset(new Widget);
+  Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
+  params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  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
+// the closing of the menu.
+TEST_F(MenuRunnerTest, AsynchronousRun) {
+  InitMenuRunner(MenuRunner::ASYNC);
+  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);
+  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());
+}
+
+}  // namespace test
+}  // namespace views