chrome: Rename WrenchMenuModel to AppMenuModel.

chrome/browser/ui/toolbar/app_menu_model.cc

 // Copyright (c) 2012 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/toolbar/wrench_menu_model.h"
+#include "chrome/browser/ui/toolbar/app_menu_model.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 210 matching lines @@
   AddItemWithStringId(IDC_ZOOM_PLUS, IDS_ZOOM_PLUS);
   AddItemWithStringId(IDC_ZOOM_NORMAL, IDS_ZOOM_NORMAL);
   AddItemWithStringId(IDC_ZOOM_MINUS, IDS_ZOOM_MINUS);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HelpMenuModel
 
 #if defined(GOOGLE_CHROME_BUILD)
 
-class WrenchMenuModel::HelpMenuModel : public ui::SimpleMenuModel {
+class AppMenuModel::HelpMenuModel : public ui::SimpleMenuModel {
  public:
   HelpMenuModel(ui::SimpleMenuModel::Delegate* delegate,
                 Browser* browser)
       : SimpleMenuModel(delegate) {
     Build(browser);
   }
 
  private:
   void Build(Browser* browser) {
 #if defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD)
@@ skipping 81 matching lines @@
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddItemWithStringId(IDC_DEV_TOOLS, IDS_DEV_TOOLS);
 
 #if defined(ENABLE_PROFILING) && !defined(NO_TCMALLOC)
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddCheckItemWithStringId(IDC_PROFILING_ENABLED, IDS_PROFILING_ENABLED);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WrenchMenuModel
+// AppMenuModel
 
-WrenchMenuModel::WrenchMenuModel(ui::AcceleratorProvider* provider,
-                                 Browser* browser)
+AppMenuModel::AppMenuModel(ui::AcceleratorProvider* provider, Browser* browser)
     : ui::SimpleMenuModel(this),
       uma_action_recorded_(false),
       provider_(provider),
       browser_(browser) {
   Build();
   UpdateZoomControls();
 
   browser_zoom_subscription_ =
       ui_zoom::ZoomEventManager::GetForBrowserContext(browser->profile())
           ->AddZoomLevelChangedCallback(base::Bind(
-              &WrenchMenuModel::OnZoomLevelChanged, base::Unretained(this)));
+              &AppMenuModel::OnZoomLevelChanged, base::Unretained(this)));
 
   browser_->tab_strip_model()->AddObserver(this);
 
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
 }
 
-WrenchMenuModel::~WrenchMenuModel() {
+AppMenuModel::~AppMenuModel() {
   if (browser_)  // Null in tests.
     browser_->tab_strip_model()->RemoveObserver(this);
 }
 
-bool WrenchMenuModel::DoesCommandIdDismissMenu(int command_id) const {
+bool AppMenuModel::DoesCommandIdDismissMenu(int command_id) const {
   return command_id != IDC_ZOOM_MINUS && command_id != IDC_ZOOM_PLUS;
 }
 
-bool WrenchMenuModel::IsItemForCommandIdDynamic(int command_id) const {
+bool AppMenuModel::IsItemForCommandIdDynamic(int command_id) const {
   return command_id == IDC_ZOOM_PERCENT_DISPLAY ||
 #if defined(OS_MACOSX)
          command_id == IDC_FULLSCREEN ||
 #elif defined(OS_WIN)
          command_id == IDC_PIN_TO_START_SCREEN ||
 #endif
          command_id == IDC_UPGRADE_DIALOG;
 }
 
-base::string16 WrenchMenuModel::GetLabelForCommandId(int command_id) const {
+base::string16 AppMenuModel::GetLabelForCommandId(int command_id) const {
   switch (command_id) {
     case IDC_ZOOM_PERCENT_DISPLAY:
       return zoom_label_;
 #if defined(OS_MACOSX)
     case IDC_FULLSCREEN: {
       int string_id = IDS_ENTER_FULLSCREEN_MAC;  // Default to Enter.
       // Note: On startup, |window()| may be NULL.
       if (browser_->window() && browser_->window()->IsFullscreen())
         string_id = IDS_EXIT_FULLSCREEN_MAC;
       return l10n_util::GetStringUTF16(string_id);
@@ skipping 12 matching lines @@
     }
 #endif
     case IDC_UPGRADE_DIALOG:
       return GetUpgradeDialogMenuItemName();
     default:
       NOTREACHED();
       return base::string16();
   }
 }
 
-bool WrenchMenuModel::GetIconForCommandId(int command_id,
-                                          gfx::Image* icon) const {
+bool AppMenuModel::GetIconForCommandId(int command_id, gfx::Image* icon) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   switch (command_id) {
     case IDC_UPGRADE_DIALOG: {
       if (UpgradeDetector::GetInstance()->notify_upgrade()) {
         *icon = rb.GetNativeImageNamed(
             UpgradeDetector::GetInstance()->GetIconResourceID());
         return true;
       }
       return false;
     }
     default:
       break;
   }
   return false;
 }
 
-void WrenchMenuModel::ExecuteCommand(int command_id, int event_flags) {
+void AppMenuModel::ExecuteCommand(int command_id, int event_flags) {
   GlobalError* error = GlobalErrorServiceFactory::GetForProfile(
       browser_->profile())->GetGlobalErrorByMenuItemCommandID(command_id);
   if (error) {
     error->ExecuteMenuItem(browser_);
     return;
   }
 
   LogMenuMetrics(command_id);
   chrome::ExecuteCommand(browser_, command_id);
 }
 
-void WrenchMenuModel::LogMenuMetrics(int command_id) {
+void AppMenuModel::LogMenuMetrics(int command_id) {
   base::TimeDelta delta = timer_.Elapsed();
 
   switch (command_id) {
     case IDC_NEW_TAB:
       if (!uma_action_recorded_)
         UMA_HISTOGRAM_MEDIUM_TIMES("WrenchMenu.TimeToAction.NewTab", delta);
       LogMenuAction(MENU_ACTION_NEW_TAB);
       break;
     case IDC_NEW_WINDOW:
       if (!uma_action_recorded_)
@@ skipping 273 matching lines @@
       LogMenuAction(MENU_ACTION_EXIT);
       break;
   }
 
   if (!uma_action_recorded_) {
     UMA_HISTOGRAM_MEDIUM_TIMES("WrenchMenu.TimeToAction", delta);
     uma_action_recorded_ = true;
   }
 }
 
-void WrenchMenuModel::LogMenuAction(int action_id) {
+void AppMenuModel::LogMenuAction(int action_id) {
   UMA_HISTOGRAM_ENUMERATION("WrenchMenu.MenuAction", action_id,
                             LIMIT_MENU_ACTION);
 }
 
-bool WrenchMenuModel::IsCommandIdChecked(int command_id) const {
+bool AppMenuModel::IsCommandIdChecked(int command_id) const {
   if (command_id == IDC_SHOW_BOOKMARK_BAR) {
     return browser_->profile()->GetPrefs()->GetBoolean(
         bookmarks::prefs::kShowBookmarkBar);
   } else if (command_id == IDC_PROFILING_ENABLED) {
     return Profiling::BeingProfiled();
   } else if (command_id == IDC_TOGGLE_REQUEST_TABLET_SITE) {
     return chrome::IsRequestingTabletSite(browser_);
   }
 
   return false;
 }
 
-bool WrenchMenuModel::IsCommandIdEnabled(int command_id) const {
+bool AppMenuModel::IsCommandIdEnabled(int command_id) const {
   GlobalError* error = GlobalErrorServiceFactory::GetForProfile(
       browser_->profile())->GetGlobalErrorByMenuItemCommandID(command_id);
   if (error)
     return true;
 
   return chrome::IsCommandEnabled(browser_, command_id);
 }
 
-bool WrenchMenuModel::IsCommandIdVisible(int command_id) const {
+bool AppMenuModel::IsCommandIdVisible(int command_id) const {
   switch (command_id) {
 #if defined(OS_MACOSX)
     case kEmptyMenuItemCommand:
       return false;  // Always hidden (see CreateActionToolbarOverflowMenu).
 #endif
 #if defined(OS_WIN)
     case IDC_VIEW_INCOMPATIBILITIES: {
       EnumerateModulesModel* loaded_modules =
           EnumerateModulesModel::GetInstance();
       if (loaded_modules->confirmed_bad_modules_detected() <= 0)
         return false;
-      // We'll leave the wrench adornment on until the user clicks the link.
+      // We'll leave the app menu adornment on until the user clicks the link.
       if (loaded_modules->modules_to_notify_about() <= 0)
         loaded_modules->AcknowledgeConflictNotification();
       return true;
     }
     case IDC_PIN_TO_START_SCREEN:
       return base::win::IsMetroProcess();
 #else
     case IDC_VIEW_INCOMPATIBILITIES:
     case IDC_PIN_TO_START_SCREEN:
       return false;
 #endif
     case IDC_UPGRADE_DIALOG:
       return browser_defaults::kShowUpgradeMenuItem &&
           UpgradeDetector::GetInstance()->notify_upgrade();
 #if !defined(OS_LINUX) || defined(USE_AURA)
     case IDC_BOOKMARK_PAGE:
       return !chrome::ShouldRemoveBookmarkThisPageUI(browser_->profile());
     case IDC_BOOKMARK_ALL_TABS:
       return !chrome::ShouldRemoveBookmarkOpenPagesUI(browser_->profile());
 #endif
     default:
       return true;
   }
 }
 
-bool WrenchMenuModel::GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) {
+bool AppMenuModel::GetAcceleratorForCommandId(int command_id,
+                                              ui::Accelerator* accelerator) {
   return provider_->GetAcceleratorForCommandId(command_id, accelerator);
 }
 
-void WrenchMenuModel::ActiveTabChanged(WebContents* old_contents,
-                                       WebContents* new_contents,
-                                       int index,
-                                       int reason) {
+void AppMenuModel::ActiveTabChanged(WebContents* old_contents,
+                                    WebContents* new_contents,
+                                    int index,
+                                    int reason) {
   // The user has switched between tabs and the new tab may have a different
   // zoom setting.
   UpdateZoomControls();
 }
 
-void WrenchMenuModel::TabReplacedAt(TabStripModel* tab_strip_model,
-                                    WebContents* old_contents,
-                                    WebContents* new_contents,
-                                    int index) {
+void AppMenuModel::TabReplacedAt(TabStripModel* tab_strip_model,
+                                 WebContents* old_contents,
+                                 WebContents* new_contents,
+                                 int index) {
   UpdateZoomControls();
 }
 
-void WrenchMenuModel::Observe(int type,
-                              const content::NotificationSource& source,
-                              const content::NotificationDetails& details) {
+void AppMenuModel::Observe(int type,
+                           const content::NotificationSource& source,
+                           const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_NAV_ENTRY_COMMITTED);
   UpdateZoomControls();
 }
 
 // For testing.
-WrenchMenuModel::WrenchMenuModel()
+AppMenuModel::AppMenuModel()
     : ui::SimpleMenuModel(this),
       uma_action_recorded_(false),
       provider_(nullptr),
       browser_(nullptr) {}
 
-bool WrenchMenuModel::ShouldShowNewIncognitoWindowMenuItem() {
+bool AppMenuModel::ShouldShowNewIncognitoWindowMenuItem() {
   if (browser_->profile()->IsGuestSession())
     return false;
 
   return IncognitoModePrefs::GetAvailability(browser_->profile()->GetPrefs()) !=
       IncognitoModePrefs::DISABLED;
 }
 
 // Note: When adding new menu items please place under an appropriate section.
 // Menu is organised as follows:
 // - Extension toolbar overflow.
 // - Global browser errors and warnings.
 // - Tabs and windows.
 // - Places previously been e.g. History, bookmarks, recent tabs.
 // - Page actions e.g. zoom, edit, find, print.
 // - Learn about the browser and global customisation e.g. settings, help.
 // - Browser relaunch, quit.
-void WrenchMenuModel::Build() {
+void AppMenuModel::Build() {
   if (extensions::FeatureSwitch::extension_action_redesign()->IsEnabled())
     CreateActionToolbarOverflowMenu();
 
   AddItem(IDC_VIEW_INCOMPATIBILITIES,
       l10n_util::GetStringUTF16(IDS_VIEW_INCOMPATIBILITIES));
   SetIcon(GetIndexOfCommandId(IDC_VIEW_INCOMPATIBILITIES),
           ui::ResourceBundle::GetSharedInstance().
               GetNativeImageNamed(IDR_INPUT_ALERT_MENU));
   if (IsCommandIdVisible(IDC_UPGRADE_DIALOG))
     AddItem(IDC_UPGRADE_DIALOG, GetUpgradeDialogMenuItemName());
@@ skipping 70 matching lines @@
   if (browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH)
     show_exit_menu = false;
 #endif
   if (show_exit_menu) {
     AddSeparator(ui::NORMAL_SEPARATOR);
     AddItemWithStringId(IDC_EXIT, IDS_EXIT);
   }
   uma_action_recorded_ = false;
 }
 
-bool WrenchMenuModel::AddGlobalErrorMenuItems() {
-  // TODO(sail): Currently we only build the wrench menu once per browser
+bool AppMenuModel::AddGlobalErrorMenuItems() {
+  // TODO(sail): Currently we only build the app menu once per browser
   // window. This means that if a new error is added after the menu is built
-  // it won't show in the existing wrench menu. To fix this we need to some
+  // it won't show in the existing app menu. To fix this we need to some
   // how update the menu if new errors are added.
   const GlobalErrorService::GlobalErrorList& errors =
       GlobalErrorServiceFactory::GetForProfile(browser_->profile())->errors();
   bool menu_items_added = false;
   for (GlobalErrorService::GlobalErrorList::const_iterator
        it = errors.begin(); it != errors.end(); ++it) {
     GlobalError* error = *it;
     DCHECK(error);
     if (error->HasMenuItem()) {
       AddItem(error->MenuItemCommandID(), error->MenuItemLabel());
       SetIcon(GetIndexOfCommandId(error->MenuItemCommandID()),
               error->MenuItemIcon());
       menu_items_added = true;
     }
   }
   return menu_items_added;
 }
 
-void WrenchMenuModel::CreateActionToolbarOverflowMenu() {
+void AppMenuModel::CreateActionToolbarOverflowMenu() {
   // We only add the extensions overflow container if there are any icons that
   // aren't shown in the main container.
   // browser_->window() can return null during startup.
   if (browser_->window() &&
       browser_->window()->GetToolbarActionsBar()->NeedsOverflow()) {
 #if defined(OS_MACOSX)
     // There's a bug in AppKit menus, where if a menu item with a custom view
     // (like the extensions overflow menu) is the first menu item, it is not
     // highlightable or keyboard-selectable.
     // Adding any menu item before it (even one which is never visible) prevents
     // it, so add a bogus item here that will always be hidden.
     AddItem(kEmptyMenuItemCommand, base::string16());
 #endif
     AddItem(IDC_EXTENSIONS_OVERFLOW_MENU, base::string16());
     AddSeparator(ui::UPPER_SEPARATOR);
   }
 }
 
-void WrenchMenuModel::CreateCutCopyPasteMenu() {
+void AppMenuModel::CreateCutCopyPasteMenu() {
   AddSeparator(ui::LOWER_SEPARATOR);
 
   // WARNING: Mac does not use the ButtonMenuItemModel, but instead defines the
   // layout for this menu item in WrenchMenu.xib. It does, however, use the
   // command_id value from AddButtonItem() to identify this special item.
   edit_menu_item_model_.reset(new ui::ButtonMenuItemModel(IDS_EDIT, this));
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_CUT, IDS_CUT);
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_COPY, IDS_COPY);
   edit_menu_item_model_->AddGroupItemWithStringId(IDC_PASTE, IDS_PASTE);
   AddButtonItem(IDC_EDIT_MENU, edit_menu_item_model_.get());
 
   AddSeparator(ui::UPPER_SEPARATOR);
 }
 
-void WrenchMenuModel::CreateZoomMenu() {
+void AppMenuModel::CreateZoomMenu() {
   // This menu needs to be enclosed by separators.
   AddSeparator(ui::LOWER_SEPARATOR);
 
   // WARNING: Mac does not use the ButtonMenuItemModel, but instead defines the
   // layout for this menu item in WrenchMenu.xib. It does, however, use the
   // command_id value from AddButtonItem() to identify this special item.
   zoom_menu_item_model_.reset(
       new ui::ButtonMenuItemModel(IDS_ZOOM_MENU, this));
   zoom_menu_item_model_->AddGroupItemWithStringId(IDC_ZOOM_MINUS,
                                                   IDS_ZOOM_MINUS2);
   zoom_menu_item_model_->AddGroupItemWithStringId(IDC_ZOOM_PLUS,
                                                   IDS_ZOOM_PLUS2);
   zoom_menu_item_model_->AddItemWithImage(IDC_FULLSCREEN,
                                           IDR_FULLSCREEN_MENU_BUTTON);
   AddButtonItem(IDC_ZOOM_MENU, zoom_menu_item_model_.get());
 
   AddSeparator(ui::UPPER_SEPARATOR);
 }
 
-void WrenchMenuModel::UpdateZoomControls() {
+void AppMenuModel::UpdateZoomControls() {
   int zoom_percent = 100;
   if (browser_->tab_strip_model() &&
       browser_->tab_strip_model()->GetActiveWebContents()) {
     zoom_percent = ui_zoom::ZoomController::FromWebContents(
                        browser_->tab_strip_model()->GetActiveWebContents())
                        ->GetZoomPercent();
   }
   zoom_label_ = l10n_util::GetStringFUTF16(
       IDS_ZOOM_PERCENT, base::IntToString16(zoom_percent));
 }
 
-void WrenchMenuModel::OnZoomLevelChanged(
+void AppMenuModel::OnZoomLevelChanged(
     const content::HostZoomMap::ZoomLevelChange& change) {
   UpdateZoomControls();
 }