Moves ownership of MenuItemView to MenuRunner as well as responbility

views/controls/menu/menu_item_view.cc

 // 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.
 
 #include "views/controls/menu/menu_item_view.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ui_strings.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/canvas.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/button/text_button.h"
 #include "views/controls/menu/menu_config.h"
 #include "views/controls/menu/menu_controller.h"
 #include "views/controls/menu/menu_separator.h"
 #include "views/controls/menu/submenu_view.h"
 
-#if defined(OS_WIN)
-#include "base/win/win_util.h"
-#endif
-
 namespace views {
 
 namespace {
 
 // EmptyMenuMenuItem ---------------------------------------------------------
 
 // EmptyMenuMenuItem is used when a menu has no menu items. EmptyMenuMenuItem
 // is itself a MenuItemView, but it uses a different ID so that it isn't
 // identified as a MenuItemView.
 
@@ skipping 57 matching lines @@
       has_icons_(false),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
       actual_menu_position_(requested_menu_position_) {
   // NOTE: don't check the delegate for NULL, UpdateMenuPartSizes supplies a
   // NULL delegate.
   Init(NULL, 0, SUBMENU, delegate);
 }
 
-MenuItemView::~MenuItemView() {
-  // TODO(sky): ownership is bit wrong now. In particular if a nested message
-  // loop is running deletion can't be done, otherwise the stack gets
-  // thoroughly screwed. The destructor should be made private, and
-  // MenuController should be the only place handling deletion of the menu.
-  // (57890).
-  delete submenu_;
-  STLDeleteElements(&removed_items_);
-}
-
 void MenuItemView::ChildPreferredSizeChanged(View* child) {
   pref_size_.SetSize(0, 0);
   PreferredSizeChanged();
 }
 
 bool MenuItemView::GetTooltipText(const gfx::Point& p, std::wstring* tooltip) {
   *tooltip = UTF16ToWideHack(tooltip_);
   if (!tooltip->empty())
     return true;
 
@@ skipping 62 matching lines @@
 
   // Append accelerator text.
   if (!accelerator_text.empty()) {
     accessible_name.push_back(' ');
     accessible_name.append(accelerator_text);
   }
 
   return accessible_name;
 }
 
-void MenuItemView::RunMenuAt(Widget* parent,
-                             MenuButton* button,
-                             const gfx::Rect& bounds,
-                             AnchorPosition anchor,
-                             bool has_mnemonics) {
-  // Show mnemonics if the button has focus or alt is pressed.
-  bool show_mnemonics = button ? button->HasFocus() : false;
-#if defined(OS_WIN)
-  // We don't currently need this on gtk as showing the menu gives focus to the
-  // button first.
-  if (!show_mnemonics)
-    show_mnemonics = base::win::IsAltPressed();
-#endif
-  PrepareForRun(has_mnemonics, show_mnemonics);
-  int mouse_event_flags;
-
-  MenuController* controller = MenuController::GetActiveInstance();
-  if (controller && !controller->IsBlockingRun()) {
-    // A menu is already showing, but it isn't a blocking menu. Cancel it.
-    // We can get here during drag and drop if the user right clicks on the
-    // menu quickly after the drop.
-    controller->Cancel(MenuController::EXIT_ALL);
-    controller = NULL;
-  }
-  // TODO(sky): remove volatile, used in tracking 90860.
-  volatile bool owns_controller = false;
-  if (!controller) {
-    // No menus are showing, show one.
-    controller = new MenuController(true);
-    MenuController::SetActiveInstance(controller);
-    owns_controller = true;
-  } else {
-    // A menu is already showing, use the same controller.
-
-    // Don't support blocking from within non-blocking.
-    DCHECK(controller->IsBlockingRun());
-  }
-
-  controller_ = controller;
-
-  // Run the loop.
-  MenuItemView* result =
-      controller->Run(parent, button, this, bounds, anchor, &mouse_event_flags);
-
-  RemoveEmptyMenus();
-
-  controller_ = NULL;
-
-  if (owns_controller) {
-    // We created the controller and need to delete it.
-    if (MenuController::GetActiveInstance() == controller)
-      MenuController::SetActiveInstance(NULL);
-    delete controller;
-  }
-  // Make sure all the windows we created to show the menus have been
-  // destroyed.
-  DestroyAllMenuHosts();
-  if (result && delegate_)
-    delegate_->ExecuteCommand(result->GetCommand(), mouse_event_flags);
-}
-
-void MenuItemView::RunMenuForDropAt(Widget* parent,
-                                    const gfx::Rect& bounds,
-                                    AnchorPosition anchor) {
-  PrepareForRun(false, false);
-
-  // If there is a menu, hide it so that only one menu is shown during dnd.
-  MenuController* current_controller = MenuController::GetActiveInstance();
-  if (current_controller) {
-    current_controller->Cancel(MenuController::EXIT_ALL);
-  }
-
-  // Always create a new controller for non-blocking.
-  controller_ = new MenuController(false);
-
-  // Set the instance, that way it can be canceled by another menu.
-  MenuController::SetActiveInstance(controller_);
-
-  controller_->Run(parent, NULL, this, bounds, anchor, NULL);
-}
-
 void MenuItemView::Cancel() {
   if (controller_ && !canceled_) {
     canceled_ = true;
     controller_->Cancel(MenuController::EXIT_ALL);
   }
 }
 
 MenuItemView* MenuItemView::AddMenuItemAt(int index,
                                           int item_id,
                                           const std::wstring& label,
@@ skipping 266 matching lines @@
       has_mnemonics_(false),
       show_mnemonics_(false),
       has_icons_(false),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
       actual_menu_position_(requested_menu_position_) {
   Init(parent, command, type, NULL);
 }
 
+MenuItemView::~MenuItemView() {
+  delete submenu_;
+  STLDeleteElements(&removed_items_);
+}
+
 std::string MenuItemView::GetClassName() const {
   return kViewClassName;
 }
 
 // Calculates all sizes that we can from the OS.
 //
 // This is invoked prior to Running a menu.
 void MenuItemView::UpdateMenuPartSizes(bool has_icons) {
   MenuConfig::Reset();
   const MenuConfig& config = MenuConfig::instance();
@@ skipping 34 matching lines @@
   set_id(kMenuItemViewID);
   has_icons_ = false;
 
   // Don't request enabled status from the root menu item as it is just
   // a container for real items.  EMPTY items will be disabled.
   MenuDelegate* root_delegate = GetDelegate();
   if (parent && type != EMPTY && root_delegate)
     SetEnabled(root_delegate->IsCommandEnabled(command));
 }
 
-void MenuItemView::DropMenuClosed(bool notify_delegate) {
-  DCHECK(controller_);
-  DCHECK(!controller_->IsBlockingRun());
-  if (MenuController::GetActiveInstance() == controller_)
-    MenuController::SetActiveInstance(NULL);
-  delete controller_;
-  controller_ = NULL;
-
-  RemoveEmptyMenus();
-
-  if (notify_delegate && delegate_) {
-    // Our delegate is null when invoked from the destructor.
-    delegate_->DropMenuClosed(this);
-  }
-  // WARNING: its possible the delegate deleted us at this point.
-}
-
 void MenuItemView::PrepareForRun(bool has_mnemonics, bool show_mnemonics) {
   // Currently we only support showing the root.
   DCHECK(!parent_menu_item_);
 
   // Force us to have a submenu.
   CreateSubmenu();
   actual_menu_position_ = requested_menu_position_;
   canceled_ = false;
 
   has_mnemonics_ = has_mnemonics;
@@ skipping 153 matching lines @@
     return string16();
   }
 
   Accelerator accelerator;
   return (GetDelegate() &&
           GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) ?
       accelerator.GetShortcutText() : string16();
 }
 
 }  // namespace views