chrome/browser/ui/cocoa/browser_window_cocoa.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/cocoa/browser_window_cocoa.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/logging.h"
  10 #include "base/mac/mac_util.h"
  11 #import "base/mac/sdk_forward_declarations.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/strings/sys_string_conversions.h"
  15 #include "chrome/app/chrome_command_ids.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/download/download_shelf.h"
  18 #include "chrome/browser/extensions/tab_helper.h"
  19 #include "chrome/browser/fullscreen.h"
  20 #include "chrome/browser/password_manager/password_manager.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/shell_integration.h"
  23 #include "chrome/browser/ui/browser.h"
  24 #include "chrome/browser/ui/browser_command_controller.h"
  25 #include "chrome/browser/ui/browser_commands.h"
  26 #include "chrome/browser/ui/browser_list.h"
  27 #include "chrome/browser/ui/browser_window_state.h"
  28 #import "chrome/browser/ui/cocoa/browser/avatar_button_controller.h"
  29 #import "chrome/browser/ui/cocoa/browser/avatar_menu_bubble_controller.h"
  30 #import "chrome/browser/ui/cocoa/browser/edit_search_engine_cocoa_controller.h"
  31 #import "chrome/browser/ui/cocoa/browser/password_generation_bubble_controller.h"
  32 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
  33 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
  34 #import "chrome/browser/ui/cocoa/chrome_event_processing_window.h"
  35 #import "chrome/browser/ui/cocoa/download/download_shelf_controller.h"
  36 #include "chrome/browser/ui/cocoa/find_bar/find_bar_bridge.h"
  37 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
  38 #import "chrome/browser/ui/cocoa/location_bar/location_bar_view_mac.h"
  39 #import "chrome/browser/ui/cocoa/nsmenuitem_additions.h"
  40 #include "chrome/browser/ui/cocoa/restart_browser.h"
  41 #include "chrome/browser/ui/cocoa/status_bubble_mac.h"
  42 #include "chrome/browser/ui/cocoa/task_manager_mac.h"
  43 #import "chrome/browser/ui/cocoa/toolbar/toolbar_controller.h"
  44 #import "chrome/browser/ui/cocoa/web_dialog_window_controller.h"
  45 #import "chrome/browser/ui/cocoa/website_settings_bubble_controller.h"
  46 #include "chrome/browser/ui/search/search_model.h"
  47 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  48 #include "chrome/browser/web_applications/web_app.h"
  49 #include "chrome/common/chrome_switches.h"
  50 #include "chrome/common/pref_names.h"
  51 #include "components/autofill/core/common/password_form.h"
  52 #include "content/public/browser/native_web_keyboard_event.h"
  53 #include "content/public/browser/notification_details.h"
  54 #include "content/public/browser/notification_source.h"
  55 #include "content/public/browser/web_contents.h"
  56 #include "content/public/browser/web_contents_view.h"
  57 #include "grit/chromium_strings.h"
  58 #include "grit/generated_resources.h"
  59 #include "ui/base/l10n/l10n_util_mac.h"
  60 #include "ui/gfx/rect.h"
  61
  62 #if defined(ENABLE_ONE_CLICK_SIGNIN)
  63 #import "chrome/browser/ui/cocoa/one_click_signin_bubble_controller.h"
  64 #import "chrome/browser/ui/cocoa/one_click_signin_dialog_controller.h"
  65 #endif
  66
  67 using content::NativeWebKeyboardEvent;
  68 using content::SSLStatus;
  69 using content::WebContents;
  70
  71 namespace {
  72
  73 NSPoint GetPointForBubble(content::WebContents* web_contents,
  74                           int x_offset,
  75                           int y_offset) {
  76   NSView* view = web_contents->GetView()->GetNativeView();
  77   NSRect bounds = [view bounds];
  78   NSPoint point;
  79   point.x = NSMinX(bounds) + x_offset;
  80   // The view's origin is at the bottom but |rect|'s origin is at the top.
  81   point.y = NSMaxY(bounds) - y_offset;
  82   point = [view convertPoint:point toView:nil];
  83   point = [[view window] convertBaseToScreen:point];
  84   return point;
  85 }
  86
  87 }  // namespace
  88
  89 BrowserWindowCocoa::BrowserWindowCocoa(Browser* browser,
  90                                        BrowserWindowController* controller)
  91   : browser_(browser),
  92     controller_(controller),
  93     initial_show_state_(ui::SHOW_STATE_DEFAULT),
  94     attention_request_id_(0) {
  95
  96   gfx::Rect bounds;
  97   chrome::GetSavedWindowBoundsAndShowState(browser_,
  98                                            &bounds,
  99                                            &initial_show_state_);
 100
 101   browser_->search_model()->AddObserver(this);
 102 }
 103
 104 BrowserWindowCocoa::~BrowserWindowCocoa() {
 105   browser_->search_model()->RemoveObserver(this);
 106 }
 107
 108 void BrowserWindowCocoa::Show() {
 109   // The Browser associated with this browser window must become the active
 110   // browser at the time |Show()| is called. This is the natural behaviour under
 111   // Windows, but |-makeKeyAndOrderFront:| won't send |-windowDidBecomeMain:|
 112   // until we return to the runloop. Therefore any calls to
 113   // |chrome::FindLastActiveWithHostDesktopType| will return the previous
 114   // browser instead if we don't explicitly set it here.
 115   BrowserList::SetLastActive(browser_);
 116
 117   bool is_session_restore = browser_->is_session_restore();
 118   NSWindowAnimationBehavior saved_animation_behavior =
 119       NSWindowAnimationBehaviorDefault;
 120   bool did_save_animation_behavior = false;
 121   // Turn off swishing when restoring windows.
 122   if (is_session_restore &&
 123       [window() respondsToSelector:@selector(animationBehavior)] &&
 124       [window() respondsToSelector:@selector(setAnimationBehavior:)]) {
 125     did_save_animation_behavior = true;
 126     saved_animation_behavior = [window() animationBehavior];
 127     [window() setAnimationBehavior:NSWindowAnimationBehaviorNone];
 128   }
 129
 130   [window() makeKeyAndOrderFront:controller_];
 131
 132   // When creating windows from nibs it is necessary to |makeKeyAndOrderFront:|
 133   // prior to |orderOut:| then |miniaturize:| when restoring windows in the
 134   // minimized state.
 135   if (initial_show_state_ == ui::SHOW_STATE_MINIMIZED) {
 136     [window() orderOut:controller_];
 137     [window() miniaturize:controller_];
 138   } else if (initial_show_state_ == ui::SHOW_STATE_FULLSCREEN) {
 139     chrome::ToggleFullscreenMode(browser_);
 140   }
 141   initial_show_state_ = ui::SHOW_STATE_DEFAULT;
 142
 143   // Restore window animation behavior.
 144   if (did_save_animation_behavior)
 145     [window() setAnimationBehavior:saved_animation_behavior];
 146
 147   browser_->OnWindowDidShow();
 148 }
 149
 150 void BrowserWindowCocoa::ShowInactive() {
 151   [window() orderFront:controller_];
 152 }
 153
 154 void BrowserWindowCocoa::Hide() {
 155   // Not implemented.
 156 }
 157
 158 void BrowserWindowCocoa::SetBounds(const gfx::Rect& bounds) {
 159   gfx::Rect real_bounds = [controller_ enforceMinWindowSize:bounds];
 160
 161   ExitFullscreen();
 162   NSRect cocoa_bounds = NSMakeRect(real_bounds.x(), 0,
 163                                    real_bounds.width(),
 164                                    real_bounds.height());
 165   // Flip coordinates based on the primary screen.
 166   NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
 167   cocoa_bounds.origin.y =
 168       NSHeight([screen frame]) - real_bounds.height() - real_bounds.y();
 169
 170   [window() setFrame:cocoa_bounds display:YES];
 171 }
 172
 173 // Callers assume that this doesn't immediately delete the Browser object.
 174 // The controller implementing the window delegate methods called from
 175 // |-performClose:| must take precautions to ensure that.
 176 void BrowserWindowCocoa::Close() {
 177   // If there is an overlay window, we contain a tab being dragged between
 178   // windows. Don't hide the window as it makes the UI extra confused. We can
 179   // still close the window, as that will happen when the drag completes.
 180   if ([controller_ overlayWindow]) {
 181     [controller_ deferPerformClose];
 182   } else {
 183     // Using |-performClose:| can prevent the window from actually closing if
 184     // a JavaScript beforeunload handler opens an alert during shutdown, as
 185     // documented at <http://crbug.com/118424>. Re-implement
 186     // -[NSWindow performClose:] as closely as possible to how Apple documents
 187     // it.
 188     //
 189     // Before calling |-close|, hide the window immediately. |-performClose:|
 190     // would do something similar, and this ensures that the window is removed
 191     // from AppKit's display list. Not doing so can lead to crashes like
 192     // <http://crbug.com/156101>.
 193     id<NSWindowDelegate> delegate = [window() delegate];
 194     SEL window_should_close = @selector(windowShouldClose:);
 195     if ([delegate respondsToSelector:window_should_close]) {
 196       if ([delegate windowShouldClose:window()]) {
 197         [window() orderOut:nil];
 198         [window() close];
 199       }
 200     } else if ([window() respondsToSelector:window_should_close]) {
 201       if ([window() performSelector:window_should_close withObject:window()]) {
 202         [window() orderOut:nil];
 203         [window() close];
 204       }
 205     } else {
 206       [window() orderOut:nil];
 207       [window() close];
 208     }
 209   }
 210 }
 211
 212 void BrowserWindowCocoa::Activate() {
 213   [controller_ activate];
 214 }
 215
 216 void BrowserWindowCocoa::Deactivate() {
 217   // TODO(jcivelli): http://crbug.com/51364 Implement me.
 218   NOTIMPLEMENTED();
 219 }
 220
 221 void BrowserWindowCocoa::FlashFrame(bool flash) {
 222   if (flash) {
 223     attention_request_id_ = [NSApp requestUserAttention:NSInformationalRequest];
 224   } else {
 225     [NSApp cancelUserAttentionRequest:attention_request_id_];
 226     attention_request_id_ = 0;
 227   }
 228 }
 229
 230 bool BrowserWindowCocoa::IsAlwaysOnTop() const {
 231   return false;
 232 }
 233
 234 void BrowserWindowCocoa::SetAlwaysOnTop(bool always_on_top) {
 235   // Not implemented for browser windows.
 236   NOTIMPLEMENTED();
 237 }
 238
 239 bool BrowserWindowCocoa::IsActive() const {
 240   return [window() isKeyWindow];
 241 }
 242
 243 gfx::NativeWindow BrowserWindowCocoa::GetNativeWindow() {
 244   return window();
 245 }
 246
 247 BrowserWindowTesting* BrowserWindowCocoa::GetBrowserWindowTesting() {
 248   return NULL;
 249 }
 250
 251 StatusBubble* BrowserWindowCocoa::GetStatusBubble() {
 252   return [controller_ statusBubble];
 253 }
 254
 255 void BrowserWindowCocoa::UpdateTitleBar() {
 256   NSString* newTitle =
 257       base::SysUTF16ToNSString(browser_->GetWindowTitleForCurrentTab());
 258
 259   pending_window_title_.reset(
 260       [BrowserWindowUtils scheduleReplaceOldTitle:pending_window_title_.get()
 261                                      withNewTitle:newTitle
 262                                         forWindow:window()]);
 263 }
 264
 265 void BrowserWindowCocoa::BookmarkBarStateChanged(
 266     BookmarkBar::AnimateChangeType change_type) {
 267   [[controller_ bookmarkBarController]
 268       updateState:browser_->bookmark_bar_state()
 269        changeType:change_type];
 270 }
 271
 272 void BrowserWindowCocoa::UpdateDevTools() {
 273   [controller_ updateDevToolsForContents:
 274       browser_->tab_strip_model()->GetActiveWebContents()];
 275 }
 276
 277 void BrowserWindowCocoa::UpdateLoadingAnimations(bool should_animate) {
 278   // Do nothing on Mac.
 279 }
 280
 281 void BrowserWindowCocoa::SetStarredState(bool is_starred) {
 282   [controller_ setStarredState:is_starred ? YES : NO];
 283 }
 284
 285 void BrowserWindowCocoa::SetTranslateIconToggled(bool is_lit) {
 286   NOTIMPLEMENTED();
 287 }
 288
 289 void BrowserWindowCocoa::OnActiveTabChanged(content::WebContents* old_contents,
 290                                             content::WebContents* new_contents,
 291                                             int index,
 292                                             int reason) {
 293   // TODO(pkasting): Perhaps the code in
 294   // TabStripController::activateTabWithContents should move here?  Or this
 295   // should call that (instead of TabStripModelObserverBridge doing so)?  It's
 296   // not obvious to me why Mac doesn't handle tab changes in BrowserWindow the
 297   // way views and GTK do.
 298 }
 299
 300 void BrowserWindowCocoa::ZoomChangedForActiveTab(bool can_show_bubble) {
 301   [controller_ zoomChangedForActiveTab:can_show_bubble ? YES : NO];
 302 }
 303
 304 gfx::Rect BrowserWindowCocoa::GetRestoredBounds() const {
 305   // Flip coordinates based on the primary screen.
 306   NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
 307   NSRect frame = [controller_ regularWindowFrame];
 308   gfx::Rect bounds(frame.origin.x, 0, NSWidth(frame), NSHeight(frame));
 309   bounds.set_y(NSHeight([screen frame]) - NSMaxY(frame));
 310   return bounds;
 311 }
 312
 313 ui::WindowShowState BrowserWindowCocoa::GetRestoredState() const {
 314   if (IsMaximized())
 315     return ui::SHOW_STATE_MAXIMIZED;
 316   if (IsMinimized())
 317     return ui::SHOW_STATE_MINIMIZED;
 318   return ui::SHOW_STATE_NORMAL;
 319 }
 320
 321 gfx::Rect BrowserWindowCocoa::GetBounds() const {
 322   return GetRestoredBounds();
 323 }
 324
 325 bool BrowserWindowCocoa::IsMaximized() const {
 326   return [window() isZoomed];
 327 }
 328
 329 bool BrowserWindowCocoa::IsMinimized() const {
 330   return [window() isMiniaturized];
 331 }
 332
 333 void BrowserWindowCocoa::Maximize() {
 334   // Zoom toggles so only call if not already maximized.
 335   if (!IsMaximized())
 336     [window() zoom:controller_];
 337 }
 338
 339 void BrowserWindowCocoa::Minimize() {
 340   [window() miniaturize:controller_];
 341 }
 342
 343 void BrowserWindowCocoa::Restore() {
 344   if (IsMaximized())
 345     [window() zoom:controller_];  // Toggles zoom mode.
 346   else if (IsMinimized())
 347     [window() deminiaturize:controller_];
 348 }
 349
 350 void BrowserWindowCocoa::EnterFullscreen(
 351       const GURL& url, FullscreenExitBubbleType bubble_type) {
 352   // When simplified fullscreen is enabled, always enter normal fullscreen.
 353   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 354   if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen)) {
 355     if (url.is_empty())
 356       [controller_ enterFullscreen];
 357     else
 358       [controller_ enterFullscreenForURL:url bubbleType:bubble_type];
 359     return;
 360   }
 361
 362   [controller_ enterPresentationModeForURL:url
 363                                 bubbleType:bubble_type];
 364 }
 365
 366 void BrowserWindowCocoa::ExitFullscreen() {
 367   [controller_ exitFullscreen];
 368 }
 369
 370 void BrowserWindowCocoa::UpdateFullscreenExitBubbleContent(
 371       const GURL& url,
 372       FullscreenExitBubbleType bubble_type) {
 373   [controller_ updateFullscreenExitBubbleURL:url bubbleType:bubble_type];
 374 }
 375
 376 bool BrowserWindowCocoa::ShouldHideUIForFullscreen() const {
 377   // On Mac, fullscreen mode has most normal things (in a slide-down panel).
 378   return false;
 379 }
 380
 381 bool BrowserWindowCocoa::IsFullscreen() const {
 382   if ([controller_ inPresentationMode])
 383     CHECK([controller_ isFullscreen]);  // Presentation mode must be fullscreen.
 384   return [controller_ isFullscreen];
 385 }
 386
 387 bool BrowserWindowCocoa::IsFullscreenBubbleVisible() const {
 388   return false;
 389 }
 390
 391 void BrowserWindowCocoa::ConfirmAddSearchProvider(
 392     TemplateURL* template_url,
 393     Profile* profile) {
 394   // The controller will release itself when the window closes.
 395   EditSearchEngineCocoaController* editor =
 396       [[EditSearchEngineCocoaController alloc] initWithProfile:profile
 397                                                       delegate:NULL
 398                                                    templateURL:template_url];
 399   [NSApp beginSheet:[editor window]
 400      modalForWindow:window()
 401       modalDelegate:controller_
 402      didEndSelector:@selector(sheetDidEnd:returnCode:context:)
 403         contextInfo:NULL];
 404 }
 405
 406 LocationBar* BrowserWindowCocoa::GetLocationBar() const {
 407   return [controller_ locationBarBridge];
 408 }
 409
 410 void BrowserWindowCocoa::SetFocusToLocationBar(bool select_all) {
 411   [controller_ focusLocationBar:select_all ? YES : NO];
 412 }
 413
 414 void BrowserWindowCocoa::UpdateReloadStopState(bool is_loading, bool force) {
 415   [controller_ setIsLoading:is_loading force:force];
 416 }
 417
 418 void BrowserWindowCocoa::UpdateToolbar(content::WebContents* contents) {
 419   [controller_ updateToolbarWithContents:contents];
 420 }
 421
 422 void BrowserWindowCocoa::FocusToolbar() {
 423   // Not needed on the Mac.
 424 }
 425
 426 void BrowserWindowCocoa::FocusAppMenu() {
 427   // Chrome uses the standard Mac OS X menu bar, so this isn't needed.
 428 }
 429
 430 void BrowserWindowCocoa::RotatePaneFocus(bool forwards) {
 431   // Not needed on the Mac.
 432 }
 433
 434 void BrowserWindowCocoa::FocusBookmarksToolbar() {
 435   // Not needed on the Mac.
 436 }
 437
 438 void BrowserWindowCocoa::FocusInfobars() {
 439   // Not needed on the Mac.
 440 }
 441
 442 bool BrowserWindowCocoa::IsBookmarkBarVisible() const {
 443   return browser_->profile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 444 }
 445
 446 bool BrowserWindowCocoa::IsBookmarkBarAnimating() const {
 447   return [controller_ isBookmarkBarAnimating];
 448 }
 449
 450 bool BrowserWindowCocoa::IsTabStripEditable() const {
 451   return ![controller_ isDragSessionActive];
 452 }
 453
 454 bool BrowserWindowCocoa::IsToolbarVisible() const {
 455   return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
 456          browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
 457 }
 458
 459 gfx::Rect BrowserWindowCocoa::GetRootWindowResizerRect() const {
 460   if (IsDownloadShelfVisible())
 461     return gfx::Rect();
 462   NSRect tabRect = [controller_ selectedTabGrowBoxRect];
 463   return gfx::Rect(NSRectToCGRect(tabRect));
 464 }
 465
 466 void BrowserWindowCocoa::AddFindBar(
 467     FindBarCocoaController* find_bar_cocoa_controller) {
 468   [controller_ addFindBar:find_bar_cocoa_controller];
 469 }
 470
 471 void BrowserWindowCocoa::ShowUpdateChromeDialog() {
 472   restart_browser::RequestRestart(window());
 473 }
 474
 475 void BrowserWindowCocoa::ShowBookmarkBubble(const GURL& url,
 476                                             bool already_bookmarked) {
 477   [controller_ showBookmarkBubbleForURL:url
 478                       alreadyBookmarked:(already_bookmarked ? YES : NO)];
 479 }
 480
 481 void BrowserWindowCocoa::ShowTranslateBubble(
 482       content::WebContents* contents,
 483       TranslateBubbleModel::ViewState view_state,
 484       TranslateErrors::Type error_type) {
 485   NOTIMPLEMENTED();
 486 }
 487
 488 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 489 void BrowserWindowCocoa::ShowOneClickSigninBubble(
 490     OneClickSigninBubbleType type,
 491     const base::string16& email,
 492     const base::string16& error_message,
 493     const StartSyncCallback& start_sync_callback) {
 494   WebContents* web_contents =
 495         browser_->tab_strip_model()->GetActiveWebContents();
 496   if (type == ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE) {
 497     base::scoped_nsobject<OneClickSigninBubbleController> bubble_controller([
 498             [OneClickSigninBubbleController alloc]
 499         initWithBrowserWindowController:cocoa_controller()
 500                             webContents:web_contents
 501                            errorMessage:base::SysUTF16ToNSString(error_message)
 502                                callback:start_sync_callback]);
 503     [bubble_controller showWindow:nil];
 504   } else {
 505     // Deletes itself when the dialog closes.
 506     new OneClickSigninDialogController(
 507         web_contents, start_sync_callback, email);
 508   }
 509 }
 510 #endif
 511
 512 bool BrowserWindowCocoa::IsDownloadShelfVisible() const {
 513   return [controller_ isDownloadShelfVisible] != NO;
 514 }
 515
 516 DownloadShelf* BrowserWindowCocoa::GetDownloadShelf() {
 517   DownloadShelfController* shelfController = [controller_ downloadShelf];
 518   return [shelfController bridge];
 519 }
 520
 521 // We allow closing the window here since the real quit decision on Mac is made
 522 // in [AppController quit:].
 523 void BrowserWindowCocoa::ConfirmBrowserCloseWithPendingDownloads(
 524       int download_count,
 525       Browser::DownloadClosePreventionType dialog_type,
 526       bool app_modal,
 527       const base::Callback<void(bool)>& callback) {
 528   callback.Run(true);
 529 }
 530
 531 void BrowserWindowCocoa::UserChangedTheme() {
 532   [controller_ userChangedTheme];
 533 }
 534
 535 int BrowserWindowCocoa::GetExtraRenderViewHeight() const {
 536   // Currently this is only used on linux.
 537   return 0;
 538 }
 539
 540 void BrowserWindowCocoa::WebContentsFocused(WebContents* contents) {
 541   NOTIMPLEMENTED();
 542 }
 543
 544 void BrowserWindowCocoa::ShowWebsiteSettings(
 545     Profile* profile,
 546     content::WebContents* web_contents,
 547     const GURL& url,
 548     const content::SSLStatus& ssl) {
 549   WebsiteSettingsUIBridge::Show(window(), profile, web_contents, url, ssl);
 550 }
 551
 552 void BrowserWindowCocoa::ShowAppMenu() {
 553   // No-op. Mac doesn't support showing the menus via alt keys.
 554 }
 555
 556 bool BrowserWindowCocoa::PreHandleKeyboardEvent(
 557     const NativeWebKeyboardEvent& event, bool* is_keyboard_shortcut) {
 558   if (![BrowserWindowUtils shouldHandleKeyboardEvent:event])
 559     return false;
 560
 561   if (event.type == blink::WebInputEvent::RawKeyDown &&
 562       [controller_ handledByExtensionCommand:event.os_event])
 563     return true;
 564
 565   int id = [BrowserWindowUtils getCommandId:event];
 566   if (id == -1)
 567     return false;
 568
 569   if (browser_->command_controller()->IsReservedCommandOrKey(id, event)) {
 570       return [BrowserWindowUtils handleKeyboardEvent:event.os_event
 571                                             inWindow:window()];
 572   }
 573
 574   DCHECK(is_keyboard_shortcut);
 575   *is_keyboard_shortcut = true;
 576   return false;
 577 }
 578
 579 void BrowserWindowCocoa::HandleKeyboardEvent(
 580     const NativeWebKeyboardEvent& event) {
 581   if ([BrowserWindowUtils shouldHandleKeyboardEvent:event])
 582     [BrowserWindowUtils handleKeyboardEvent:event.os_event inWindow:window()];
 583 }
 584
 585 void BrowserWindowCocoa::Cut() {
 586   [NSApp sendAction:@selector(cut:) to:nil from:nil];
 587 }
 588
 589 void BrowserWindowCocoa::Copy() {
 590   [NSApp sendAction:@selector(copy:) to:nil from:nil];
 591 }
 592
 593 void BrowserWindowCocoa::Paste() {
 594   [NSApp sendAction:@selector(paste:) to:nil from:nil];
 595 }
 596
 597 void BrowserWindowCocoa::OpenTabpose() {
 598   [controller_ openTabpose];
 599 }
 600
 601 void BrowserWindowCocoa::EnterFullscreenWithChrome() {
 602   // This method cannot be called if simplified fullscreen is enabled.
 603   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 604   DCHECK(!command_line->HasSwitch(switches::kEnableSimplifiedFullscreen));
 605
 606   CHECK(chrome::mac::SupportsSystemFullscreen());
 607   if ([controller_ inPresentationMode])
 608     [controller_ exitPresentationMode];
 609   else
 610     [controller_ enterFullscreen];
 611 }
 612
 613 bool BrowserWindowCocoa::IsFullscreenWithChrome() {
 614   // The WithChrome mode does not exist when simplified fullscreen is enabled.
 615   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 616   if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen))
 617     return false;
 618   return IsFullscreen() && ![controller_ inPresentationMode];
 619 }
 620
 621 bool BrowserWindowCocoa::IsFullscreenWithoutChrome() {
 622   // Presentation mode does not exist if simplified fullscreen is enabled.  The
 623   // WithoutChrome mode simply maps to whether or not the window is fullscreen.
 624   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 625   if (command_line->HasSwitch(switches::kEnableSimplifiedFullscreen))
 626     return IsFullscreen();
 627
 628   return IsFullscreen() && [controller_ inPresentationMode];
 629 }
 630
 631 WindowOpenDisposition BrowserWindowCocoa::GetDispositionForPopupBounds(
 632     const gfx::Rect& bounds) {
 633   // In Lion fullscreen mode, convert popups into tabs.
 634   if (chrome::mac::SupportsSystemFullscreen() && IsFullscreen())
 635     return NEW_FOREGROUND_TAB;
 636   return NEW_POPUP;
 637 }
 638
 639 FindBar* BrowserWindowCocoa::CreateFindBar() {
 640   // We could push the AddFindBar() call into the FindBarBridge
 641   // constructor or the FindBarCocoaController init, but that makes
 642   // unit testing difficult, since we would also require a
 643   // BrowserWindow object.
 644   FindBarBridge* bridge = new FindBarBridge(browser_);
 645   AddFindBar(bridge->find_bar_cocoa_controller());
 646   return bridge;
 647 }
 648
 649 web_modal::WebContentsModalDialogHost*
 650     BrowserWindowCocoa::GetWebContentsModalDialogHost() {
 651   return NULL;
 652 }
 653
 654 extensions::ActiveTabPermissionGranter*
 655     BrowserWindowCocoa::GetActiveTabPermissionGranter() {
 656   WebContents* web_contents =
 657       browser_->tab_strip_model()->GetActiveWebContents();
 658   if (!web_contents)
 659     return NULL;
 660   extensions::TabHelper* tab_helper =
 661       extensions::TabHelper::FromWebContents(web_contents);
 662   return tab_helper ? tab_helper->active_tab_permission_granter() : NULL;
 663 }
 664
 665 void BrowserWindowCocoa::ModelChanged(const SearchModel::State& old_state,
 666                                       const SearchModel::State& new_state) {
 667 }
 668
 669 void BrowserWindowCocoa::DestroyBrowser() {
 670   [controller_ destroyBrowser];
 671
 672   // at this point the controller is dead (autoreleased), so
 673   // make sure we don't try to reference it any more.
 674 }
 675
 676 NSWindow* BrowserWindowCocoa::window() const {
 677   return [controller_ window];
 678 }
 679
 680 void BrowserWindowCocoa::ShowAvatarBubble(WebContents* web_contents,
 681                                           const gfx::Rect& rect) {
 682   NSPoint point = GetPointForBubble(web_contents, rect.right(), rect.bottom());
 683
 684   // |menu| will automatically release itself on close.
 685   AvatarMenuBubbleController* menu =
 686       [[AvatarMenuBubbleController alloc] initWithBrowser:browser_
 687                                                anchoredAt:point];
 688   [[menu bubble] setAlignment:info_bubble::kAlignEdgeToAnchorEdge];
 689   [menu showWindow:nil];
 690 }
 691
 692 void BrowserWindowCocoa::ShowAvatarBubbleFromAvatarButton() {
 693   AvatarButtonController* controller = [controller_ avatarButtonController];
 694   [controller showAvatarBubble:[controller buttonView]];
 695 }
 696
 697 void BrowserWindowCocoa::ShowPasswordGenerationBubble(
 698     const gfx::Rect& rect,
 699     const autofill::PasswordForm& form,
 700     autofill::PasswordGenerator* password_generator) {
 701   WebContents* web_contents =
 702       browser_->tab_strip_model()->GetActiveWebContents();
 703   // We want to point to the middle of the rect instead of the right side.
 704   NSPoint point = GetPointForBubble(web_contents,
 705                                     rect.x() + rect.width()/2,
 706                                     rect.bottom());
 707
 708   PasswordGenerationBubbleController* controller =
 709       [[PasswordGenerationBubbleController alloc]
 710         initWithWindow:browser_->window()->GetNativeWindow()
 711             anchoredAt:point
 712         renderViewHost:web_contents->GetRenderViewHost()
 713         passwordManager:PasswordManager::FromWebContents(web_contents)
 714         usingGenerator:password_generator
 715                forForm:form];
 716   [controller showWindow:nil];
 717 }
 718
 719 int
 720 BrowserWindowCocoa::GetRenderViewHeightInsetWithDetachedBookmarkBar() {
 721   if (browser_->bookmark_bar_state() != BookmarkBar::DETACHED)
 722     return 0;
 723   // TODO(sail): please make this work with cocoa, then enable
 724   // BrowserTest.GetSizeForNewRenderView and
 725   // WebContentsImplBrowserTest.GetSizeForNewRenderView.
 726   // This function should return the extra height of the render view when
 727   // detached bookmark bar is hidden.
 728   // However, I (kuan) return 0 for now to retain the original behavior,
 729   // because I encountered the following problem on cocoa:
 730   // 1) When a navigation is requested,
 731   //    WebContentsImpl::CreateRenderViewForRenderManager creates the new
 732   //    RenderWidgetHostView at the size specified by
 733   //    WebContentsDelegate::GetSizeForNewRenderView implemented by Browser.
 734   // 2) When the pending navigation entry is committed,
 735   //    WebContentsImpl::UpdateRenderViewSizeForRenderManager udpates the size
 736   //    of WebContentsView to the size in (1).
 737   // 3) WebContentsImpl::DidNavigateMainFramePostCommit() is called, where
 738   //    the detached bookmark bar is hidden, resulting in relayout of tab
 739   //    contents area.
 740   // On cocoa, (2) causes RenderWidgetHostView to resize (enlarge) further.
 741   // e.g. if size in (1) is size A, and this function returns height H, height
 742   // of RenderWidgetHostView after (2) becomes A.height() + H; it's supposed to
 743   // stay at A.height().
 744   // Then, in (3), WebContentsView and RenderWidgetHostView enlarge even
 745   // further, both by another H, i.e. WebContentsView's height becomes
 746   // A.height() + H and RenderWidgetHostView's height becomes A.height() + 2H.
 747   // Strangely, the RenderWidgetHostView for the previous navigation entry also
 748   // gets enlarged by H.
 749   // I believe these "automatic" resizing are caused by setAutoresizingMask of
 750   // of the cocoa view in WebContentsViewMac, which defeats the purpose of
 751   // WebContentsDelegate::GetSizeForNewRenderView i.e. to prevent resizing of
 752   // RenderWidgetHostView in (2) and (3).
 753   return 0;
 754 }