Cleanup MenuRunner API

ui/views/controls/menu/menu_runner.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_RUNNER_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_RUNNER_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 27 matching lines @@
 namespace internal {
 class DisplayChangeListener;
 class MenuRunnerImplInterface;
 }
 
 namespace test {
 class MenuRunnerTestAPI;
 }
 
 // MenuRunner is responsible for showing (running) the menu and additionally
-// owning the MenuItemView. RunMenuAt() runs a nested message loop. It is safe
-// to delete MenuRunner at any point, but MenuRunner internally only deletes the
-// MenuItemView *after* the nested message loop completes. If MenuRunner is
-// deleted while the menu is showing the delegate of the menu is reset. This is
-// done to ensure delegates aren't notified after they may have been deleted.
-//
-// NOTE: while you can delete a MenuRunner at any point, the nested message loop
-// won't return immediately. This means if you delete the object that owns
-// the MenuRunner while the menu is running, your object is effectively still
-// on the stack. A return value of MENU_DELETED indicated this. In most cases
-// if RunMenuAt() returns MENU_DELETED, you should return immediately.
+// owning the MenuItemView. It is safe to delete MenuRunner at any point, but
+// MenuRunner will not notify you of the closure caused by a deletion.
+// If MenuRunner is deleted while the menu is showing the delegate of the menu
+// is reset. This is done to ensure delegates aren't notified after they may
+// have been deleted.
 //
 // Similarly you should avoid creating MenuRunner on the stack. Doing so means
 // MenuRunner may not be immediately destroyed if your object is destroyed,
 // resulting in possible callbacks to your now deleted object. Instead you
 // should define MenuRunner as a scoped_ptr in your class so that when your
 // object is destroyed MenuRunner initiates the proper cleanup and ensures your
 // object isn't accessed again.
 class VIEWS_EXPORT MenuRunner {
  public:
   enum RunTypes {
@@ skipping 15 matching lines @@
 
     // The menu should behave like a Windows native Combobox dropdow menu.
     // This behavior includes accepting the pending item and closing on F4.
     COMBOBOX = 1 << 4,
 
     // A child view is performing a drag-and-drop operation, so the menu should
     // stay open (even if it doesn't receive drag updated events). In this case,
     // the caller is responsible for closing the menu upon completion of the
     // drag-and-drop.
     NESTED_DRAG = 1 << 5,
-
-    // Used for showing a menu which does NOT block the caller. Instead the
-    // delegate is notified when the menu closes via OnMenuClosed.
-    ASYNC = 1 << 6,
-  };
-
-  enum RunResult {
-    // Indicates RunMenuAt is returning because the MenuRunner was deleted.
-    MENU_DELETED,
-
-    // Indicates RunMenuAt returned and MenuRunner was not deleted.
-    NORMAL_EXIT
   };
 
   // Creates a new MenuRunner, which may use a native menu if available.
   // |run_types| is a bitmask of RunTypes. If provided,
   // |on_menu_closed_callback| is invoked when the menu is closed.
   // Note that with a native menu (e.g. on Mac), the ASYNC flag in |run_types|
   // may be ignored. See http://crbug.com/682544.
   MenuRunner(ui::MenuModel* menu_model,
              int32_t run_types,
              const base::Closure& on_menu_closed_callback = base::Closure());
 
   // Creates a runner for a custom-created toolkit-views menu.
   MenuRunner(MenuItemView* menu, int32_t run_types);
   ~MenuRunner();
 
-  // Runs the menu. If this returns MENU_DELETED the method is returning
-  // because the MenuRunner was deleted.
-  // Typically callers should NOT do any processing if this returns
-  // MENU_DELETED.
+  // Runs the menu. MenuDelegate::OnMenuClosed will be notified of the results.
   // If |anchor| uses a |BUBBLE_..| type, the bounds will get determined by
   // using |bounds| as the thing to point at in screen coordinates.
-  RunResult RunMenuAt(Widget* parent,
-                      MenuButton* button,
-                      const gfx::Rect& bounds,
-                      MenuAnchorPosition anchor,
-                      ui::MenuSourceType source_type);
+  void RunMenuAt(Widget* parent,
+                 MenuButton* button,
+                 const gfx::Rect& bounds,
+                 MenuAnchorPosition anchor,
+                 ui::MenuSourceType source_type);
 
   // Returns true if we're in a nested message loop running the menu.
   bool IsRunning() const;
 
   // Hides and cancels the menu. This does nothing if the menu is not open.
   void Cancel();
 
   // Returns the time from the event which closed the menu - or 0.
   base::TimeTicks closing_event_time() const;
 
@@ skipping 33 matching lines @@
 
  protected:
   DisplayChangeListener() {}
 };
 
 }  // namespace internal
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_RUNNER_H_