chrome: Rename WrenchMenuController to AppMenuController.

chrome/browser/ui/cocoa/app_menu/app_menu_controller.mm

 // 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.
 
-#import "chrome/browser/ui/cocoa/wrench_menu/wrench_menu_controller.h"
+#import "chrome/browser/ui/cocoa/app_menu/app_menu_controller.h"
 
 #include "base/basictypes.h"
 #include "base/mac/bundle_locations.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #import "chrome/browser/app_controller_mac.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 27 matching lines @@
 const int kRightPadding = 10;
 
 // In *very* extreme cases, it's possible that there are so many overflowed
 // actions, we won't be able to show them all. Cap the height so that the
 // overflow won't make the menu larger than the height of the screen.
 // Note: With this height, we can show 104 actions. Less than 0.0002% of our
 // users will be affected.
 const int kMaxOverflowContainerHeight = 416;
 }
 
-namespace wrench_menu_controller {
-const CGFloat kWrenchBubblePointOffsetY = 6;
+namespace app_menu_controller {
+const CGFloat kAppMenuBubblePointOffsetY = 6;
 }
 
 using base::UserMetricsAction;
 
-@interface WrenchMenuController (Private)
+@interface AppMenuController (Private)
 - (void)createModel;
 - (void)adjustPositioning;
 - (void)performCommandDispatch:(NSNumber*)tag;
 - (NSButton*)zoomDisplay;
 - (void)menu:(NSMenu*)menu willHighlightItem:(NSMenuItem*)item;
 - (void)removeAllItems:(NSMenu*)menu;
 - (NSMenu*)recentTabsSubmenu;
 - (RecentTabsSubMenuModel*)recentTabsMenuModel;
 - (int)maxWidthForMenuModel:(ui::MenuModel*)model
                  modelIndex:(int)modelIndex;
 @end
 
-namespace WrenchMenuControllerInternal {
+namespace AppMenuControllerInternal {
 
-// A C++ delegate that handles the accelerators in the wrench menu.
+// A C++ delegate that handles the accelerators in the app menu.
 class AcceleratorDelegate : public ui::AcceleratorProvider {
  public:
   bool GetAcceleratorForCommandId(int command_id,
                                   ui::Accelerator* out_accelerator) override {
     AcceleratorsCocoa* keymap = AcceleratorsCocoa::GetInstance();
     const ui::Accelerator* accelerator =
         keymap->GetAcceleratorForCommand(command_id);
     if (!accelerator)
       return false;
     *out_accelerator = *accelerator;
     return true;
   }
 };
 
 class ZoomLevelObserver {
  public:
-  ZoomLevelObserver(WrenchMenuController* controller,
+  ZoomLevelObserver(AppMenuController* controller,
                     ui_zoom::ZoomEventManager* manager)
       : controller_(controller) {
     subscription_ = manager->AddZoomLevelChangedCallback(
         base::Bind(&ZoomLevelObserver::OnZoomLevelChanged,
                    base::Unretained(this)));
   }
 
   ~ZoomLevelObserver() {}
 
  private:
   void OnZoomLevelChanged(const content::HostZoomMap::ZoomLevelChange& change) {
     AppMenuModel* appMenuModel = [controller_ appMenuModel];
     appMenuModel->UpdateZoomControls();
     const base::string16 level =
         appMenuModel->GetLabelForCommandId(IDC_ZOOM_PERCENT_DISPLAY);
     [[controller_ zoomDisplay] setTitle:SysUTF16ToNSString(level)];
   }
 
   scoped_ptr<content::HostZoomMap::Subscription> subscription_;
 
-  WrenchMenuController* controller_;  // Weak; owns this.
+  AppMenuController* controller_;  // Weak; owns this.
 
   DISALLOW_COPY_AND_ASSIGN(ZoomLevelObserver);
 };
 
 class ToolbarActionsBarObserverHelper : public ToolbarActionsBarObserver {
  public:
-  ToolbarActionsBarObserverHelper(WrenchMenuController* controller,
+  ToolbarActionsBarObserverHelper(AppMenuController* controller,
                                   ToolbarActionsBar* toolbar_actions_bar)
       : controller_(controller),
         scoped_observer_(this) {
     scoped_observer_.Add(toolbar_actions_bar);
   }
   ~ToolbarActionsBarObserverHelper() override {}
 
  private:
   // ToolbarActionsBarObserver:
   void OnToolbarActionsBarDestroyed() override {
     scoped_observer_.RemoveAll();
   }
   void OnToolbarActionsBarDidStartResize() override {
     [controller_ updateBrowserActionsSubmenu];
   }
 
-  WrenchMenuController* controller_;
+  AppMenuController* controller_;
   ScopedObserver<ToolbarActionsBar, ToolbarActionsBarObserver> scoped_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsBarObserverHelper);
 };
 
-}  // namespace WrenchMenuControllerInternal
+}  // namespace AppMenuControllerInternal
 
-@implementation WrenchMenuController
+@implementation AppMenuController
 
 - (id)initWithBrowser:(Browser*)browser {
   if ((self = [super init])) {
     browser_ = browser;
     acceleratorDelegate_.reset(
-        new WrenchMenuControllerInternal::AcceleratorDelegate());
+        new AppMenuControllerInternal::AcceleratorDelegate());
     [self createModel];
   }
   return self;
 }
 
 - (void)dealloc {
   [self browserWillBeDestroyed];
   [super dealloc];
 }
 
@@ skipping 36 matching lines @@
   MenuTrackedRootView* view = nil;
   switch (command_id) {
     case IDC_EXTENSIONS_OVERFLOW_MENU: {
       browserActionsMenuItem_ = customItem.get();
       view = [buttonViewController_ toolbarActionsOverflowItem];
       BrowserActionsContainerView* containerView =
           [buttonViewController_ overflowActionsContainerView];
 
       // The overflow browser actions container can't function properly without
       // a main counterpart, so if the browser window hasn't initialized, abort.
-      // (This is fine because we re-populate the wrench menu each time before
-      // we show it.)
+      // (This is fine because we re-populate the app menu each time before we
+      // show it.)
       if (!browser_->window())
         break;
 
       BrowserActionsController* mainController =
           [[[BrowserWindowController browserWindowControllerForWindow:browser_->
               window()->GetNativeWindow()] toolbarController]
                   browserActionsController];
       toolbar_actions_bar_observer_.reset(
-          new WrenchMenuControllerInternal::ToolbarActionsBarObserverHelper(
+          new AppMenuControllerInternal::ToolbarActionsBarObserverHelper(
               self, [mainController toolbarActionsBar]));
       browserActionsController_.reset(
           [[BrowserActionsController alloc]
               initWithBrowser:browser_
                 containerView:containerView
                mainController:mainController]);
       break;
     }
     case IDC_EDIT_MENU:
       view = [buttonViewController_ editItem];
@@ skipping 98 matching lines @@
 
   [view setFrameOrigin:NSZeroPoint];
   [[containerView superview] setFrameOrigin:NSZeroPoint];
   [containerView setFrameOrigin:NSMakePoint(kLeftPadding, 0)];
 }
 
 - (void)menuWillOpen:(NSMenu*)menu {
   [super menuWillOpen:menu];
 
   zoom_level_observer_.reset(
-      new WrenchMenuControllerInternal::ZoomLevelObserver(
+      new AppMenuControllerInternal::ZoomLevelObserver(
           self,
           ui_zoom::ZoomEventManager::GetForBrowserContext(
               browser_->profile())));
   NSString* title = base::SysUTF16ToNSString(
       [self appMenuModel]->GetLabelForCommandId(IDC_ZOOM_PERCENT_DISPLAY));
   [[[buttonViewController_ zoomItem] viewWithTag:IDC_ZOOM_PERCENT_DISPLAY]
       setTitle:title];
   content::RecordAction(UserMetricsAction("ShowAppMenu"));
 
   NSImage* icon = [self appMenuModel]->browser()->window()->IsFullscreen()
@@ skipping 25 matching lines @@
   [self removeAllItems:newMenu];
   for (NSMenuItem* item in itemArray) {
     [menu addItem:item];
   }
 
   [self updateRecentTabsSubmenu];
   [self updateBookmarkSubMenu];
   [self updateBrowserActionsSubmenu];
 }
 
-// Used to dispatch commands from the Wrench menu. The custom items within the
+// Used to dispatch commands from the App menu. The custom items within the
 // menu cannot be hooked up directly to First Responder because the window in
 // which the controls reside is not the BrowserWindowController, but a
 // NSCarbonMenuWindow; this screws up the typical |-commandDispatch:| system.
-- (IBAction)dispatchWrenchMenuCommand:(id)sender {
+- (IBAction)dispatchAppMenuCommand:(id)sender {
   NSInteger tag = [sender tag];
   if (sender == [buttonViewController_ zoomPlus] ||
       sender == [buttonViewController_ zoomMinus]) {
     // Do a direct dispatch rather than scheduling on the outermost run loop,
     // which would not get hit until after the menu had closed.
     [self performCommandDispatch:[NSNumber numberWithInt:tag]];
 
     // The zoom buttons should not close the menu if opened sticky.
     if ([sender respondsToSelector:@selector(isTracking)] &&
         [sender performSelector:@selector(isTracking)]) {
       [menu_ cancelTracking];
     }
   } else {
-    // The custom views within the Wrench menu are abnormal and keep the menu
-    // open after a target-action.  Close the menu manually.
+    // The custom views within the App menu are abnormal and keep the menu open
+    // after a target-action.  Close the menu manually.
     [menu_ cancelTracking];
 
     // Executing certain commands from the nested run loop of the menu can lead
     // to wonky behavior (e.g. http://crbug.com/49716). To avoid this, schedule
     // the dispatch on the outermost run loop.
     [self performSelector:@selector(performCommandDispatch:)
                withObject:[NSNumber numberWithInt:tag]
                afterDelay:0.0];
   }
 }
@@ skipping 20 matching lines @@
   return browserActionsController_.get();
 }
 
 - (void)createModel {
   DCHECK(browser_);
   recentTabsMenuModelDelegate_.reset();
   appMenuModel_.reset(new AppMenuModel(acceleratorDelegate_.get(), browser_));
   [self setModel:appMenuModel_.get()];
 
   buttonViewController_.reset(
-      [[WrenchMenuButtonViewController alloc] initWithController:self]);
+      [[AppMenuButtonViewController alloc] initWithController:self]);
   [buttonViewController_ view];
 
   // See comment in containerSuperviewFrameChanged:.
   NSView* containerSuperview =
       [[buttonViewController_ overflowActionsContainerView] superview];
   [containerSuperview setPostsFrameChangedNotifications:YES];
 }
 
 // Fit the localized strings into the Cut/Copy/Paste control, then resize the
 // whole menu item accordingly.
@@ skipping 61 matching lines @@
 
 - (NSMenu*)recentTabsSubmenu {
   NSString* title = l10n_util::GetNSStringWithFixup(IDS_RECENT_TABS_MENU);
   return [[[self menu] itemWithTitle:title] submenu];
 }
 
 // The recent tabs menu model is recognized by the existence of either the
 // kRecentlyClosedHeaderCommandId or the kDisabledRecentlyClosedHeaderCommandId.
 - (RecentTabsSubMenuModel*)recentTabsMenuModel {
   int index = 0;
-  // Start searching at the wrench menu model level, |model| will be updated
-  // only if the command we're looking for is found in one of the [sub]menus.
+  // Start searching at the app menu model level, |model| will be updated only
+  // if the command we're looking for is found in one of the [sub]menus.
   ui::MenuModel* model = [self appMenuModel];
   if (ui::MenuModel::GetModelAndIndexForCommandId(
           RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId, &model,
           &index)) {
     return static_cast<RecentTabsSubMenuModel*>(model);
   }
   if (ui::MenuModel::GetModelAndIndexForCommandId(
           RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId,
           &model, &index)) {
     return static_cast<RecentTabsSubMenuModel*>(model);
   }
   return NULL;
 }
 
 // This overrdies the parent class to return a custom width for recent tabs
 // menu.
 - (int)maxWidthForMenuModel:(ui::MenuModel*)model
                  modelIndex:(int)modelIndex {
   RecentTabsSubMenuModel* recentTabsMenuModel = [self recentTabsMenuModel];
   if (recentTabsMenuModel && recentTabsMenuModel == model) {
     return recentTabsMenuModel->GetMaxWidthForItemAtIndex(modelIndex);
   }
   return -1;
 }
 
-@end  // @implementation WrenchMenuController
+@end  // @implementation AppMenuController
 
 ////////////////////////////////////////////////////////////////////////////////
 
-@interface WrenchMenuButtonViewController ()
+@interface AppMenuButtonViewController ()
 - (void)containerSuperviewFrameChanged:(NSNotification*)notification;
 @end
 
-@implementation WrenchMenuButtonViewController
+@implementation AppMenuButtonViewController
 
 @synthesize editItem = editItem_;
 @synthesize editCut = editCut_;
 @synthesize editCopy = editCopy_;
 @synthesize editPaste = editPaste_;
 @synthesize zoomItem = zoomItem_;
 @synthesize zoomPlus = zoomPlus_;
 @synthesize zoomDisplay = zoomDisplay_;
 @synthesize zoomMinus = zoomMinus_;
 @synthesize zoomFullScreen = zoomFullScreen_;
 @synthesize toolbarActionsOverflowItem = toolbarActionsOverflowItem_;
 @synthesize overflowActionsContainerView = overflowActionsContainerView_;
 
-- (id)initWithController:(WrenchMenuController*)controller {
+- (id)initWithController:(AppMenuController*)controller {
   if ((self = [super initWithNibName:@"WrenchMenu"
                               bundle:base::mac::FrameworkBundle()])) {
-    propertyReleaser_.Init(self, [WrenchMenuButtonViewController class]);
+    propertyReleaser_.Init(self, [AppMenuButtonViewController class]);
     controller_ = controller;
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(containerSuperviewFrameChanged:)
                name:NSViewFrameDidChangeNotification
              object:[overflowActionsContainerView_ superview]];
   }
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
-- (IBAction)dispatchWrenchMenuCommand:(id)sender {
-  [controller_ dispatchWrenchMenuCommand:sender];
+- (IBAction)dispatchAppMenuCommand:(id)sender {
+  [controller_ dispatchAppMenuCommand:sender];
 }
 
 - (void)containerSuperviewFrameChanged:(NSNotification*)notification {
   // AppKit menus were probably never designed with a view like the browser
   // actions container in mind, and, as a result, we come across a few oddities.
   // One of these is that the container's superview will, on some versions of
   // OSX, change frame position sometime after the the menu begins tracking
   // (and thus, after all our ability to adjust it normally). Throw in the
   // towel, and simply don't let the frame move from where it's supposed to be.
   // TODO(devlin): Yet another Cocoa hack. It'd be good to find a workaround,
   // but unlikely unless we replace the Cocoa menu implementation.
   NSView* containerSuperview = [overflowActionsContainerView_ superview];
   if (NSMinX([containerSuperview frame]) != 0)
     [containerSuperview setFrameOrigin:NSZeroPoint];
 }
 
-@end  // @implementation WrenchMenuButtonViewController
+@end  // @implementation AppMenuButtonViewController