MacViews: Gets wrench menu working

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 46 matching lines @@
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/widget/widget.h"
 
 using base::UserMetricsAction;
 using bookmarks::BookmarkModel;
 using content::WebContents;
+using ui::ButtonMenuItemModel;
 using ui::MenuModel;
 using views::CustomButton;
 using views::ImageButton;
 using views::Label;
 using views::LabelButton;
 using views::MenuConfig;
 using views::MenuItemView;
 using views::View;
 
 namespace {
@@ skipping 154 matching lines @@
   const ButtonType type_;
 
   // See description above setter for details.
   const CustomButton* left_button_;
   const CustomButton* right_button_;
 
   DISALLOW_COPY_AND_ASSIGN(InMenuButtonBackground);
 };
 
 base::string16 GetAccessibleNameForWrenchMenuItem(
-      MenuModel* model, int item_index, int accessible_string_id) {
+    ButtonMenuItemModel* model, int item_index, int accessible_string_id) {
   base::string16 accessible_name =
       l10n_util::GetStringUTF16(accessible_string_id);
   base::string16 accelerator_text;
 
   ui::Accelerator menu_accelerator;
   if (model->GetAcceleratorAt(item_index, &menu_accelerator)) {
     accelerator_text =
         ui::Accelerator(menu_accelerator.key_code(),
                         menu_accelerator.modifiers()).GetShortcutText();
   }
@@ skipping 55 matching lines @@
   InMenuButtonBackground* in_menu_background_;
 
   DISALLOW_COPY_AND_ASSIGN(InMenuButton);
 };
 
 // WrenchMenuView is a view that can contain label buttons.
 class WrenchMenuView : public views::View,
                        public views::ButtonListener,
                        public WrenchMenuObserver {
  public:
-  WrenchMenuView(WrenchMenu* menu, MenuModel* menu_model)
+  WrenchMenuView(WrenchMenu* menu, ButtonMenuItemModel* menu_model)
       : menu_(menu),
         menu_model_(menu_model) {
     menu_->AddObserver(this);
   }
 
   ~WrenchMenuView() override {
     if (menu_)
       menu_->RemoveObserver(this);
   }
 
@@ skipping 38 matching lines @@
 
   // Overridden from WrenchMenuObserver:
   void WrenchMenuDestroyed() override {
     menu_->RemoveObserver(this);
     menu_ = NULL;
     menu_model_ = NULL;
   }
 
  protected:
   WrenchMenu* menu() { return menu_; }
-  MenuModel* menu_model() { return menu_model_; }
+  ButtonMenuItemModel* menu_model() { return menu_model_; }
 
  private:
   // Hosting WrenchMenu.
   // WARNING: this may be NULL during shutdown.
   WrenchMenu* menu_;
 
   // The menu model containing the increment/decrement/reset items.
   // WARNING: this may be NULL during shutdown.
-  MenuModel* menu_model_;
+  ButtonMenuItemModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
 
 // Generate the button image for hover state.
 class HoveredImageSource : public gfx::ImageSkiaSource {
  public:
   HoveredImageSource(const gfx::ImageSkia& image, SkColor color)
       : image_(image),
         color_(color) {
@@ skipping 27 matching lines @@
 };
 
 }  // namespace
 
 // CutCopyPasteView ------------------------------------------------------------
 
 // CutCopyPasteView is the view containing the cut/copy/paste buttons.
 class WrenchMenu::CutCopyPasteView : public WrenchMenuView {
  public:
   CutCopyPasteView(WrenchMenu* menu,
-                   MenuModel* menu_model,
+                   ButtonMenuItemModel* menu_model,
                    int cut_index,
                    int copy_index,
                    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, InMenuButtonBackground::CENTER_BUTTON, paste_index);
@@ skipping 33 matching lines @@
 
 // ZoomView --------------------------------------------------------------------
 
 
 // ZoomView contains the various zoom controls: two buttons to increase/decrease
 // the zoom, a label showing the current zoom percent, and a button to go
 // full-screen.
 class WrenchMenu::ZoomView : public WrenchMenuView {
  public:
   ZoomView(WrenchMenu* menu,
-           MenuModel* menu_model,
+           ButtonMenuItemModel* menu_model,
            int decrement_index,
            int increment_index,
            int fullscreen_index)
       : WrenchMenuView(menu, menu_model),
         fullscreen_index_(fullscreen_index),
         increment_button_(NULL),
         zoom_label_(NULL),
         decrement_button_(NULL),
         fullscreen_button_(NULL),
         zoom_label_width_(0) {
@@ skipping 346 matching lines @@
                               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_)
+  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();
 }
@@ skipping 122 matching lines @@
 bool WrenchMenu::IsCommandEnabled(int command_id) const {
   if (IsBookmarkCommand(command_id))
     return true;
 
   if (command_id == 0)
     return false;  // The root item.
 
   // The items representing the cut menu (cut/copy/paste), zoom menu
   // (increment/decrement/reset) and extension toolbar view are always enabled.
   // The child views of these items enabled state updates appropriately.
-  if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS ||
+  if (command_id == IDC_EDIT_MENU || command_id == IDC_ZOOM_MENU ||
+      command_id == IDC_MORE_TOOLS_MENU ||
       command_id == IDC_EXTENSIONS_OVERFLOW_MENU)
     return true;
 
   const Entry& entry = command_id_to_entry_.find(command_id)->second;
   return entry.first->IsEnabledAt(entry.second);
 }
 
 void WrenchMenu::ExecuteCommand(int command_id, int mouse_event_flags) {
   if (IsBookmarkCommand(command_id)) {
     UMA_HISTOGRAM_MEDIUM_TIMES("WrenchMenu.TimeToAction.OpenBookmark",
                         menu_opened_timer_.Elapsed());
     UMA_HISTOGRAM_ENUMERATION("WrenchMenu.MenuAction",
                               MENU_ACTION_BOOKMARK_OPEN, LIMIT_MENU_ACTION);
     bookmark_menu_delegate_->ExecuteCommand(command_id, mouse_event_flags);
     return;
   }
 
-  if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS ||
+  if (command_id == IDC_EDIT_MENU || command_id == IDC_ZOOM_MENU ||
+      command_id == IDC_MORE_TOOLS_MENU ||
       command_id == IDC_EXTENSIONS_OVERFLOW_MENU) {
     // These items are represented by child views. If ExecuteCommand is invoked
     // it means the user clicked on the area around the buttons and we should
     // not do anyting.
     return;
   }
 
   const Entry& entry = command_id_to_entry_.find(command_id)->second;
   return entry.first->ActivatedAt(entry.second, mouse_event_flags);
 }
 
 bool WrenchMenu::GetAccelerator(int command_id,
                                 ui::Accelerator* accelerator) const {
   if (IsBookmarkCommand(command_id))
     return false;
 
-  if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS ||
+  if (command_id == IDC_EDIT_MENU || command_id == IDC_ZOOM_MENU ||
+      command_id == IDC_MORE_TOOLS_MENU ||
       command_id == IDC_EXTENSIONS_OVERFLOW_MENU) {
     // These have special child views; don't show the accelerator for them.
     return false;
   }
 
   CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   const Entry& entry = ix->second;
   ui::Accelerator menu_accelerator;
   if (!entry.first->GetAcceleratorAt(entry.second, &menu_accelerator))
     return false;
@@ skipping 50 matching lines @@
 
 void WrenchMenu::PopulateMenu(MenuItemView* parent,
                               MenuModel* model) {
   for (int i = 0, max = model->GetItemCount(); i < max; ++i) {
     // 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));
 
-    if (model->GetCommandIdAt(i) == IDC_CUT ||
-        model->GetCommandIdAt(i) == IDC_ZOOM_MINUS) {
+    if (model->GetCommandIdAt(i) == IDC_EDIT_MENU ||
+        model->GetCommandIdAt(i) == IDC_ZOOM_MENU ||
+        model->GetCommandIdAt(i) == IDC_MORE_TOOLS_MENU) {
       const MenuConfig& config = item->GetMenuConfig();
       int top_margin = config.item_top_margin + config.separator_height / 2;
       int bottom_margin =
           config.item_bottom_margin + config.separator_height / 2;
 
       // Chromeos adds extra vertical space for the menu buttons.
 #if defined(OS_CHROMEOS)
       top_margin += 4;
       bottom_margin += 5;
 #endif
 
       item->SetMargins(top_margin, bottom_margin);
     }
 
     if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU)
       PopulateMenu(item, model->GetSubmenuModelAt(i));
 
     switch (model->GetCommandIdAt(i)) {
       case IDC_EXTENSIONS_OVERFLOW_MENU: {
         scoped_ptr<ExtensionToolbarMenuView> extension_toolbar(
             new ExtensionToolbarMenuView(browser_, this));
         if (extension_toolbar->ShouldShow())
           item->AddChildView(extension_toolbar.release());
         else
           item->SetVisible(false);
         break;
       }
 
-      case IDC_CUT:
-        DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(i));
-        DCHECK_LT(i + 2, max);
-        DCHECK_EQ(IDC_COPY, model->GetCommandIdAt(i + 1));
-        DCHECK_EQ(IDC_PASTE, model->GetCommandIdAt(i + 2));
+      case IDC_EDIT_MENU: {
+        ui::ButtonMenuItemModel* submodel = model->GetButtonMenuItemAt(i);
+        DCHECK_EQ(IDC_CUT, submodel->GetCommandIdAt(0));
+        DCHECK_EQ(IDC_COPY, submodel->GetCommandIdAt(1));
+        DCHECK_EQ(IDC_PASTE, submodel->GetCommandIdAt(2));
         item->SetTitle(l10n_util::GetStringUTF16(IDS_EDIT2));
-        item->AddChildView(new CutCopyPasteView(this, model,
-                                                i, i + 1, i + 2));
-        i += 2;
+        item->AddChildView(new CutCopyPasteView(this, submodel, 0, 1, 2));
         break;
+      }
 
-      case IDC_ZOOM_MINUS:
-        DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(i));
-        DCHECK_EQ(IDC_ZOOM_PLUS, model->GetCommandIdAt(i + 1));
-        DCHECK_EQ(IDC_FULLSCREEN, model->GetCommandIdAt(i + 2));
+      case IDC_ZOOM_MENU: {
+        ui::ButtonMenuItemModel* submodel = model->GetButtonMenuItemAt(i);
+        DCHECK_EQ(IDC_ZOOM_MINUS, submodel->GetCommandIdAt(0));
+        DCHECK_EQ(IDC_ZOOM_PLUS, submodel->GetCommandIdAt(1));
+        DCHECK_EQ(IDC_FULLSCREEN, submodel->GetCommandIdAt(2));
         item->SetTitle(l10n_util::GetStringUTF16(IDS_ZOOM_MENU2));
-        item->AddChildView(new ZoomView(this, model, i, i + 1, i + 2));
-        i += 2;
+        item->AddChildView(new ZoomView(this, submodel, 0, 1, 2));
         break;
+      }
 
       case IDC_BOOKMARKS_MENU:
         DCHECK(!bookmark_menu_);
         bookmark_menu_ = item;
         break;
 
 #if defined(GOOGLE_CHROME_BUILD)
       case IDC_FEEDBACK:
         DCHECK(!feedback_menu_item_);
         feedback_menu_item_ = item;
@@ skipping 53 matching lines @@
     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;
 }
 
-void WrenchMenu::CancelAndEvaluate(MenuModel* model, int index) {
+void WrenchMenu::CancelAndEvaluate(ButtonMenuItemModel* model, int index) {
   selected_menu_model_ = model;
   selected_index_ = index;
   root_->Cancel();
 }
 
 void WrenchMenu::CreateBookmarkMenu() {
   if (bookmark_menu_delegate_.get())
     return;  // Already created the menu.
 
   BookmarkModel* model =
@@ skipping 18 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;
 }