Moves ownership of MenuItemView to MenuRunner as well as responbility

views/controls/menu/menu_item_view.h

 // Copyright (c) 2011 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 VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #define VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 namespace gfx {
 class Font;
 }
 
 namespace ui {
 class MenuModel;
 }
 
 namespace views {
 
+namespace internal {
+class MenuRunnerImpl;
+}
+
 class MenuButton;
+struct MenuConfig;
 class MenuController;
 class MenuDelegate;
 class SubmenuView;
 
-struct MenuConfig;
-
 // MenuItemView --------------------------------------------------------------
 
 // MenuItemView represents a single menu item with a label and optional icon.
 // Each MenuItemView may also contain a submenu, which in turn may contain
 // any number of child MenuItemViews.
 //
 // To use a menu create an initial MenuItemView using the constructor that
 // takes a MenuDelegate, then create any number of child menu items by way
 // of the various AddXXX methods.
 //
 // MenuItemView is itself a View, which means you can add Views to each
 // MenuItemView. This is normally NOT want you want, rather add other child
 // Views to the submenu of the MenuItemView. Any child views of the MenuItemView
 // that are focusable can be navigated to by way of the up/down arrow and can be
 // activated by way of space/return keys. Activating a focusable child results
 // in |AcceleratorPressed| being invoked. Note, that as menus try not to steal
 // focus from the hosting window child views do not actually get focus. Instead
 // |SetHotTracked| is used as the user navigates around.
 //
-// There are two ways to show a MenuItemView:
-// 1. Use RunMenuAt. This blocks the caller, executing the selected command
-//    on success.
-// 2. Use RunMenuForDropAt. This is intended for use during a drop session
-//    and does NOT block the caller. Instead the delegate is notified when the
-//    menu closes via the DropMenuClosed method.
+// To show the menu use MenuRunner. See MenuRunner for details on how to run
+// (show) the menu as well as for details on the life time of the menu.
 
 class VIEWS_EXPORT MenuItemView : public View {
  public:
   friend class MenuController;
 
   // The menu item view's class name.
   static const char kViewClassName[];
 
   // ID used to identify menu items.
   static const int kMenuItemViewID;
@@ skipping 26 matching lines @@
   enum MenuPosition {
     POSITION_BEST_FIT,
     POSITION_ABOVE_BOUNDS,
     POSITION_BELOW_BOUNDS
   };
 
   // Constructor for use with the top level menu item. This menu is never
   // shown to the user, rather its use as the parent for all menu items.
   explicit MenuItemView(MenuDelegate* delegate);
 
-  virtual ~MenuItemView();
-
   // Overridden from View:
   virtual bool GetTooltipText(const gfx::Point& p,
                               std::wstring* tooltip) OVERRIDE;
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
 
   // Returns the preferred height of menu items. This is only valid when the
   // menu is about to be shown.
   static int pref_menu_height() { return pref_menu_height_; }
 
   // X-coordinate of where the label starts.
   static int label_start() { return label_start_; }
 
   // Returns the accessible name to be used with screen readers. Mnemonics are
   // removed and the menu item accelerator text is appended.
   static string16 GetAccessibleNameForMenuItem(
       const string16& item_text, const string16& accelerator_text);
 
-  // Run methods. See description above class for details. Both Run methods take
-  // a rectangle, which is used to position the menu. |has_mnemonics| indicates
-  // whether the items have mnemonics. Mnemonics are identified by way of the
-  // character following the '&'.  The anchor position is specified for non-RTL
-  // languages; the opposite value will be used for RTL.
-  void RunMenuAt(Widget* parent,
-                 MenuButton* button,
-                 const gfx::Rect& bounds,
-                 AnchorPosition anchor,
-                 bool has_mnemonics);
-  void RunMenuForDropAt(Widget* parent,
-                        const gfx::Rect& bounds,
-                        AnchorPosition anchor);
-
   // Hides and cancels the menu. This does nothing if the menu is not open.
   void Cancel();
 
   // Add an item to the menu at a specified index.  ChildrenChanged() should
   // called after adding menu items if the menu may be active.
   MenuItemView* AddMenuItemAt(int index,
                               int item_id,
                               const std::wstring& label,
                               const SkBitmap& icon,
                               Type type);
@@ skipping 124 matching lines @@
   virtual void OnPaint(gfx::Canvas* canvas);
 
   // Returns the preferred size of this item.
   virtual gfx::Size GetPreferredSize();
 
   // Returns the object responsible for controlling showing the menu.
   MenuController* GetMenuController();
 
   // Returns the delegate. This returns the delegate of the root menu item.
   MenuDelegate* GetDelegate();
+  void set_delegate(MenuDelegate* delegate) { delegate_ = delegate; }
 
   // Returns the root parent, or this if this has no parent.
   MenuItemView* GetRootMenuItem();
 
   // Returns the mnemonic for this MenuItemView, or 0 if this MenuItemView
   // doesn't have a mnemonic.
   char16 GetMnemonic();
 
   // Do we have icons? This only has effect on the top menu. Turning this on
   // makes the menus slightly wider and taller.
@@ skipping 26 matching lines @@
   // Set the position of the menu with respect to the bounds (top
   // level only).
   void set_menu_position(MenuPosition menu_position) {
     requested_menu_position_ = menu_position;
   }
 
  protected:
   // Creates a MenuItemView. This is used by the various AddXXX methods.
   MenuItemView(MenuItemView* parent, int command, Type type);
 
+  // MenuRunner owns MenuItemView and should be the only one deleting it.
+  virtual ~MenuItemView();
+
   virtual void ChildPreferredSizeChanged(View* child) OVERRIDE;
 
   virtual std::string GetClassName() const OVERRIDE;
 
  private:
+  friend class internal::MenuRunnerImpl;  // For access to ~MenuItemView.
+
   // Calculates all sizes that we can from the OS.
   //
   // This is invoked prior to Running a menu.
   static void UpdateMenuPartSizes(bool has_icons);
 
   // Called by the two constructors to initialize this menu item.
   void Init(MenuItemView* parent,
             int command,
             MenuItemView::Type type,
             MenuDelegate* delegate);
 
-  // Invoked by the MenuController when the menu closes as the result of
-  // drag and drop run.
-  void DropMenuClosed(bool notify_delegate);
-
   // The RunXXX methods call into this to set up the necessary state before
   // running.
   void PrepareForRun(bool has_mnemonics, bool show_mnemonics);
 
   // Returns the flags passed to DrawStringInt.
   int GetDrawStringFlags();
 
   // Returns the font to use for menu text.
   const gfx::Font& GetFont();
 
@@ skipping 44 matching lines @@
   // Calculates the preferred size.
   gfx::Size CalculatePreferredSize();
 
   // Used by MenuController to cache the menu position in use by the
   // active menu.
   MenuPosition actual_menu_position() const { return actual_menu_position_; }
   void set_actual_menu_position(MenuPosition actual_menu_position) {
     actual_menu_position_ = actual_menu_position;
   }
 
+  void set_controller(MenuController* controller) { controller_ = controller; }
+
   // The delegate. This is only valid for the root menu item. You shouldn't
   // use this directly, instead use GetDelegate() which walks the tree as
   // as necessary.
   MenuDelegate* delegate_;
 
-  // Returns the controller for the run operation, or NULL if the menu isn't
-  // showing.
+  // The controller for the run operation, or NULL if the menu isn't showing.
   MenuController* controller_;
 
   // Used to detect when Cancel was invoked.
   bool canceled_;
 
   // Our parent.
   MenuItemView* parent_menu_item_;
 
   // Type of menu. NOTE: MenuItemView doesn't itself represent SEPARATOR,
   // that is handled by an entirely different view class.
@@ skipping 54 matching lines @@
   // position of the menu being shown.
   MenuPosition requested_menu_position_;
   MenuPosition actual_menu_position_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuItemView);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_