Resubmit: Open the WrenchMenu on mouseover when dragging a browser action

chrome/browser/ui/views/toolbar/wrench_menu.cc

 // Copyright 2013 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 "chrome/browser/ui/views/toolbar/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 554 matching lines @@
                    int paste_index)
       : WrenchMenuView(menu, menu_model) {
     InMenuButton* cut = CreateAndConfigureButton(
         IDS_CUT, InMenuButtonBackground::LEFT_BUTTON,
         cut_index);
     InMenuButton* copy = CreateAndConfigureButton(
         IDS_COPY, InMenuButtonBackground::CENTER_BUTTON,
         copy_index);
     InMenuButton* paste = CreateAndConfigureButton(
         IDS_PASTE,
-        menu->use_new_menu() && menu->supports_new_separators_ ?
+        menu->use_new_menu() && menu->supports_new_separators() ?
             InMenuButtonBackground::CENTER_BUTTON :
             InMenuButtonBackground::RIGHT_BUTTON,
         paste_index);
     copy->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() const OVERRIDE {
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview.
@@ skipping 61 matching lines @@
     decrement_button_ = CreateButtonWithAccName(
         IDS_ZOOM_MINUS2, InMenuButtonBackground::LEFT_BUTTON,
         decrement_index, IDS_ACCNAME_ZOOM_MINUS2);
 
     zoom_label_ = new Label(
         l10n_util::GetStringFUTF16Int(IDS_ZOOM_PERCENT, 100));
     zoom_label_->SetAutoColorReadabilityEnabled(false);
     zoom_label_->SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 
     InMenuButtonBackground* center_bg = new InMenuButtonBackground(
-        menu->use_new_menu() && menu->supports_new_separators_ ?
+        menu->use_new_menu() && menu->supports_new_separators() ?
             InMenuButtonBackground::RIGHT_BUTTON :
             InMenuButtonBackground::CENTER_BUTTON,
         menu->use_new_menu());
     zoom_label_->set_background(center_bg);
 
     AddChildView(zoom_label_);
     zoom_label_width_ = MaxWidthForZoomLabel();
 
     increment_button_ = CreateButtonWithAccName(
         IDS_ZOOM_PLUS2, InMenuButtonBackground::RIGHT_BUTTON,
@@ skipping 271 matching lines @@
  private:
   WrenchMenu* wrench_menu_;
   ui::MenuModel* model_;
   views::MenuItemView* menu_item_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentTabsMenuModelDelegate);
 };
 
 // WrenchMenu ------------------------------------------------------------------
 
-WrenchMenu::WrenchMenu(Browser* browser,
-                       bool use_new_menu,
-                       bool supports_new_separators)
+WrenchMenu::WrenchMenu(Browser* browser, int run_flags)
     : root_(NULL),
       browser_(browser),
       selected_menu_model_(NULL),
       selected_index_(0),
       bookmark_menu_(NULL),
       feedback_menu_item_(NULL),
-      use_new_menu_(use_new_menu),
-      supports_new_separators_(supports_new_separators) {
+      run_flags_(run_flags) {
   registrar_.Add(this, chrome::NOTIFICATION_GLOBAL_ERRORS_CHANGED,
                  content::Source<Profile>(browser_->profile()));
 }
 
 WrenchMenu::~WrenchMenu() {
   if (bookmark_menu_delegate_.get()) {
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(
         browser_->profile());
     if (model)
       model->RemoveObserver(this);
   }
   FOR_EACH_OBSERVER(WrenchMenuObserver, observer_list_, WrenchMenuDestroyed());
 }
 
 void WrenchMenu::Init(ui::MenuModel* model) {
   DCHECK(!root_);
   root_ = new MenuItemView(this);
   root_->set_has_icons(true);  // We have checks, radios and icons, set this
                                // so we get the taller menu style.
   PopulateMenu(root_, model);
 
 #if defined(DEBUG)
   // Verify that the reserved command ID's for bookmarks menu are not used.
   for (int i = WrenchMenuModel:kMinBookmarkCommandId;
        i <= WrenchMenuModel::kMaxBookmarkCommandId; ++i)
     DCHECK(command_id_to_entry_.find(i) == command_id_to_entry_.end());
 #endif  // defined(DEBUG)
 
-  menu_runner_.reset(
-      new views::MenuRunner(root_, views::MenuRunner::HAS_MNEMONICS));
+  int32 types = views::MenuRunner::HAS_MNEMONICS;
+  if (for_drop()) {
+    // We add NESTED_DRAG since currently the only operation to open the wrench
+    // menu for is an extension action drag, which is controlled by the child
+    // BrowserActionsContainer view.
+    types |= views::MenuRunner::FOR_DROP | views::MenuRunner::NESTED_DRAG;
+  }
+  menu_runner_.reset(new views::MenuRunner(root_, types));
 }
 
 void WrenchMenu::RunMenu(views::MenuButton* host) {
   gfx::Point screen_loc;
   views::View::ConvertPointToScreen(host, &screen_loc);
   gfx::Rect bounds(screen_loc, host->size());
   content::RecordAction(UserMetricsAction("ShowAppMenu"));
   if (menu_runner_->RunMenuAt(host->GetWidget(),
                               host,
                               bounds,
                               views::MENU_ANCHOR_TOPRIGHT,
                               ui::MENU_SOURCE_NONE) ==
       views::MenuRunner::MENU_DELETED)
     return;
   if (bookmark_menu_delegate_.get()) {
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(
         browser_->profile());
     if (model)
       model->RemoveObserver(this);
   }
   if (selected_menu_model_)
     selected_menu_model_->ActivatedAt(selected_index_);
 }
 
+void WrenchMenu::CloseMenu() {
+  if (menu_runner_.get())
+    menu_runner_->Cancel();
+}
+
 bool WrenchMenu::IsShowing() {
   return menu_runner_.get() && menu_runner_->IsRunning();
 }
 
 void WrenchMenu::AddObserver(WrenchMenuObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void WrenchMenu::RemoveObserver(WrenchMenuObserver* observer) {
   observer_list_.RemoveObserver(observer);
@@ skipping 221 matching lines @@
       NOTREACHED();
   }
 }
 
 void WrenchMenu::PopulateMenu(MenuItemView* parent,
                               MenuModel* model) {
   for (int i = 0, max = model->GetItemCount(); i < max; ++i) {
     // The button container menu items have a special height which we have to
     // use instead of the normal height.
     int height = 0;
-    if (use_new_menu_ &&
+    if (use_new_menu() &&
         (model->GetCommandIdAt(i) == IDC_CUT ||
          model->GetCommandIdAt(i) == IDC_ZOOM_MINUS))
       height = kMenuItemContainingButtonsHeight;
 
     scoped_ptr<ExtensionToolbarMenuView> extension_toolbar_menu_view;
     if (model->GetCommandIdAt(i) == IDC_EXTENSIONS_OVERFLOW_MENU) {
-      extension_toolbar_menu_view.reset(new ExtensionToolbarMenuView(browser_));
+      extension_toolbar_menu_view.reset(
+          new ExtensionToolbarMenuView(browser_, this));
       height = extension_toolbar_menu_view->GetPreferredSize().height();
     }
 
     // Add the menu item at the end.
     int menu_index = parent->HasSubmenu() ?
         parent->GetSubmenu()->child_count() : 0;
     MenuItemView* item = AddMenuItem(
         parent, menu_index, model, i, model->GetTypeAt(i), height);
 
     if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU)
@@ skipping 83 matching lines @@
       parent->CreateSubmenu();
     parent->GetSubmenu()->AddChildViewAt(menu_item, menu_index);
   } else {
     // For all other cases we use the more generic way to add menu items.
     menu_item = views::MenuModelAdapter::AddMenuItemFromModelAt(
         model, model_index, parent, menu_index, command_id);
   }
 
   if (menu_item) {
     // Flush all buttons to the right side of the menu for the new menu type.
-    menu_item->set_use_right_margin(!use_new_menu_);
+    menu_item->set_use_right_margin(!use_new_menu());
     menu_item->SetVisible(model->IsVisibleAt(model_index));
 
     if (menu_type == MenuModel::TYPE_COMMAND && model->HasIcons()) {
       gfx::Image icon;
       if (model->GetIconAt(model_index, &icon))
         menu_item->SetIcon(*icon.ToImageSkia());
     }
   }
 
   return menu_item;
@@ skipping 31 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_WRENCH_MENU);
 }
 
 int WrenchMenu::ModelIndexFromCommandId(int command_id) const {
   CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   DCHECK(ix != command_id_to_entry_.end());
   return ix->second.second;
 }