Delete MenuController Nested Message Loop

ui/views/controls/menu/menu_runner_impl.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_runner_impl.h"
 
 #include "build/build_config.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/menu/menu_controller.h"
@@ skipping 15 matching lines @@
     int32_t run_types,
     const base::Closure& on_menu_closed_callback) {
   return new MenuRunnerImplAdapter(menu_model, on_menu_closed_callback);
 }
 #endif
 
 MenuRunnerImpl::MenuRunnerImpl(MenuItemView* menu)
     : menu_(menu),
       running_(false),
       delete_after_run_(false),
-      async_(false),
       for_drop_(false),
       controller_(NULL),
       owns_controller_(false),
       weak_factory_(this) {}
 
 bool MenuRunnerImpl::IsRunning() const {
   return running_;
 }
 
 void MenuRunnerImpl::Release() {
@@ skipping 60 matching lines @@
         // expected.
         return MenuRunner::NORMAL_EXIT;
       }
       // Drop menus don't block the message loop, so it's ok to create a new
       // MenuController.
       controller = NULL;
     }
   }
 
   running_ = true;
-  async_ = (run_types & MenuRunner::ASYNC) != 0;
   for_drop_ = (run_types & MenuRunner::FOR_DROP) != 0;
   bool has_mnemonics = (run_types & MenuRunner::HAS_MNEMONICS) != 0;
   owns_controller_ = false;
   if (!controller) {
     // No menus are showing, show one.
     controller = new MenuController(!for_drop_, this);
     owns_controller_ = true;
   }
-  controller->SetAsyncRun(async_);
   controller->set_is_combobox((run_types & MenuRunner::COMBOBOX) != 0);
   controller_ = controller->AsWeakPtr();
   menu_->set_controller(controller_.get());
   menu_->PrepareForRun(owns_controller_,
                        has_mnemonics,
                        !for_drop_ && ShouldShowMnemonics(button));
 
-  // Run the loop.
   int mouse_event_flags = 0;
-  MenuItemView* result =
-      controller->Run(parent,
-                      button,
-                      menu_,
-                      bounds,
-                      anchor,
-                      (run_types & MenuRunner::CONTEXT_MENU) != 0,
-                      (run_types & MenuRunner::NESTED_DRAG) != 0,
-                      &mouse_event_flags);
-  // Get the time of the event which closed this menu.
-  closing_event_time_ = controller->closing_event_time();
-  if (for_drop_ || async_) {
-    // Drop and asynchronous menus return immediately. We finish processing in
-    // OnMenuClosed.
-    return MenuRunner::NORMAL_EXIT;
-  }
-  return MenuDone(NOTIFY_DELEGATE, result, mouse_event_flags);
+  controller->Run(parent, button, menu_, bounds, anchor,
+                  (run_types & MenuRunner::CONTEXT_MENU) != 0,
+                  (run_types & MenuRunner::NESTED_DRAG) != 0,
+                  &mouse_event_flags);
+  // We finish processing results in OnMenuClosed.
+  return MenuRunner::NORMAL_EXIT;
 }
 
 void MenuRunnerImpl::Cancel() {
   if (running_)
     controller_->Cancel(MenuController::EXIT_ALL);
 }
 
 base::TimeTicks MenuRunnerImpl::GetClosingEventTime() const {
   return closing_event_time_;
 }
 
 void MenuRunnerImpl::OnMenuClosed(NotifyType type,
                                   MenuItemView* menu,
                                   int mouse_event_flags) {
-  MenuDone(type, menu, mouse_event_flags);
-}
-
-void MenuRunnerImpl::SiblingMenuCreated(MenuItemView* menu) {
-  if (menu != menu_ && sibling_menus_.count(menu) == 0)
-    sibling_menus_.insert(menu);
-}
-
-MenuRunnerImpl::~MenuRunnerImpl() {
-  delete menu_;
-  for (std::set<MenuItemView*>::iterator i = sibling_menus_.begin();
-       i != sibling_menus_.end();
-       ++i)
-    delete *i;
-}
-
-MenuRunner::RunResult MenuRunnerImpl::MenuDone(NotifyType type,
-                                               MenuItemView* result,
-                                               int mouse_event_flags) {
+  if (controller_)
+    closing_event_time_ = controller_->closing_event_time();
   menu_->RemoveEmptyMenus();
   menu_->set_controller(nullptr);
 
   if (owns_controller_ && controller_) {
     // We created the controller and need to delete it.
     delete controller_.get();
     owns_controller_ = false;
   }
   controller_ = nullptr;
   // Make sure all the windows we created to show the menus have been
   // destroyed.
   menu_->DestroyAllMenuHosts();
   if (delete_after_run_) {
     delete this;
-    return MenuRunner::MENU_DELETED;
+    return;
   }
   running_ = false;
   if (menu_->GetDelegate()) {
     // Executing the command may also delete this.
     base::WeakPtr<MenuRunnerImpl> ref(weak_factory_.GetWeakPtr());
-    if (result && !for_drop_) {
+    if (menu && !for_drop_) {
       // Do not execute the menu that was dragged/dropped.
-      menu_->GetDelegate()->ExecuteCommand(result->GetCommand(),
+      menu_->GetDelegate()->ExecuteCommand(menu->GetCommand(),
                                            mouse_event_flags);
     }
     // Only notify the delegate if it did not delete this.
     if (!ref)
-      return MenuRunner::MENU_DELETED;
+      return;
     else if (type == NOTIFY_DELEGATE)
-      menu_->GetDelegate()->OnMenuClosed(result, MenuRunner::NORMAL_EXIT);
+      menu_->GetDelegate()->OnMenuClosed(menu, MenuRunner::NORMAL_EXIT);
   }
-  return MenuRunner::NORMAL_EXIT;
+}
+
+void MenuRunnerImpl::SiblingMenuCreated(MenuItemView* menu) {
+  if (menu != menu_ && sibling_menus_.count(menu) == 0)
+    sibling_menus_.insert(menu);
+}
+
+MenuRunnerImpl::~MenuRunnerImpl() {
+  delete menu_;
+  for (std::set<MenuItemView*>::iterator i = sibling_menus_.begin();
+       i != sibling_menus_.end(); ++i)
+    delete *i;
 }
 
 bool MenuRunnerImpl::ShouldShowMnemonics(MenuButton* button) {
   // Show mnemonics if the button has focus or alt is pressed.
   bool show_mnemonics = button ? button->HasFocus() : false;
 #if defined(OS_WIN)
   // This is only needed on Windows.
   if (!show_mnemonics)
     show_mnemonics = ui::win::IsAltPressed();
 #endif
   return show_mnemonics;
 }
 
 }  // namespace internal
 }  // namespace views