Clean up BrowserWindowController by using the ObjCCast helper function.

chrome/browser/ui/cocoa/browser_window_controller.mm

 // Copyright 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"
+#import "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"  // IDC_*
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/profiles/avatar_menu.h"
@@ skipping 1067 matching lines @@
     NSInteger tag = [item tag];
     if (chrome::SupportsCommand(browser_.get(), tag)) {
       // Generate return value (enabled state)
       enable = chrome::IsCommandEnabled(browser_.get(), 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];
+          if (NSMenuItem* menuItem = base::mac::ObjCCast<NSMenuItem>(item))
+            enable &= !![[menuItem keyEquivalent] length];
           break;
         case IDC_FULLSCREEN: {
-          if ([static_cast<NSObject*>(item) isKindOfClass:[NSMenuItem class]]) {
+          if (NSMenuItem* menuItem = base::mac::ObjCCast<NSMenuItem>(item)) {
             NSString* menuTitle = l10n_util::GetNSString(
                 [self isFullscreen] && ![self inPresentationMode] ?
                     IDS_EXIT_FULLSCREEN_MAC :
                     IDS_ENTER_FULLSCREEN_MAC);
-            [static_cast<NSMenuItem*>(item) setTitle:menuTitle];
+            [menuItem setTitle:menuTitle];
 
             if (!chrome::mac::SupportsSystemFullscreen())
-              [static_cast<NSMenuItem*>(item) setHidden:YES];
+              [menuItem setHidden:YES];
           }
           break;
         }
         case IDC_PRESENTATION_MODE: {
-          if ([static_cast<NSObject*>(item) isKindOfClass:[NSMenuItem class]]) {
+          if (NSMenuItem* menuItem = base::mac::ObjCCast<NSMenuItem>(item)) {
             NSString* menuTitle = l10n_util::GetNSString(
                 [self inPresentationMode] ? IDS_EXIT_PRESENTATION_MAC :
                                             IDS_ENTER_PRESENTATION_MAC);
-            [static_cast<NSMenuItem*>(item) setTitle:menuTitle];
+            [menuItem setTitle:menuTitle];
           }
           break;
         }
         case IDC_SHOW_SIGNIN: {
           Profile* original_profile =
               browser_->profile()->GetOriginalProfile();
           [BrowserWindowController updateSigninItem:item
                                          shouldShow:enable
                                      currentProfile:original_profile];
           break;
@@ skipping 131 matching lines @@
   // to tab content area coordinates and flip the coordinate system.
   NSRect growBoxRect =
       [[self tabContentArea] convertRect:[window _growBoxRect] fromView:nil];
   growBoxRect.origin.y =
       NSHeight([[self tabContentArea] frame]) - NSMaxY(growBoxRect);
   return growBoxRect;
 }
 
 // Accept tabs from a BrowserWindowController with the same Profile.
 - (BOOL)canReceiveFrom:(TabWindowController*)source {
-  if (![source isKindOfClass:[BrowserWindowController class]]) {
+  BrowserWindowController* realSource =
+      base::mac::ObjCCast<BrowserWindowController>(source);
+  if (!realSource || browser_->profile() != realSource->browser_->profile()) {
     return NO;
   }
 
-  BrowserWindowController* realSource =
-      static_cast<BrowserWindowController*>(source);
-  if (browser_->profile() != realSource->browser_->profile()) {
-    return NO;
-  }
-
   // Can't drag a tab from a normal browser to a pop-up
   if (browser_->type() != realSource->browser_->type()) {
     return NO;
   }
 
   return YES;
 }
 
 // Move a given tab view to the location of the current placeholder. If there is
 // no placeholder, it will go at the end. |controller| is the window controller
 // of a tab being dropped from a different window. It will be nil if the drag is
 // within the window, otherwise the tab is removed from that window before being
 // placed into this one. The implementation will call |-removePlaceholder| since
 // the drag is now complete.  This also calls |-layoutTabs| internally so
 // clients do not need to call it again.
 - (void)moveTabView:(NSView*)view
      fromController:(TabWindowController*)dragController {
   if (dragController) {
     // Moving between windows. Figure out the WebContents to drop into our tab
     // model from the source window's model.
-    BOOL isBrowser =
-        [dragController isKindOfClass:[BrowserWindowController class]];
-    DCHECK(isBrowser);
-    if (!isBrowser) return;
-    BrowserWindowController* dragBWC = (BrowserWindowController*)dragController;
+    BrowserWindowController* dragBWC =
+        base::mac::ObjCCastStrict<BrowserWindowController>(dragController);
     int index = [dragBWC->tabStripController_ modelIndexForTabView:view];
     WebContents* contents =
         dragBWC->browser_->tab_strip_model()->GetWebContentsAt(index);
     // The tab contents may have gone away if given a window.close() while it
     // is being dragged. If so, bail, we've got nothing to drop.
     if (!contents)
       return;
 
     // Convert |view|'s frame (which starts in the source tab strip's coordinate
     // system) to the coordinate system of the destination tab strip. This needs
@@ skipping 502 matching lines @@
   // TODO: calling |layoutSubviews| here is a waste, find a better way to
   // do this.
   if ([findBarCocoaController_ isFindBarVisible])
     [self layoutSubviews];
 }
 
 // Handle the openLearnMoreAboutCrashLink: action from SadTabController when
 // "Learn more" link in "Aw snap" page (i.e. crash page or sad tab) is
 // clicked. Decoupling the action from its target makes unit testing possible.
 - (void)openLearnMoreAboutCrashLink:(id)sender {
-  if ([sender isKindOfClass:[SadTabController class]]) {
-    SadTabController* sad_tab = static_cast<SadTabController*>(sender);
-    WebContents* web_contents = [sad_tab webContents];
-    if (web_contents) {
+  if (SadTabController* sadTab =
+          base::mac::ObjCCast<SadTabController>(sender)) {
+    WebContents* webContents = [sadTab webContents];
+    if (webContents) {
       OpenURLParams params(
           GURL(chrome::kCrashReasonURL), Referrer(), CURRENT_TAB,
           content::PAGE_TRANSITION_LINK, false);
-      web_contents->OpenURL(params);
+      webContents->OpenURL(params);
     }
   }
 }
 
 // Delegate method called when window did move. (See below for why we don't use
 // |-windowWillMove:|, which is called less frequently than |-windowDidMove|
 // instead.)
 - (void)windowDidMove:(NSNotification*)notification {
   [self saveWindowPositionIfNeeded];
 
@@ skipping 141 matching lines @@
 // |-setPresentationMode:|.
 - (void)setFullscreen:(BOOL)fullscreen {
   if (fullscreen == [self isFullscreen])
     return;
 
   if (!chrome::IsCommandEnabled(browser_.get(), IDC_FULLSCREEN))
     return;
 
   if (chrome::mac::SupportsSystemFullscreen() && !fullscreenWindow_) {
     enteredPresentationModeFromFullscreen_ = YES;
-    if ([[self window] isKindOfClass:[FramedBrowserWindow class]])
-      [static_cast<FramedBrowserWindow*>([self window]) toggleSystemFullScreen];
+    if (FramedBrowserWindow* framedBrowserWindow =
+            base::mac::ObjCCast<FramedBrowserWindow>([self window])) {
+      [framedBrowserWindow toggleSystemFullScreen];
+    }
   } else {
     if (fullscreen)
       [self enterFullscreenForSnowLeopard];
     else
       [self exitFullscreenForSnowLeopard];
   }
 }
 
 - (void)enterFullscreen {
   [self setFullscreen:YES];
@@ skipping 54 matching lines @@
       [self releaseBarVisibilityForOwner:self withAnimation:YES delay:YES];
       // Since -windowDidEnterFullScreen: won't be called in the
       // fullscreen --> presentation mode case, manually show the exit bubble
       // and notify the change happened with WindowFullscreenStateChanged().
       [self showFullscreenExitBubbleIfNecessary];
       browser_->WindowFullscreenStateChanged();
     } else {
       // If not in fullscreen mode, trigger the Lion fullscreen mode machinery.
       // Presentation mode will automatically be enabled in
       // |-windowWillEnterFullScreen:|.
-      NSWindow* window = [self window];
-      if ([window isKindOfClass:[FramedBrowserWindow class]])
-        [static_cast<FramedBrowserWindow*>(window) toggleSystemFullScreen];
+      if (FramedBrowserWindow* window =
+              base::mac::ObjCCast<FramedBrowserWindow>([self window])) {
+        [window toggleSystemFullScreen];
+      }
     }
   } else {
     // Exiting presentation mode does not exit system fullscreen; it merely
     // switches from presentation mode to normal fullscreen.
     [self setPresentationModeInternal:NO forceDropdown:NO];
 
     // Since -windowDidExitFullScreen: won't be called in the
     // presentation mode --> normal fullscreen case, manually show the exit
     // bubble and notify the change happened with
     // WindowFullscreenStateChanged().
@@ skipping 151 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 @end  // @implementation BrowserWindowController(WindowType)