Makes it so that when a folder is open on the bookmark bar and the...

views/controls/menu/menu_item_view.cc

 // Copyright (c) 2006-2008 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 "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "grit/app_strings.h"
 #include "views/controls/menu/menu_config.h"
@@ skipping 48 matching lines @@
 // static
 int MenuItemView::pref_menu_height_;
 
 MenuItemView::MenuItemView(MenuDelegate* delegate) {
   // NOTE: don't check the delegate for NULL, UpdateMenuPartSizes supplies a
   // NULL delegate.
   Init(NULL, 0, SUBMENU, delegate);
 }
 
 MenuItemView::~MenuItemView() {
-  if (controller_) {
-    // We're currently showing.
-
-    // We can't delete ourselves while we're blocking.
-    DCHECK(!controller_->IsBlockingRun());
-
-    // Invoking Cancel is going to call us back and notify the delegate.
-    // Notifying the delegate from the destructor can be problematic. To avoid
-    // this the delegate is set to NULL.
-    delegate_ = NULL;
-
-    controller_->Cancel(true);
-  }
+  // 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.
   delete submenu_;
 }
 
 void MenuItemView::RunMenuAt(gfx::NativeWindow parent,
+                             MenuButton* button,
                              const gfx::Rect& bounds,
                              AnchorPosition anchor,
                              bool has_mnemonics) {
   PrepareForRun(has_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.
@@ skipping 12 matching lines @@
     // 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, this, bounds, anchor, &mouse_event_flags);
+      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;
@@ skipping 15 matching lines @@
   if (current_controller) {
     current_controller->Cancel(true);
   }
 
   // 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, this, bounds, anchor, NULL);
+  controller_->Run(parent, NULL, this, bounds, anchor, NULL);
 }
 
 void MenuItemView::Cancel() {
   if (controller_ && !canceled_) {
     canceled_ = true;
     controller_->Cancel(true);
   }
 }
 
 SubmenuView* MenuItemView::CreateSubmenu() {
@@ skipping 165 matching lines @@
     // 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) {
   // Currently we only support showing the root.
   DCHECK(!parent_menu_item_);
 
-  // Don't invoke run from within run on the same menu.
-  DCHECK(!controller_);
-
   // Force us to have a submenu.
   CreateSubmenu();
 
   canceled_ = false;
 
   has_mnemonics_ = has_mnemonics;
 
   AddEmptyMenus();
 
   if (!MenuController::GetActiveInstance()) {
@@ skipping 73 matching lines @@
 }
 
 int MenuItemView::GetBottomMargin() {
   MenuItemView* root = GetRootMenuItem();
   return root && root->has_icons_
       ? MenuConfig::instance().item_bottom_margin :
         MenuConfig::instance().item_no_icon_bottom_margin;
 }
 
 }  // namespace views