Update closing of nested asynchronous menus

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/strings/utf_string_conversions.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/events/event_handler.h"
@@ skipping 15 matching lines @@
 #undef Bool
 #undef None
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 namespace views {
 namespace test {
 
 namespace {
 
+// Test implementation of MenuDelegate that only reports calls of OnPerformDrop.
+class TestMenuDelegate : public MenuDelegate {
+ public:
+  TestMenuDelegate();
+  ~TestMenuDelegate() override;
+
+  bool on_perform_drop_called() { return on_perform_drop_called_; }
+
+  int OnPerformDrop(MenuItemView* menu,
+                    DropPosition position,
+                    const ui::DropTargetEvent& event) override;
+
+ private:
+  bool on_perform_drop_called_;
+  DISALLOW_COPY_AND_ASSIGN(TestMenuDelegate);
+};
+
+TestMenuDelegate::TestMenuDelegate() : on_perform_drop_called_(false) {}
+
+TestMenuDelegate::~TestMenuDelegate() {}
+
+int TestMenuDelegate::OnPerformDrop(MenuItemView* menu,
+                                    DropPosition position,
+                                    const ui::DropTargetEvent& event) {
+  on_perform_drop_called_ = true;
+  return ui::DragDropTypes::DRAG_COPY;
+}
+
 // Test implementation of MenuControllerDelegate that only reports the values
 // called of OnMenuClosed.
 class TestMenuControllerDelegate : public internal::MenuControllerDelegate {
  public:
   TestMenuControllerDelegate();
   ~TestMenuControllerDelegate() override {}
 
   int on_menu_closed_called() { return on_menu_closed_called_; }
 
   NotifyType on_menu_closed_notify_type() {
@@ skipping 188 matching lines @@
     return menu_controller_->FindNextSelectableMenuItem(
         parent, index, MenuController::INCREMENT_SELECTION_UP);
   }
 
   internal::MenuControllerDelegate* GetCurrentDelegate() {
     return menu_controller_->delegate_;
   }
 
   bool IsAsyncRun() { return menu_controller_->async_run_; }
 
+  bool IsShowing() { return menu_controller_->showing_; }
+
   void SelectByChar(base::char16 character) {
     menu_controller_->SelectByChar(character);
   }
 
+  void SetDropMenuItem(MenuItemView* target,
+                       MenuDelegate::DropPosition position) {
+    menu_controller_->SetDropMenuItem(target, position);
+  }
+
   void SetIsCombobox(bool is_combobox) {
     menu_controller_->set_is_combobox(is_combobox);
   }
 
   void RunMenu() {
     menu_controller_->RunMessageLoop(false);
   }
 
   void Accept(MenuItemView* item, int event_flags) {
     menu_controller_->Accept(item, event_flags);
@@ skipping 22 matching lines @@
     event_generator_.reset(
         new ui::test::EventGenerator(GetContext(), owner_->GetNativeWindow()));
     owner_->Show();
 
     SetupMenuItem();
 
     SetupMenuController();
   }
 
   void SetupMenuItem() {
-    menu_delegate_.reset(new MenuDelegate);
+    menu_delegate_.reset(new TestMenuDelegate);
     menu_item_.reset(new TestMenuItemViewShown(menu_delegate_.get()));
     menu_item_->AppendMenuItemWithLabel(1, base::ASCIIToUTF16("One"));
     menu_item_->AppendMenuItemWithLabel(2, base::ASCIIToUTF16("Two"));
     menu_item_->AppendMenuItemWithLabel(3, base::ASCIIToUTF16("Three"));
     menu_item_->AppendMenuItemWithLabel(4, base::ASCIIToUTF16("Four"));
   }
 
   void SetupMenuController() {
     menu_controller_delegate_.reset(new TestMenuControllerDelegate);
     menu_controller_ =
@@ skipping 292 matching lines @@
   EXPECT_EQ(delegate, GetCurrentDelegate());
   EXPECT_EQ(0, 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());
 }
 
+// Tests that dropping within an asynchronous menu notifies the MenuDelegate,
+// and exits the MenuController.
+TEST_F(MenuControllerTest, AsynchronousPerformDrop) {
+  MenuController* controller = menu_controller();
+  controller->SetAsyncRun(true);
+  SubmenuView* source = menu_item()->GetSubmenu();
+  MenuItemView* target = source->GetMenuItemAt(0);
+
+  SetDropMenuItem(target, MenuDelegate::DropPosition::DROP_AFTER);
+
+  ui::OSExchangeData drop_data;
+  gfx::Rect bounds(target->bounds());
+  gfx::Point location(bounds.x(), bounds.y());
+  ui::DropTargetEvent target_event(drop_data, location, location,
+                                   ui::DragDropTypes::DRAG_MOVE);
+  controller->OnPerformDrop(source, target_event);
+
+  TestMenuDelegate* menu_delegate =
+      static_cast<TestMenuDelegate*>(target->GetDelegate());
+  TestMenuControllerDelegate* controller_delegate = menu_controller_delegate();
+  EXPECT_TRUE(menu_delegate->on_perform_drop_called());
+  EXPECT_FALSE(IsShowing());
+  EXPECT_EQ(0, controller_delegate->on_menu_closed_called());
+
+  // Closing from drag and drop is enqueued. The message to
+  // MenuControllerDelegate occurs afterwards so that the destruction of
+  // MenuController does no free the layers who are still referenced in enqueued
+  // tasks.
+  RunPendingMessages();
+  EXPECT_EQ(1, controller_delegate->on_menu_closed_called());
+  EXPECT_EQ(nullptr, controller_delegate->on_menu_closed_menu());
+  EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
+            controller_delegate->on_menu_closed_notify_type());
+  EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
+}
+
+// Tests that dragging within an asynchronous menu notifies the
+// MenuControllerDelegate for shutdown.
+TEST_F(MenuControllerTest, AsynchronousDragComplete) {
+  MenuController* controller = menu_controller();
+  controller->SetAsyncRun(true);
+
+  controller->OnDragWillStart();
+  controller->OnDragComplete(true);
+
+  EXPECT_FALSE(controller->drag_in_progress());
+  TestMenuControllerDelegate* controller_delegate = menu_controller_delegate();
+  EXPECT_EQ(0, controller_delegate->on_menu_closed_called());
+
+  // Closing from drag and drop is enqueued. The message to
+  // MenuControllerDelegate occurs afterwards so that the destruction of
+  // MenuController does no free the layers who are still referenced in enqueued
+  // tasks.
+  RunPendingMessages();
+  EXPECT_EQ(1, controller_delegate->on_menu_closed_called());
+  EXPECT_EQ(nullptr, controller_delegate->on_menu_closed_menu());
+  EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
+            controller_delegate->on_menu_closed_notify_type());
+  EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
+}
+
+// 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();
+  scoped_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(),
+                      MENU_ANCHOR_TOPLEFT, false, false, &mouse_event_flags);
+  EXPECT_EQ(run_result, nullptr);
+
+  controller->CancelAll();
+  EXPECT_EQ(1, delegate->on_menu_closed_called());
+  EXPECT_EQ(1, nested_delegate->on_menu_closed_called());
+}
+
 }  // namespace test
 }  // namespace views