Cleanup MenuRunner API

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 55 matching lines @@
       // happening because the object referencing the menu has been destroyed
       // and the menu button is no longer valid.
       controller_->Cancel(MenuController::EXIT_DESTROYED);
       return;
     }
   }
 
   delete this;
 }
 
-MenuRunner::RunResult MenuRunnerImpl::RunMenuAt(Widget* parent,
-                                                MenuButton* button,
-                                                const gfx::Rect& bounds,
-                                                MenuAnchorPosition anchor,
-                                                int32_t run_types) {
+void MenuRunnerImpl::RunMenuAt(Widget* parent,
+                               MenuButton* button,
+                               const gfx::Rect& bounds,
+                               MenuAnchorPosition anchor,
+                               int32_t run_types) {
   closing_event_time_ = base::TimeTicks();
   if (running_) {
     // Ignore requests to show the menu while it's already showing. MenuItemView
     // doesn't handle this very well (meaning it crashes).
-    return MenuRunner::NORMAL_EXIT;
+    return;
   }
 
   MenuController* controller = MenuController::GetActiveInstance();
   if (controller) {
     if ((run_types & MenuRunner::IS_NESTED) != 0) {
       if (!controller->IsBlockingRun()) {
         controller->CancelAll();
         controller = NULL;
       } else {
         // Only nest the delegate when not cancelling drag-and-drop. When
         // cancelling this will become the root delegate of the new
         // MenuController
         controller->AddNestedDelegate(this);
       }
     } else {
       // There's some other menu open and we're not nested. Cancel the menu.
       controller->CancelAll();
       if ((run_types & MenuRunner::FOR_DROP) == 0) {
         // We can't open another menu, otherwise the message loop would become
         // twice nested. This isn't necessarily a problem, but generally isn't
         // expected.
-        return MenuRunner::NORMAL_EXIT;
+        return;
       }
       // Drop menus don't block the message loop, so it's ok to create a new
       // MenuController.
       controller = NULL;
     }
   }
 
   running_ = true;
   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->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));
 
-  int mouse_event_flags = 0;
   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;
+                  (run_types & MenuRunner::NESTED_DRAG) != 0);
 }
 
 void MenuRunnerImpl::Cancel() {
   if (running_)
     controller_->Cancel(MenuController::EXIT_ALL);
 }
 
 base::TimeTicks MenuRunnerImpl::GetClosingEventTime() const {
   return closing_event_time_;
 }
@@ skipping 22 matching lines @@
   running_ = false;
   if (menu_->GetDelegate()) {
     // Executing the command may also delete this.
     base::WeakPtr<MenuRunnerImpl> ref(weak_factory_.GetWeakPtr());
     if (menu && !for_drop_) {
       // Do not execute the menu that was dragged/dropped.
       menu_->GetDelegate()->ExecuteCommand(menu->GetCommand(),
                                            mouse_event_flags);
     }
     // Only notify the delegate if it did not delete this.
-    if (!ref)
-      return;
-    else if (type == NOTIFY_DELEGATE)
-      menu_->GetDelegate()->OnMenuClosed(menu, MenuRunner::NORMAL_EXIT);
+    if (ref && type == NOTIFY_DELEGATE)
+      menu_->GetDelegate()->OnMenuClosed(menu);
   }
 }
 
 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