Move command handling and updating off Browser and onto a helper object.

chrome/browser/ui/cocoa/browser_window_controller.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 
 #include <cmath>
 #include <numeric>
 
 #include "base/command_line.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/mac_util.h"
 #import "base/memory/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"  // IDC_*
 #include "chrome/browser/bookmarks/bookmark_editor.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/managed_mode.h"
 #include "chrome/browser/profiles/avatar_menu_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_ui_util_mac.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #import "chrome/browser/ui/cocoa/background_gradient_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_editor_controller.h"
 #import "chrome/browser/ui/cocoa/browser/avatar_button_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_cocoa.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller_private.h"
 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
 #import "chrome/browser/ui/cocoa/chrome_to_mobile_bubble_controller.h"
@@ skipping 274 matching lines @@
     // registering for the appropriate tab notifications from the back-end and
     // managing the creation of new tabs.
     [self createTabStripController];
 
     // Create a controller for the toolbar, giving it the toolbar model object
     // and the toolbar view from the nib. The controller will handle
     // registering for the appropriate command state changes from the back-end.
     // Adds the toolbar to the content area.
     toolbarController_.reset([[ToolbarController alloc]
                                initWithModel:browser->toolbar_model()
-                                    commands:browser->command_updater()
+                                    commands:browser->command_controller()->command_updater()
                                      profile:browser->profile()
                                      browser:browser
                               resizeDelegate:self]);
     [toolbarController_ setHasToolbar:[self hasToolbar]
                        hasLocationBar:[self hasLocationBar]];
     [[[self window] contentView] addSubview:[toolbarController_ view]];
 
     // Create a sub-controller for the bookmark bar.
     bookmarkBarController_.reset(
         [[BookmarkBarController alloc]
@@ skipping 674 matching lines @@
 // NOTE: we might have to handle state for app-wide menu items,
 // although we could cheat and directly ask the app controller if our
 // command_updater doesn't support the command. This may or may not be an issue,
 // too early to tell.
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   SEL action = [item action];
   BOOL enable = NO;
   if (action == @selector(commandDispatch:) ||
       action == @selector(commandDispatchUsingKeyModifiers:)) {
     NSInteger tag = [item tag];
-    if (browser_->command_updater()->SupportsCommand(tag)) {
+    if (chrome::SupportsCommand(browser_.get(), tag)) {
       // Generate return value (enabled state)
-      enable = browser_->command_updater()->IsCommandEnabled(tag);
+      enable = updater->IsCommandEnabled(tag);
       switch (tag) {
         case IDC_CLOSE_TAB:
           // Disable "close tab" if the receiving window is not tabbed.
           // We simply check whether the item has a keyboard shortcut set here;
           // app_controller_mac.mm actually determines whether the item should
           // be enabled.
           if ([static_cast<NSObject*>(item) isKindOfClass:[NSMenuItem class]])
             enable &= !![[static_cast<NSMenuItem*>(item) keyEquivalent] length];
           break;
         case IDC_FULLSCREEN: {
@@ skipping 25 matching lines @@
           enable &= original_profile->IsSyncAccessible();
           sync_ui_util::UpdateSyncItem(item, enable, original_profile);
           break;
         }
         default:
           // Special handling for the contents of the Text Encoding submenu. On
           // Mac OS, instead of enabling/disabling the top-level menu item, we
           // enable/disable the submenu's contents (per Apple's HIG).
           EncodingMenuController encoding_controller;
           if (encoding_controller.DoesCommandBelongToEncodingMenu(tag)) {
-            enable &= browser_->command_updater()->IsCommandEnabled(
-                IDC_ENCODING_MENU) ? YES : NO;
+            enable &= chrome::IsCommandEnabled(browser_.get(),
+                                               IDC_ENCODING_MENU) ? YES : NO;
           }
       }
 
       // If the item is toggleable, find its toggle state and
       // try to update it.  This is a little awkward, but the alternative is
       // to check after a commandDispatch, which seems worse.
       [self updateToggleStateWithTag:tag forItem:item];
     }
   }
   return enable;
 }
 
 // Called when the user picks a menu or toolbar item when this window is key.
 // Calls through to the browser object to execute the command. This assumes that
 // the command is supported and doesn't check, otherwise it would have been
 // disabled in the UI in validateUserInterfaceItem:.
 - (void)commandDispatch:(id)sender {
   DCHECK(sender);
   // Identify the actual BWC to which the command should be dispatched. It might
   // belong to a background window, yet this controller gets it because it is
   // the foreground window's controller and thus in the responder chain. Some
   // senders don't have this problem (for example, menus only operate on the
   // foreground window), so this is only an issue for senders that are part of
   // windows.
   BrowserWindowController* targetController = self;
   if ([sender respondsToSelector:@selector(window)])
     targetController = [[sender window] windowController];
   DCHECK([targetController isKindOfClass:[BrowserWindowController class]]);
   DCHECK(targetController->browser_.get());
-  targetController->browser_->ExecuteCommand([sender tag]);
+  chrome::ExecuteCommand(targetController->browser_.get(), [sender tag]);
 }
 
 // Same as |-commandDispatch:|, but executes commands using a disposition
 // determined by the key flags. If the window is in the background and the
 // command key is down, ignore the command key, but process any other modifiers.
 - (void)commandDispatchUsingKeyModifiers:(id)sender {
   DCHECK(sender);
 
   if (![sender isEnabled]) {
     // This code is reachable e.g. if the user mashes the back button, queuing
@@ skipping 29 matching lines @@
     case IDC_RELOAD:
     case IDC_RELOAD_IGNORING_CACHE:
       if (disposition == CURRENT_TAB) {
         // Forcibly reset the location bar, since otherwise it won't discard any
         // ongoing user edits, since it doesn't realize this is a user-initiated
         // action.
         [targetController locationBarBridge]->Revert();
       }
   }
   DCHECK(targetController->browser_.get());
-  targetController->browser_->ExecuteCommandWithDisposition(command,
-                                                            disposition);
+  chrome::ExecuteCommandWithDisposition(targetController->browser_.get(),
+                                        command, disposition);
 }
 
 // Called when another part of the internal codebase needs to execute a
 // command.
 - (void)executeCommand:(int)command {
-  browser_->ExecuteCommandIfEnabled(command);
+  chrome::ExecuteCommand(browser_.get(), command);
 }
 
 // StatusBubble delegate method: tell the status bubble the frame it should
 // position itself in.
 - (NSRect)statusBubbleBaseFrame {
   NSView* view = [previewableContentsController_ view];
   return [view convertRect:[view bounds] toView:nil];
 }
 
 - (GTMWindowSheetController*)sheetController {
@@ skipping 532 matching lines @@
   // Map forwards and backwards to history; left is positive, right is negative.
   unsigned int command = 0;
   if (deltaX > 0.5) {
     command = IDC_BACK;
   } else if (deltaX < -0.5) {
     command = IDC_FORWARD;
   } else if (deltaY > 0.5) {
     // TODO(pinkerton): figure out page-up, http://crbug.com/16305
   } else if (deltaY < -0.5) {
     // TODO(pinkerton): figure out page-down, http://crbug.com/16305
-    browser_->ExecuteCommand(IDC_TABPOSE);
+    chrome::ExecuteCommand(browser_.get(), IDC_TABPOSE);
   }
 
   // Ensure the command is valid first (ExecuteCommand() won't do that) and
   // then make it so.
-  if (browser_->command_updater()->IsCommandEnabled(command))
-    browser_->ExecuteCommandWithDisposition(command,
+  if (chrome::IsCommandEnabled(browser_.get(), command)) {
+    chrome::ExecuteCommandWithDisposition(
+        browser_.get(),
+        command,
         event_utils::WindowOpenDispositionFromNSEvent(event));
+  }
 }
 
 // Documented in 10.6+, but present starting in 10.5. Called repeatedly during
 // a pinch gesture, with incremental change values.
 - (void)magnifyWithEvent:(NSEvent*)event {
   // The deltaZ difference necessary to trigger a zoom action. Derived from
   // experimentation to find a value that feels reasonable.
   const float kZoomStepValue = 300;
 
   // Find the (absolute) thresholds on either side of the current zoom factor,
   // then convert those to actual numbers to trigger a zoom in or out.
   // This logic deliberately makes the range around the starting zoom value for
   // the gesture twice as large as the other ranges (i.e., the notches are at
   // ..., -3*step, -2*step, -step, step, 2*step, 3*step, ... but not at 0)
   // so that it's easier to get back to your starting point than it is to
   // overshoot.
   float nextStep = (abs(currentZoomStepDelta_) + 1) * kZoomStepValue;
   float backStep = abs(currentZoomStepDelta_) * kZoomStepValue;
   float zoomInThreshold = (currentZoomStepDelta_ >= 0) ? nextStep : -backStep;
   float zoomOutThreshold = (currentZoomStepDelta_ <= 0) ? -nextStep : backStep;
 
   unsigned int command = 0;
   totalMagnifyGestureAmount_ += [event deltaZ];
   if (totalMagnifyGestureAmount_ > zoomInThreshold) {
     command = IDC_ZOOM_PLUS;
   } else if (totalMagnifyGestureAmount_ < zoomOutThreshold) {
     command = IDC_ZOOM_MINUS;
   }
 
-  if (command && browser_->command_updater()->IsCommandEnabled(command)) {
+  if (command && chrome::IsCommandEnabled(browser_.get(), command)) {
     currentZoomStepDelta_ += (command == IDC_ZOOM_PLUS) ? 1 : -1;
-    browser_->ExecuteCommandWithDisposition(command,
+    chrome::ExecuteCommandWithDisposition(
+        browser_.get(),
+        command, 
         event_utils::WindowOpenDispositionFromNSEvent(event));
   }
 }
 
 // Delegate method called when window is resized.
 - (void)windowDidResize:(NSNotification*)notification {
   [self saveWindowPositionIfNeeded];
 
   // Resize (and possibly move) the status bubble. Note that we may get called
   // when the status bubble does not exist.
@@ skipping 178 matching lines @@
   [sheet orderOut:self];
 }
 
 @end  // @implementation BrowserWindowController
 
 
 @implementation BrowserWindowController(Fullscreen)
 
 - (void)handleLionToggleFullscreen {
   DCHECK(base::mac::IsOSLionOrLater());
-  browser_->ExecuteCommand(IDC_FULLSCREEN);
+  chrome::ExecuteCommand(browser_.get(), IDC_FULLSCREEN);
 }
 
 // On Lion, this method is called by either the Lion fullscreen button or the
 // "Enter Full Screen" menu item.  On Snow Leopard, this function is never
 // called by the UI directly, but it provides the implementation for
 // |-setPresentationMode:|.
 - (void)setFullscreen:(BOOL)fullscreen
                   url:(const GURL&)url
            bubbleType:(FullscreenExitBubbleType)bubbleType {
   if (fullscreen == [self isFullscreen])
@@ skipping 34 matching lines @@
 - (BOOL)isFullscreen {
   return (fullscreenWindow_.get() != nil) ||
          ([[self window] styleMask] & NSFullScreenWindowMask) ||
          enteringFullscreen_;
 }
 
 - (void)togglePresentationModeForLionOrLater:(id)sender {
   // Called only by the presentation mode toggle button.
   DCHECK(base::mac::IsOSLionOrLater());
   enteredPresentationModeFromFullscreen_ = YES;
-  browser_->ExecuteCommand(IDC_PRESENTATION_MODE);
+  chrome::ExecuteCommand(browser_.get(), IDC_PRESENTATION_MODE);
 }
 
 // On Lion, this function is called by either the presentation mode toggle
 // button or the "Enter Presentation Mode" menu item.  In the latter case, this
 // function also triggers the Lion machinery to enter fullscreen mode as well as
 // set presentation mode.  On Snow Leopard, this function is called by the
 // "Enter Presentation Mode" menu item, and triggering presentation mode always
 // moves the user into fullscreen mode.
 - (void)setPresentationMode:(BOOL)presentationMode
                         url:(const GURL&)url
@@ skipping 199 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 @end  // @implementation BrowserWindowController(WindowType)