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/browser_command_controller.h" 6 7 #include "base/command_line.h" 8 #include "base/prefs/pref_service.h" 9 #include "chrome/app/chrome_command_ids.h" 10 #include "chrome/browser/browser_process.h" 11 #include "chrome/browser/chrome_notification_types.h" 12 #include "chrome/browser/defaults.h" 13 #include "chrome/browser/extensions/extension_service.h" 14 #include "chrome/browser/lifetime/application_lifetime.h" 15 #include "chrome/browser/prefs/incognito_mode_prefs.h" 16 #include "chrome/browser/profiles/avatar_menu.h" 17 #include "chrome/browser/profiles/profile.h" 18 #include "chrome/browser/profiles/profile_manager.h" 19 #include "chrome/browser/sessions/tab_restore_service.h" 20 #include "chrome/browser/sessions/tab_restore_service_factory.h" 21 #include "chrome/browser/shell_integration.h" 22 #include "chrome/browser/signin/signin_promo.h" 23 #include "chrome/browser/sync/profile_sync_service.h" 24 #include "chrome/browser/sync/profile_sync_service_factory.h" 25 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h" 26 #include "chrome/browser/ui/browser.h" 27 #include "chrome/browser/ui/browser_commands.h" 28 #include "chrome/browser/ui/browser_window.h" 29 #include "chrome/browser/ui/chrome_pages.h" 30 #include "chrome/browser/ui/tabs/tab_strip_model.h" 31 #include "chrome/browser/ui/tabs/tab_strip_model_utils.h" 32 #include "chrome/browser/ui/webui/inspect_ui.h" 33 #include "chrome/common/chrome_switches.h" 34 #include "chrome/common/content_restriction.h" 35 #include "chrome/common/pref_names.h" 36 #include "chrome/common/profiling.h" 37 #include "content/public/browser/native_web_keyboard_event.h" 38 #include "content/public/browser/navigation_controller.h" 39 #include "content/public/browser/navigation_entry.h" 40 #include "content/public/browser/user_metrics.h" 41 #include "content/public/browser/web_contents.h" 42 #include "content/public/browser/web_contents_observer.h" 43 #include "content/public/common/url_constants.h" 44 #include "ui/events/keycodes/keyboard_codes.h" 45 46 #if defined(OS_MACOSX) 47 #include "chrome/browser/ui/browser_commands_mac.h" 48 #endif 49 50 #if defined(OS_WIN) 51 #include "base/win/metro.h" 52 #include "base/win/windows_version.h" 53 #include "chrome/browser/ui/apps/apps_metro_handler_win.h" 54 #include "content/public/browser/gpu_data_manager.h" 55 #endif 56 57 #if defined(USE_ASH) 58 #include "ash/accelerators/accelerator_commands.h" 59 #include "chrome/browser/ui/ash/ash_util.h" 60 #endif 61 62 #if defined(OS_CHROMEOS) 63 #include "ash/multi_profile_uma.h" 64 #include "ash/session_state_delegate.h" 65 #include "ash/shell.h" 66 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h" 67 #endif 68 69 using content::NavigationEntry; 70 using content::NavigationController; 71 using content::WebContents; 72 73 namespace { 74 75 enum WindowState { 76 // Not in fullscreen mode. 77 WINDOW_STATE_NOT_FULLSCREEN, 78 79 // Fullscreen mode, occupying the whole screen. 80 WINDOW_STATE_FULLSCREEN, 81 82 // Fullscreen mode for metro snap, occupying the full height and 20% of 83 // the screen width. 84 WINDOW_STATE_METRO_SNAP, 85 }; 86 87 // Returns |true| if entry has an internal chrome:// URL, |false| otherwise. 88 bool HasInternalURL(const NavigationEntry* entry) { 89 if (!entry) 90 return false; 91 92 // Check the |virtual_url()| first. This catches regular chrome:// URLs 93 // including URLs that were rewritten (such as chrome://bookmarks). 94 if (entry->GetVirtualURL().SchemeIs(chrome::kChromeUIScheme)) 95 return true; 96 97 // If the |virtual_url()| isn't a chrome:// URL, check if it's actually 98 // view-source: of a chrome:// URL. 99 if (entry->GetVirtualURL().SchemeIs(content::kViewSourceScheme)) 100 return entry->GetURL().SchemeIs(chrome::kChromeUIScheme); 101 102 return false; 103 } 104 105 #if defined(OS_WIN) 106 // Windows 8 specific helper class to manage DefaultBrowserWorker. It does the 107 // following asynchronous actions in order: 108 // 1- Check that chrome is the default browser 109 // 2- If we are the default, restart chrome in metro and exit 110 // 3- If not the default browser show the 'select default browser' system dialog 111 // 4- When dialog dismisses check again who got made the default 112 // 5- If we are the default then restart chrome in metro and exit 113 // 6- If we are not the default exit. 114 // 115 // Note: this class deletes itself. 116 class SwitchToMetroUIHandler 117 : public ShellIntegration::DefaultWebClientObserver { 118 public: 119 SwitchToMetroUIHandler() 120 : default_browser_worker_( 121 new ShellIntegration::DefaultBrowserWorker(this)), 122 first_check_(true) { 123 default_browser_worker_->StartCheckIsDefault(); 124 } 125 126 virtual ~SwitchToMetroUIHandler() { 127 default_browser_worker_->ObserverDestroyed(); 128 } 129 130 private: 131 virtual void SetDefaultWebClientUIState( 132 ShellIntegration::DefaultWebClientUIState state) OVERRIDE { 133 switch (state) { 134 case ShellIntegration::STATE_PROCESSING: 135 return; 136 case ShellIntegration::STATE_UNKNOWN : 137 break; 138 case ShellIntegration::STATE_IS_DEFAULT: 139 chrome::AttemptRestartToMetroMode(); 140 break; 141 case ShellIntegration::STATE_NOT_DEFAULT: 142 if (first_check_) { 143 default_browser_worker_->StartSetAsDefault(); 144 return; 145 } 146 break; 147 default: 148 NOTREACHED(); 149 } 150 delete this; 151 } 152 153 virtual void OnSetAsDefaultConcluded(bool success) OVERRIDE { 154 if (!success) { 155 delete this; 156 return; 157 } 158 first_check_ = false; 159 default_browser_worker_->StartCheckIsDefault(); 160 } 161 162 virtual bool IsInteractiveSetDefaultPermitted() OVERRIDE { 163 return true; 164 } 165 166 scoped_refptr<ShellIntegration::DefaultBrowserWorker> default_browser_worker_; 167 bool first_check_; 168 169 DISALLOW_COPY_AND_ASSIGN(SwitchToMetroUIHandler); 170 }; 171 #endif // defined(OS_WIN) 172 173 } // namespace 174 175 namespace chrome { 176 177 /////////////////////////////////////////////////////////////////////////////// 178 // BrowserCommandController, public: 179 180 BrowserCommandController::BrowserCommandController( 181 Browser* browser, 182 ProfileManager* profile_manager) 183 : browser_(browser), 184 profile_manager_(profile_manager), 185 command_updater_(this), 186 block_command_execution_(false), 187 last_blocked_command_id_(-1), 188 last_blocked_command_disposition_(CURRENT_TAB) { 189 if (profile_manager_) 190 profile_manager_->GetProfileInfoCache().AddObserver(this); 191 browser_->tab_strip_model()->AddObserver(this); 192 PrefService* local_state = g_browser_process->local_state(); 193 if (local_state) { 194 local_pref_registrar_.Init(local_state); 195 local_pref_registrar_.Add( 196 prefs::kAllowFileSelectionDialogs, 197 base::Bind( 198 &BrowserCommandController::UpdateCommandsForFileSelectionDialogs, 199 base::Unretained(this))); 200 } 201 202 profile_pref_registrar_.Init(profile()->GetPrefs()); 203 profile_pref_registrar_.Add( 204 prefs::kDevToolsDisabled, 205 base::Bind(&BrowserCommandController::UpdateCommandsForDevTools, 206 base::Unretained(this))); 207 profile_pref_registrar_.Add( 208 prefs::kEditBookmarksEnabled, 209 base::Bind(&BrowserCommandController::UpdateCommandsForBookmarkEditing, 210 base::Unretained(this))); 211 profile_pref_registrar_.Add( 212 prefs::kShowBookmarkBar, 213 base::Bind(&BrowserCommandController::UpdateCommandsForBookmarkBar, 214 base::Unretained(this))); 215 profile_pref_registrar_.Add( 216 prefs::kIncognitoModeAvailability, 217 base::Bind( 218 &BrowserCommandController::UpdateCommandsForIncognitoAvailability, 219 base::Unretained(this))); 220 profile_pref_registrar_.Add( 221 prefs::kPrintingEnabled, 222 base::Bind(&BrowserCommandController::UpdatePrintingState, 223 base::Unretained(this))); 224 #if !defined(OS_MACOSX) 225 profile_pref_registrar_.Add( 226 prefs::kFullscreenAllowed, 227 base::Bind(&BrowserCommandController::UpdateCommandsForFullscreenMode, 228 base::Unretained(this))); 229 #endif 230 pref_signin_allowed_.Init( 231 prefs::kSigninAllowed, 232 profile()->GetOriginalProfile()->GetPrefs(), 233 base::Bind(&BrowserCommandController::OnSigninAllowedPrefChange, 234 base::Unretained(this))); 235 236 InitCommandState(); 237 238 TabRestoreService* tab_restore_service = 239 TabRestoreServiceFactory::GetForProfile(profile()); 240 if (tab_restore_service) { 241 tab_restore_service->AddObserver(this); 242 TabRestoreServiceChanged(tab_restore_service); 243 } 244 } 245 246 BrowserCommandController::~BrowserCommandController() { 247 // TabRestoreService may have been shutdown by the time we get here. Don't 248 // trigger creating it. 249 TabRestoreService* tab_restore_service = 250 TabRestoreServiceFactory::GetForProfileIfExisting(profile()); 251 if (tab_restore_service) 252 tab_restore_service->RemoveObserver(this); 253 profile_pref_registrar_.RemoveAll(); 254 local_pref_registrar_.RemoveAll(); 255 browser_->tab_strip_model()->RemoveObserver(this); 256 if (profile_manager_) 257 profile_manager_->GetProfileInfoCache().RemoveObserver(this); 258 } 259 260 bool BrowserCommandController::IsReservedCommandOrKey( 261 int command_id, 262 const content::NativeWebKeyboardEvent& event) { 263 // In Apps mode, no keys are reserved. 264 if (browser_->is_app()) 265 return false; 266 267 #if defined(OS_CHROMEOS) 268 // On Chrome OS, the top row of keys are mapped to browser actions like 269 // back/forward or refresh. We don't want web pages to be able to change the 270 // behavior of these keys. Ash handles F4 and up; this leaves us needing to 271 // reserve browser back/forward and refresh here. 272 ui::KeyboardCode key_code = 273 static_cast<ui::KeyboardCode>(event.windowsKeyCode); 274 if ((key_code == ui::VKEY_BROWSER_BACK && command_id == IDC_BACK) || 275 (key_code == ui::VKEY_BROWSER_FORWARD && command_id == IDC_FORWARD) || 276 (key_code == ui::VKEY_BROWSER_REFRESH && command_id == IDC_RELOAD)) { 277 return true; 278 } 279 #endif 280 281 if (window()->IsFullscreen() && command_id == IDC_FULLSCREEN) 282 return true; 283 return command_id == IDC_CLOSE_TAB || 284 command_id == IDC_CLOSE_WINDOW || 285 command_id == IDC_NEW_INCOGNITO_WINDOW || 286 command_id == IDC_NEW_TAB || 287 command_id == IDC_NEW_WINDOW || 288 command_id == IDC_RESTORE_TAB || 289 command_id == IDC_SELECT_NEXT_TAB || 290 command_id == IDC_SELECT_PREVIOUS_TAB || 291 command_id == IDC_TABPOSE || 292 command_id == IDC_EXIT; 293 } 294 295 void BrowserCommandController::SetBlockCommandExecution(bool block) { 296 block_command_execution_ = block; 297 if (block) { 298 last_blocked_command_id_ = -1; 299 last_blocked_command_disposition_ = CURRENT_TAB; 300 } 301 } 302 303 int BrowserCommandController::GetLastBlockedCommand( 304 WindowOpenDisposition* disposition) { 305 if (disposition) 306 *disposition = last_blocked_command_disposition_; 307 return last_blocked_command_id_; 308 } 309 310 void BrowserCommandController::TabStateChanged() { 311 UpdateCommandsForTabState(); 312 } 313 314 void BrowserCommandController::ContentRestrictionsChanged() { 315 UpdateCommandsForContentRestrictionState(); 316 } 317 318 void BrowserCommandController::FullscreenStateChanged() { 319 UpdateCommandsForFullscreenMode(); 320 } 321 322 void BrowserCommandController::PrintingStateChanged() { 323 UpdatePrintingState(); 324 } 325 326 void BrowserCommandController::LoadingStateChanged(bool is_loading, 327 bool force) { 328 UpdateReloadStopState(is_loading, force); 329 } 330 331 //////////////////////////////////////////////////////////////////////////////// 332 // BrowserCommandController, CommandUpdaterDelegate implementation: 333 334 void BrowserCommandController::ExecuteCommandWithDisposition( 335 int id, 336 WindowOpenDisposition disposition) { 337 // No commands are enabled if there is not yet any selected tab. 338 // TODO(pkasting): It seems like we should not need this, because either 339 // most/all commands should not have been enabled yet anyway or the ones that 340 // are enabled should be global, or safe themselves against having no selected 341 // tab. However, Ben says he tried removing this before and got lots of 342 // crashes, e.g. from Windows sending WM_COMMANDs at random times during 343 // window construction. This probably could use closer examination someday. 344 if (browser_->tab_strip_model()->active_index() == TabStripModel::kNoTab) 345 return; 346 347 DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command " 348 << id; 349 350 // If command execution is blocked then just record the command and return. 351 if (block_command_execution_) { 352 // We actually only allow no more than one blocked command, otherwise some 353 // commands maybe lost. 354 DCHECK_EQ(last_blocked_command_id_, -1); 355 last_blocked_command_id_ = id; 356 last_blocked_command_disposition_ = disposition; 357 return; 358 } 359 360 // The order of commands in this switch statement must match the function 361 // declaration order in browser.h! 362 switch (id) { 363 // Navigation commands 364 case IDC_BACK: 365 GoBack(browser_, disposition); 366 break; 367 case IDC_FORWARD: 368 GoForward(browser_, disposition); 369 break; 370 case IDC_RELOAD: 371 Reload(browser_, disposition); 372 break; 373 case IDC_RELOAD_CLEARING_CACHE: 374 ClearCache(browser_); 375 // FALL THROUGH 376 case IDC_RELOAD_IGNORING_CACHE: 377 ReloadIgnoringCache(browser_, disposition); 378 break; 379 case IDC_HOME: 380 Home(browser_, disposition); 381 break; 382 case IDC_OPEN_CURRENT_URL: 383 OpenCurrentURL(browser_); 384 break; 385 case IDC_STOP: 386 Stop(browser_); 387 break; 388 389 // Window management commands 390 case IDC_NEW_WINDOW: 391 NewWindow(browser_); 392 break; 393 case IDC_NEW_INCOGNITO_WINDOW: 394 NewIncognitoWindow(browser_); 395 break; 396 case IDC_CLOSE_WINDOW: 397 content::RecordAction(content::UserMetricsAction("CloseWindowByKey")); 398 CloseWindow(browser_); 399 break; 400 case IDC_NEW_TAB: 401 NewTab(browser_); 402 break; 403 case IDC_CLOSE_TAB: 404 content::RecordAction(content::UserMetricsAction("CloseTabByKey")); 405 CloseTab(browser_); 406 break; 407 case IDC_SELECT_NEXT_TAB: 408 content::RecordAction(content::UserMetricsAction("Accel_SelectNextTab")); 409 SelectNextTab(browser_); 410 break; 411 case IDC_SELECT_PREVIOUS_TAB: 412 content::RecordAction( 413 content::UserMetricsAction("Accel_SelectPreviousTab")); 414 SelectPreviousTab(browser_); 415 break; 416 case IDC_TABPOSE: 417 OpenTabpose(browser_); 418 break; 419 case IDC_MOVE_TAB_NEXT: 420 MoveTabNext(browser_); 421 break; 422 case IDC_MOVE_TAB_PREVIOUS: 423 MoveTabPrevious(browser_); 424 break; 425 case IDC_SELECT_TAB_0: 426 case IDC_SELECT_TAB_1: 427 case IDC_SELECT_TAB_2: 428 case IDC_SELECT_TAB_3: 429 case IDC_SELECT_TAB_4: 430 case IDC_SELECT_TAB_5: 431 case IDC_SELECT_TAB_6: 432 case IDC_SELECT_TAB_7: 433 SelectNumberedTab(browser_, id - IDC_SELECT_TAB_0); 434 break; 435 case IDC_SELECT_LAST_TAB: 436 SelectLastTab(browser_); 437 break; 438 case IDC_DUPLICATE_TAB: 439 DuplicateTab(browser_); 440 break; 441 case IDC_RESTORE_TAB: 442 RestoreTab(browser_); 443 break; 444 case IDC_SHOW_AS_TAB: 445 ConvertPopupToTabbedBrowser(browser_); 446 break; 447 case IDC_FULLSCREEN: 448 #if defined(OS_MACOSX) 449 chrome::ToggleFullscreenWithChromeOrFallback(browser_); 450 #else 451 chrome::ToggleFullscreenMode(browser_); 452 #endif 453 break; 454 455 #if defined(USE_ASH) 456 case IDC_TOGGLE_ASH_DESKTOP: 457 chrome::ToggleAshDesktop(); 458 break; 459 case IDC_MINIMIZE_WINDOW: 460 content::RecordAction( 461 content::UserMetricsAction("Accel_Toggle_Minimized_M")); 462 ash::accelerators::ToggleMinimized(); 463 break; 464 // If Ash needs many more commands here we should implement a general 465 // mechanism to pass accelerators back into Ash. http://crbug.com/285308 466 #endif 467 468 #if defined(OS_CHROMEOS) 469 case IDC_VISIT_DESKTOP_OF_LRU_USER_2: 470 case IDC_VISIT_DESKTOP_OF_LRU_USER_3: { 471 ash::MultiProfileUMA::RecordTeleportAction( 472 ash::MultiProfileUMA::TELEPORT_WINDOW_CAPTION_MENU); 473 // When running the multi user mode on Chrome OS, windows can "visit" 474 // another user's desktop. 475 const std::string& user_id = 476 ash::Shell::GetInstance()->session_state_delegate()->GetUserID( 477 IDC_VISIT_DESKTOP_OF_LRU_USER_2 == id ? 1 : 2); 478 chrome::MultiUserWindowManager::GetInstance()->ShowWindowForUser( 479 browser_->window()->GetNativeWindow(), 480 user_id); 481 break; 482 } 483 #endif 484 485 #if defined(OS_WIN) 486 // Windows 8 specific commands. 487 case IDC_METRO_SNAP_ENABLE: 488 browser_->SetMetroSnapMode(true); 489 break; 490 case IDC_METRO_SNAP_DISABLE: 491 browser_->SetMetroSnapMode(false); 492 break; 493 case IDC_WIN8_DESKTOP_RESTART: 494 if (!VerifyMetroSwitchForApps(window()->GetNativeWindow(), id)) 495 break; 496 497 chrome::AttemptRestartToDesktopMode(); 498 content::RecordAction(content::UserMetricsAction("Win8DesktopRestart")); 499 break; 500 case IDC_WIN8_METRO_RESTART: 501 if (!VerifyMetroSwitchForApps(window()->GetNativeWindow(), id)) 502 break; 503 504 // SwitchToMetroUIHandler deletes itself. 505 new SwitchToMetroUIHandler; 506 content::RecordAction(content::UserMetricsAction("Win8MetroRestart")); 507 break; 508 #endif 509 510 #if defined(OS_MACOSX) 511 case IDC_PRESENTATION_MODE: 512 chrome::ToggleFullscreenMode(browser_); 513 break; 514 #endif 515 case IDC_EXIT: 516 Exit(); 517 break; 518 519 // Page-related commands 520 case IDC_SAVE_PAGE: 521 SavePage(browser_); 522 break; 523 case IDC_BOOKMARK_PAGE: 524 BookmarkCurrentPage(browser_); 525 break; 526 case IDC_BOOKMARK_PAGE_FROM_STAR: 527 BookmarkCurrentPageFromStar(browser_); 528 break; 529 case IDC_PIN_TO_START_SCREEN: 530 TogglePagePinnedToStartScreen(browser_); 531 break; 532 case IDC_BOOKMARK_ALL_TABS: 533 BookmarkAllTabs(browser_); 534 break; 535 case IDC_VIEW_SOURCE: 536 ViewSelectedSource(browser_); 537 break; 538 case IDC_EMAIL_PAGE_LOCATION: 539 EmailPageLocation(browser_); 540 break; 541 case IDC_PRINT: 542 Print(browser_); 543 break; 544 case IDC_ADVANCED_PRINT: 545 content::RecordAction(content::UserMetricsAction("Accel_Advanced_Print")); 546 AdvancedPrint(browser_); 547 break; 548 case IDC_PRINT_TO_DESTINATION: 549 PrintToDestination(browser_); 550 break; 551 case IDC_TRANSLATE_PAGE: 552 Translate(browser_); 553 break; 554 case IDC_ENCODING_AUTO_DETECT: 555 browser_->ToggleEncodingAutoDetect(); 556 break; 557 case IDC_ENCODING_UTF8: 558 case IDC_ENCODING_UTF16LE: 559 case IDC_ENCODING_ISO88591: 560 case IDC_ENCODING_WINDOWS1252: 561 case IDC_ENCODING_GBK: 562 case IDC_ENCODING_GB18030: 563 case IDC_ENCODING_BIG5HKSCS: 564 case IDC_ENCODING_BIG5: 565 case IDC_ENCODING_KOREAN: 566 case IDC_ENCODING_SHIFTJIS: 567 case IDC_ENCODING_ISO2022JP: 568 case IDC_ENCODING_EUCJP: 569 case IDC_ENCODING_THAI: 570 case IDC_ENCODING_ISO885915: 571 case IDC_ENCODING_MACINTOSH: 572 case IDC_ENCODING_ISO88592: 573 case IDC_ENCODING_WINDOWS1250: 574 case IDC_ENCODING_ISO88595: 575 case IDC_ENCODING_WINDOWS1251: 576 case IDC_ENCODING_KOI8R: 577 case IDC_ENCODING_KOI8U: 578 case IDC_ENCODING_ISO88597: 579 case IDC_ENCODING_WINDOWS1253: 580 case IDC_ENCODING_ISO88594: 581 case IDC_ENCODING_ISO885913: 582 case IDC_ENCODING_WINDOWS1257: 583 case IDC_ENCODING_ISO88593: 584 case IDC_ENCODING_ISO885910: 585 case IDC_ENCODING_ISO885914: 586 case IDC_ENCODING_ISO885916: 587 case IDC_ENCODING_WINDOWS1254: 588 case IDC_ENCODING_ISO88596: 589 case IDC_ENCODING_WINDOWS1256: 590 case IDC_ENCODING_ISO88598: 591 case IDC_ENCODING_ISO88598I: 592 case IDC_ENCODING_WINDOWS1255: 593 case IDC_ENCODING_WINDOWS1258: 594 browser_->OverrideEncoding(id); 595 break; 596 597 // Clipboard commands 598 case IDC_CUT: 599 Cut(browser_); 600 break; 601 case IDC_COPY: 602 Copy(browser_); 603 break; 604 case IDC_PASTE: 605 Paste(browser_); 606 break; 607 608 // Find-in-page 609 case IDC_FIND: 610 Find(browser_); 611 break; 612 case IDC_FIND_NEXT: 613 FindNext(browser_); 614 break; 615 case IDC_FIND_PREVIOUS: 616 FindPrevious(browser_); 617 break; 618 619 // Zoom 620 case IDC_ZOOM_PLUS: 621 Zoom(browser_, content::PAGE_ZOOM_IN); 622 break; 623 case IDC_ZOOM_NORMAL: 624 Zoom(browser_, content::PAGE_ZOOM_RESET); 625 break; 626 case IDC_ZOOM_MINUS: 627 Zoom(browser_, content::PAGE_ZOOM_OUT); 628 break; 629 630 // Focus various bits of UI 631 case IDC_FOCUS_TOOLBAR: 632 content::RecordAction(content::UserMetricsAction("Accel_Focus_Toolbar")); 633 FocusToolbar(browser_); 634 break; 635 case IDC_FOCUS_LOCATION: 636 content::RecordAction(content::UserMetricsAction("Accel_Focus_Location")); 637 FocusLocationBar(browser_); 638 break; 639 case IDC_FOCUS_SEARCH: 640 content::RecordAction(content::UserMetricsAction("Accel_Focus_Search")); 641 FocusSearch(browser_); 642 break; 643 case IDC_FOCUS_MENU_BAR: 644 FocusAppMenu(browser_); 645 break; 646 case IDC_FOCUS_BOOKMARKS: 647 content::RecordAction( 648 content::UserMetricsAction("Accel_Focus_Bookmarks")); 649 FocusBookmarksToolbar(browser_); 650 break; 651 case IDC_FOCUS_INFOBARS: 652 FocusInfobars(browser_); 653 break; 654 case IDC_FOCUS_NEXT_PANE: 655 FocusNextPane(browser_); 656 break; 657 case IDC_FOCUS_PREVIOUS_PANE: 658 FocusPreviousPane(browser_); 659 break; 660 661 // Show various bits of UI 662 case IDC_OPEN_FILE: 663 browser_->OpenFile(); 664 break; 665 case IDC_CREATE_SHORTCUTS: 666 CreateApplicationShortcuts(browser_); 667 break; 668 case IDC_CREATE_HOSTED_APP: 669 CreateHostedAppFromCurrentWebContents(browser_); 670 break; 671 case IDC_DEV_TOOLS: 672 ToggleDevToolsWindow(browser_, DevToolsToggleAction::Show()); 673 break; 674 case IDC_DEV_TOOLS_CONSOLE: 675 ToggleDevToolsWindow(browser_, DevToolsToggleAction::ShowConsole()); 676 break; 677 case IDC_DEV_TOOLS_DEVICES: 678 InspectUI::InspectDevices(browser_); 679 break; 680 case IDC_DEV_TOOLS_INSPECT: 681 ToggleDevToolsWindow(browser_, DevToolsToggleAction::Inspect()); 682 break; 683 case IDC_DEV_TOOLS_TOGGLE: 684 ToggleDevToolsWindow(browser_, DevToolsToggleAction::Toggle()); 685 break; 686 case IDC_TASK_MANAGER: 687 OpenTaskManager(browser_); 688 break; 689 #if defined(GOOGLE_CHROME_BUILD) 690 case IDC_FEEDBACK: 691 OpenFeedbackDialog(browser_); 692 break; 693 #endif 694 case IDC_SHOW_BOOKMARK_BAR: 695 ToggleBookmarkBar(browser_); 696 break; 697 case IDC_PROFILING_ENABLED: 698 Profiling::Toggle(); 699 break; 700 701 case IDC_SHOW_BOOKMARK_MANAGER: 702 ShowBookmarkManager(browser_); 703 break; 704 case IDC_SHOW_APP_MENU: 705 content::RecordAction(content::UserMetricsAction("Accel_Show_App_Menu")); 706 ShowAppMenu(browser_); 707 break; 708 case IDC_SHOW_AVATAR_MENU: 709 ShowAvatarMenu(browser_); 710 break; 711 case IDC_SHOW_HISTORY: 712 ShowHistory(browser_); 713 break; 714 case IDC_SHOW_DOWNLOADS: 715 ShowDownloads(browser_); 716 break; 717 case IDC_MANAGE_EXTENSIONS: 718 ShowExtensions(browser_, std::string()); 719 break; 720 case IDC_OPTIONS: 721 ShowSettings(browser_); 722 break; 723 case IDC_EDIT_SEARCH_ENGINES: 724 ShowSearchEngineSettings(browser_); 725 break; 726 case IDC_VIEW_PASSWORDS: 727 ShowPasswordManager(browser_); 728 break; 729 case IDC_CLEAR_BROWSING_DATA: 730 ShowClearBrowsingDataDialog(browser_); 731 break; 732 case IDC_IMPORT_SETTINGS: 733 ShowImportDialog(browser_); 734 break; 735 case IDC_TOGGLE_REQUEST_TABLET_SITE: 736 ToggleRequestTabletSite(browser_); 737 break; 738 case IDC_ABOUT: 739 ShowAboutChrome(browser_); 740 break; 741 case IDC_UPGRADE_DIALOG: 742 OpenUpdateChromeDialog(browser_); 743 break; 744 case IDC_VIEW_INCOMPATIBILITIES: 745 ShowConflicts(browser_); 746 break; 747 case IDC_HELP_PAGE_VIA_KEYBOARD: 748 ShowHelp(browser_, HELP_SOURCE_KEYBOARD); 749 break; 750 case IDC_HELP_PAGE_VIA_MENU: 751 ShowHelp(browser_, HELP_SOURCE_MENU); 752 break; 753 case IDC_SHOW_SIGNIN: 754 ShowBrowserSignin(browser_, signin::SOURCE_MENU); 755 break; 756 case IDC_TOGGLE_SPEECH_INPUT: 757 ToggleSpeechInput(browser_); 758 break; 759 760 default: 761 LOG(WARNING) << "Received Unimplemented Command: " << id; 762 break; 763 } 764 } 765 766 //////////////////////////////////////////////////////////////////////////////// 767 // BrowserCommandController, ProfileInfoCacheObserver implementation: 768 769 void BrowserCommandController::OnProfileAdded( 770 const base::FilePath& profile_path) { 771 UpdateCommandsForMultipleProfiles(); 772 } 773 774 void BrowserCommandController::OnProfileWasRemoved( 775 const base::FilePath& profile_path, 776 const base::string16& profile_name) { 777 UpdateCommandsForMultipleProfiles(); 778 } 779 780 //////////////////////////////////////////////////////////////////////////////// 781 // BrowserCommandController, SigninPrefObserver implementation: 782 783 void BrowserCommandController::OnSigninAllowedPrefChange() { 784 // For unit tests, we don't have a window. 785 if (!window()) 786 return; 787 UpdateShowSyncState(IsShowingMainUI()); 788 } 789 790 // BrowserCommandController, TabStripModelObserver implementation: 791 792 void BrowserCommandController::TabInsertedAt(WebContents* contents, 793 int index, 794 bool foreground) { 795 AddInterstitialObservers(contents); 796 } 797 798 void BrowserCommandController::TabDetachedAt(WebContents* contents, int index) { 799 RemoveInterstitialObservers(contents); 800 } 801 802 void BrowserCommandController::TabReplacedAt(TabStripModel* tab_strip_model, 803 WebContents* old_contents, 804 WebContents* new_contents, 805 int index) { 806 RemoveInterstitialObservers(old_contents); 807 AddInterstitialObservers(new_contents); 808 } 809 810 void BrowserCommandController::TabBlockedStateChanged( 811 content::WebContents* contents, 812 int index) { 813 PrintingStateChanged(); 814 FullscreenStateChanged(); 815 UpdateCommandsForFind(); 816 } 817 818 //////////////////////////////////////////////////////////////////////////////// 819 // BrowserCommandController, TabRestoreServiceObserver implementation: 820 821 void BrowserCommandController::TabRestoreServiceChanged( 822 TabRestoreService* service) { 823 command_updater_.UpdateCommandEnabled( 824 IDC_RESTORE_TAB, 825 GetRestoreTabType(browser_) != TabStripModelDelegate::RESTORE_NONE); 826 } 827 828 void BrowserCommandController::TabRestoreServiceDestroyed( 829 TabRestoreService* service) { 830 service->RemoveObserver(this); 831 } 832 833 //////////////////////////////////////////////////////////////////////////////// 834 // BrowserCommandController, private: 835 836 class BrowserCommandController::InterstitialObserver 837 : public content::WebContentsObserver { 838 public: 839 InterstitialObserver(BrowserCommandController* controller, 840 content::WebContents* web_contents) 841 : WebContentsObserver(web_contents), 842 controller_(controller) { 843 } 844 845 using content::WebContentsObserver::web_contents; 846 847 virtual void DidAttachInterstitialPage() OVERRIDE { 848 controller_->UpdateCommandsForTabState(); 849 } 850 851 virtual void DidDetachInterstitialPage() OVERRIDE { 852 controller_->UpdateCommandsForTabState(); 853 } 854 855 private: 856 BrowserCommandController* controller_; 857 858 DISALLOW_COPY_AND_ASSIGN(InterstitialObserver); 859 }; 860 861 bool BrowserCommandController::IsShowingMainUI() { 862 bool should_hide_ui = window() && window()->ShouldHideUIForFullscreen(); 863 return browser_->is_type_tabbed() && !should_hide_ui; 864 } 865 866 void BrowserCommandController::InitCommandState() { 867 // All browser commands whose state isn't set automagically some other way 868 // (like Back & Forward with initial page load) must have their state 869 // initialized here, otherwise they will be forever disabled. 870 871 // Navigation commands 872 command_updater_.UpdateCommandEnabled(IDC_RELOAD, true); 873 command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE, true); 874 command_updater_.UpdateCommandEnabled(IDC_RELOAD_CLEARING_CACHE, true); 875 876 // Window management commands 877 command_updater_.UpdateCommandEnabled(IDC_CLOSE_WINDOW, true); 878 command_updater_.UpdateCommandEnabled(IDC_NEW_TAB, true); 879 command_updater_.UpdateCommandEnabled(IDC_CLOSE_TAB, true); 880 command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB, true); 881 command_updater_.UpdateCommandEnabled(IDC_RESTORE_TAB, false); 882 #if defined(OS_WIN) && defined(USE_ASH) 883 if (browser_->host_desktop_type() != chrome::HOST_DESKTOP_TYPE_ASH) 884 command_updater_.UpdateCommandEnabled(IDC_EXIT, true); 885 #else 886 command_updater_.UpdateCommandEnabled(IDC_EXIT, true); 887 #endif 888 command_updater_.UpdateCommandEnabled(IDC_DEBUG_FRAME_TOGGLE, true); 889 #if defined(OS_WIN) && defined(USE_ASH) && !defined(NDEBUG) 890 if (base::win::GetVersion() < base::win::VERSION_WIN8 && 891 chrome::HOST_DESKTOP_TYPE_NATIVE != chrome::HOST_DESKTOP_TYPE_ASH) 892 command_updater_.UpdateCommandEnabled(IDC_TOGGLE_ASH_DESKTOP, true); 893 #endif 894 #if defined(USE_ASH) 895 command_updater_.UpdateCommandEnabled(IDC_MINIMIZE_WINDOW, true); 896 #endif 897 #if defined(OS_CHROMEOS) 898 command_updater_.UpdateCommandEnabled(IDC_VISIT_DESKTOP_OF_LRU_USER_2, true); 899 command_updater_.UpdateCommandEnabled(IDC_VISIT_DESKTOP_OF_LRU_USER_3, true); 900 #endif 901 902 // Page-related commands 903 command_updater_.UpdateCommandEnabled(IDC_EMAIL_PAGE_LOCATION, true); 904 command_updater_.UpdateCommandEnabled(IDC_ENCODING_AUTO_DETECT, true); 905 command_updater_.UpdateCommandEnabled(IDC_ENCODING_UTF8, true); 906 command_updater_.UpdateCommandEnabled(IDC_ENCODING_UTF16LE, true); 907 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88591, true); 908 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1252, true); 909 command_updater_.UpdateCommandEnabled(IDC_ENCODING_GBK, true); 910 command_updater_.UpdateCommandEnabled(IDC_ENCODING_GB18030, true); 911 command_updater_.UpdateCommandEnabled(IDC_ENCODING_BIG5HKSCS, true); 912 command_updater_.UpdateCommandEnabled(IDC_ENCODING_BIG5, true); 913 command_updater_.UpdateCommandEnabled(IDC_ENCODING_THAI, true); 914 command_updater_.UpdateCommandEnabled(IDC_ENCODING_KOREAN, true); 915 command_updater_.UpdateCommandEnabled(IDC_ENCODING_SHIFTJIS, true); 916 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO2022JP, true); 917 command_updater_.UpdateCommandEnabled(IDC_ENCODING_EUCJP, true); 918 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO885915, true); 919 command_updater_.UpdateCommandEnabled(IDC_ENCODING_MACINTOSH, true); 920 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88592, true); 921 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1250, true); 922 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88595, true); 923 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1251, true); 924 command_updater_.UpdateCommandEnabled(IDC_ENCODING_KOI8R, true); 925 command_updater_.UpdateCommandEnabled(IDC_ENCODING_KOI8U, true); 926 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88597, true); 927 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1253, true); 928 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88594, true); 929 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO885913, true); 930 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1257, true); 931 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88593, true); 932 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO885910, true); 933 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO885914, true); 934 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO885916, true); 935 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1254, true); 936 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88596, true); 937 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1256, true); 938 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88598, true); 939 command_updater_.UpdateCommandEnabled(IDC_ENCODING_ISO88598I, true); 940 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1255, true); 941 command_updater_.UpdateCommandEnabled(IDC_ENCODING_WINDOWS1258, true); 942 943 // Zoom 944 command_updater_.UpdateCommandEnabled(IDC_ZOOM_MENU, true); 945 command_updater_.UpdateCommandEnabled(IDC_ZOOM_PLUS, true); 946 command_updater_.UpdateCommandEnabled(IDC_ZOOM_NORMAL, true); 947 command_updater_.UpdateCommandEnabled(IDC_ZOOM_MINUS, true); 948 949 // Show various bits of UI 950 UpdateOpenFileState(&command_updater_); 951 command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS, false); 952 UpdateCommandsForDevTools(); 953 command_updater_.UpdateCommandEnabled(IDC_TASK_MANAGER, CanOpenTaskManager()); 954 command_updater_.UpdateCommandEnabled(IDC_SHOW_HISTORY, 955 !profile()->IsGuestSession()); 956 command_updater_.UpdateCommandEnabled(IDC_SHOW_DOWNLOADS, true); 957 command_updater_.UpdateCommandEnabled(IDC_HELP_PAGE_VIA_KEYBOARD, true); 958 command_updater_.UpdateCommandEnabled(IDC_HELP_PAGE_VIA_MENU, true); 959 command_updater_.UpdateCommandEnabled(IDC_BOOKMARKS_MENU, 960 !profile()->IsGuestSession()); 961 command_updater_.UpdateCommandEnabled(IDC_RECENT_TABS_MENU, 962 !profile()->IsGuestSession() && 963 !profile()->IsOffTheRecord()); 964 965 UpdateShowSyncState(true); 966 967 // Initialize other commands based on the window type. 968 bool normal_window = browser_->is_type_tabbed(); 969 970 // Navigation commands 971 command_updater_.UpdateCommandEnabled(IDC_HOME, normal_window); 972 973 // Window management commands 974 command_updater_.UpdateCommandEnabled(IDC_SELECT_NEXT_TAB, normal_window); 975 command_updater_.UpdateCommandEnabled(IDC_SELECT_PREVIOUS_TAB, 976 normal_window); 977 command_updater_.UpdateCommandEnabled(IDC_MOVE_TAB_NEXT, normal_window); 978 command_updater_.UpdateCommandEnabled(IDC_MOVE_TAB_PREVIOUS, normal_window); 979 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_0, normal_window); 980 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_1, normal_window); 981 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_2, normal_window); 982 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_3, normal_window); 983 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_4, normal_window); 984 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_5, normal_window); 985 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_6, normal_window); 986 command_updater_.UpdateCommandEnabled(IDC_SELECT_TAB_7, normal_window); 987 command_updater_.UpdateCommandEnabled(IDC_SELECT_LAST_TAB, normal_window); 988 #if defined(OS_WIN) 989 #if !defined(USE_AURA) 990 const bool metro_mode = base::win::IsMetroProcess(); 991 #else 992 const bool metro_mode = 993 browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH ? 994 true : false; 995 #endif 996 command_updater_.UpdateCommandEnabled(IDC_METRO_SNAP_ENABLE, metro_mode); 997 command_updater_.UpdateCommandEnabled(IDC_METRO_SNAP_DISABLE, metro_mode); 998 int restart_mode = metro_mode ? 999 IDC_WIN8_DESKTOP_RESTART : IDC_WIN8_METRO_RESTART; 1000 command_updater_.UpdateCommandEnabled(restart_mode, normal_window); 1001 #endif 1002 command_updater_.UpdateCommandEnabled(IDC_TABPOSE, normal_window); 1003 1004 // Show various bits of UI 1005 command_updater_.UpdateCommandEnabled(IDC_CLEAR_BROWSING_DATA, normal_window); 1006 1007 // The upgrade entry and the view incompatibility entry should always be 1008 // enabled. Whether they are visible is a separate matter determined on menu 1009 // show. 1010 command_updater_.UpdateCommandEnabled(IDC_UPGRADE_DIALOG, true); 1011 command_updater_.UpdateCommandEnabled(IDC_VIEW_INCOMPATIBILITIES, true); 1012 1013 // Toggle speech input 1014 command_updater_.UpdateCommandEnabled(IDC_TOGGLE_SPEECH_INPUT, true); 1015 1016 // Initialize other commands whose state changes based on fullscreen mode. 1017 UpdateCommandsForFullscreenMode(); 1018 1019 UpdateCommandsForContentRestrictionState(); 1020 1021 UpdateCommandsForBookmarkEditing(); 1022 1023 UpdateCommandsForIncognitoAvailability(); 1024 } 1025 1026 // static 1027 void BrowserCommandController::UpdateSharedCommandsForIncognitoAvailability( 1028 CommandUpdater* command_updater, 1029 Profile* profile) { 1030 IncognitoModePrefs::Availability incognito_availability = 1031 IncognitoModePrefs::GetAvailability(profile->GetPrefs()); 1032 command_updater->UpdateCommandEnabled( 1033 IDC_NEW_WINDOW, 1034 incognito_availability != IncognitoModePrefs::FORCED); 1035 command_updater->UpdateCommandEnabled( 1036 IDC_NEW_INCOGNITO_WINDOW, 1037 incognito_availability != IncognitoModePrefs::DISABLED); 1038 1039 // Bookmark manager and settings page/subpages are forced to open in normal 1040 // mode. For this reason we disable these commands when incognito is forced. 1041 const bool command_enabled = 1042 incognito_availability != IncognitoModePrefs::FORCED; 1043 command_updater->UpdateCommandEnabled( 1044 IDC_SHOW_BOOKMARK_MANAGER, 1045 browser_defaults::bookmarks_enabled && command_enabled); 1046 ExtensionService* extension_service = profile->GetExtensionService(); 1047 bool enable_extensions = 1048 extension_service && extension_service->extensions_enabled(); 1049 command_updater->UpdateCommandEnabled(IDC_MANAGE_EXTENSIONS, 1050 enable_extensions && command_enabled); 1051 1052 command_updater->UpdateCommandEnabled(IDC_IMPORT_SETTINGS, command_enabled); 1053 command_updater->UpdateCommandEnabled(IDC_OPTIONS, command_enabled); 1054 command_updater->UpdateCommandEnabled(IDC_SHOW_SIGNIN, command_enabled); 1055 } 1056 1057 void BrowserCommandController::UpdateCommandsForIncognitoAvailability() { 1058 UpdateSharedCommandsForIncognitoAvailability(&command_updater_, profile()); 1059 1060 if (!IsShowingMainUI()) { 1061 command_updater_.UpdateCommandEnabled(IDC_IMPORT_SETTINGS, false); 1062 command_updater_.UpdateCommandEnabled(IDC_OPTIONS, false); 1063 } 1064 } 1065 1066 void BrowserCommandController::UpdateCommandsForTabState() { 1067 WebContents* current_web_contents = 1068 browser_->tab_strip_model()->GetActiveWebContents(); 1069 if (!current_web_contents) // May be NULL during tab restore. 1070 return; 1071 1072 // Navigation commands 1073 command_updater_.UpdateCommandEnabled(IDC_BACK, CanGoBack(browser_)); 1074 command_updater_.UpdateCommandEnabled(IDC_FORWARD, CanGoForward(browser_)); 1075 command_updater_.UpdateCommandEnabled(IDC_RELOAD, CanReload(browser_)); 1076 command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE, 1077 CanReload(browser_)); 1078 command_updater_.UpdateCommandEnabled(IDC_RELOAD_CLEARING_CACHE, 1079 CanReload(browser_)); 1080 1081 // Window management commands 1082 command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB, 1083 !browser_->is_app() && CanDuplicateTab(browser_)); 1084 1085 // Page-related commands 1086 window()->SetStarredState( 1087 BookmarkTabHelper::FromWebContents(current_web_contents)->is_starred()); 1088 window()->ZoomChangedForActiveTab(false); 1089 command_updater_.UpdateCommandEnabled(IDC_VIEW_SOURCE, 1090 CanViewSource(browser_)); 1091 command_updater_.UpdateCommandEnabled(IDC_EMAIL_PAGE_LOCATION, 1092 CanEmailPageLocation(browser_)); 1093 if (browser_->is_devtools()) 1094 command_updater_.UpdateCommandEnabled(IDC_OPEN_FILE, false); 1095 1096 // Changing the encoding is not possible on Chrome-internal webpages. 1097 NavigationController& nc = current_web_contents->GetController(); 1098 bool is_chrome_internal = HasInternalURL(nc.GetActiveEntry()) || 1099 current_web_contents->ShowingInterstitialPage(); 1100 command_updater_.UpdateCommandEnabled(IDC_ENCODING_MENU, 1101 !is_chrome_internal && current_web_contents->IsSavable()); 1102 1103 // Show various bits of UI 1104 // TODO(pinkerton): Disable app-mode in the model until we implement it 1105 // on the Mac. Be sure to remove both ifdefs. http://crbug.com/13148 1106 #if !defined(OS_MACOSX) 1107 command_updater_.UpdateCommandEnabled( 1108 IDC_CREATE_SHORTCUTS, 1109 CanCreateApplicationShortcuts(browser_)); 1110 command_updater_.UpdateCommandEnabled( 1111 IDC_CREATE_HOSTED_APP, 1112 CanCreateApplicationShortcuts(browser_)); 1113 #endif 1114 1115 command_updater_.UpdateCommandEnabled( 1116 IDC_TOGGLE_REQUEST_TABLET_SITE, 1117 CanRequestTabletSite(current_web_contents)); 1118 1119 UpdateCommandsForContentRestrictionState(); 1120 UpdateCommandsForBookmarkEditing(); 1121 UpdateCommandsForFind(); 1122 } 1123 1124 void BrowserCommandController::UpdateCommandsForContentRestrictionState() { 1125 int restrictions = GetContentRestrictions(browser_); 1126 1127 command_updater_.UpdateCommandEnabled( 1128 IDC_COPY, !(restrictions & CONTENT_RESTRICTION_COPY)); 1129 command_updater_.UpdateCommandEnabled( 1130 IDC_CUT, !(restrictions & CONTENT_RESTRICTION_CUT)); 1131 command_updater_.UpdateCommandEnabled( 1132 IDC_PASTE, !(restrictions & CONTENT_RESTRICTION_PASTE)); 1133 UpdateSaveAsState(); 1134 UpdatePrintingState(); 1135 } 1136 1137 void BrowserCommandController::UpdateCommandsForDevTools() { 1138 bool dev_tools_enabled = 1139 !profile()->GetPrefs()->GetBoolean(prefs::kDevToolsDisabled); 1140 command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS, 1141 dev_tools_enabled); 1142 command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_CONSOLE, 1143 dev_tools_enabled); 1144 command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_DEVICES, 1145 dev_tools_enabled); 1146 command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_INSPECT, 1147 dev_tools_enabled); 1148 command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_TOGGLE, 1149 dev_tools_enabled); 1150 } 1151 1152 void BrowserCommandController::UpdateCommandsForBookmarkEditing() { 1153 command_updater_.UpdateCommandEnabled(IDC_BOOKMARK_PAGE, 1154 CanBookmarkCurrentPage(browser_)); 1155 command_updater_.UpdateCommandEnabled(IDC_BOOKMARK_ALL_TABS, 1156 CanBookmarkAllTabs(browser_)); 1157 command_updater_.UpdateCommandEnabled(IDC_PIN_TO_START_SCREEN, 1158 true); 1159 } 1160 1161 void BrowserCommandController::UpdateCommandsForBookmarkBar() { 1162 command_updater_.UpdateCommandEnabled(IDC_SHOW_BOOKMARK_BAR, 1163 browser_defaults::bookmarks_enabled && 1164 !profile()->GetPrefs()->IsManagedPreference(prefs::kShowBookmarkBar) && 1165 IsShowingMainUI()); 1166 } 1167 1168 void BrowserCommandController::UpdateCommandsForFileSelectionDialogs() { 1169 UpdateSaveAsState(); 1170 UpdateOpenFileState(&command_updater_); 1171 } 1172 1173 void BrowserCommandController::UpdateCommandsForFullscreenMode() { 1174 WindowState window_state = WINDOW_STATE_NOT_FULLSCREEN; 1175 if (window() && window()->IsFullscreen()) { 1176 window_state = WINDOW_STATE_FULLSCREEN; 1177 #if defined(OS_WIN) 1178 if (window()->IsInMetroSnapMode()) 1179 window_state = WINDOW_STATE_METRO_SNAP; 1180 #endif 1181 } 1182 bool show_main_ui = IsShowingMainUI(); 1183 bool main_not_fullscreen = 1184 show_main_ui && window_state == WINDOW_STATE_NOT_FULLSCREEN; 1185 1186 // Navigation commands 1187 command_updater_.UpdateCommandEnabled(IDC_OPEN_CURRENT_URL, show_main_ui); 1188 1189 // Window management commands 1190 command_updater_.UpdateCommandEnabled( 1191 IDC_SHOW_AS_TAB, 1192 !browser_->is_type_tabbed() && 1193 window_state == WINDOW_STATE_NOT_FULLSCREEN); 1194 1195 // Focus various bits of UI 1196 command_updater_.UpdateCommandEnabled(IDC_FOCUS_TOOLBAR, show_main_ui); 1197 command_updater_.UpdateCommandEnabled(IDC_FOCUS_LOCATION, show_main_ui); 1198 command_updater_.UpdateCommandEnabled(IDC_FOCUS_SEARCH, show_main_ui); 1199 command_updater_.UpdateCommandEnabled( 1200 IDC_FOCUS_MENU_BAR, main_not_fullscreen); 1201 command_updater_.UpdateCommandEnabled( 1202 IDC_FOCUS_NEXT_PANE, main_not_fullscreen); 1203 command_updater_.UpdateCommandEnabled( 1204 IDC_FOCUS_PREVIOUS_PANE, main_not_fullscreen); 1205 command_updater_.UpdateCommandEnabled( 1206 IDC_FOCUS_BOOKMARKS, main_not_fullscreen); 1207 command_updater_.UpdateCommandEnabled( 1208 IDC_FOCUS_INFOBARS, main_not_fullscreen); 1209 1210 // Show various bits of UI 1211 command_updater_.UpdateCommandEnabled(IDC_DEVELOPER_MENU, show_main_ui); 1212 #if defined(GOOGLE_CHROME_BUILD) 1213 command_updater_.UpdateCommandEnabled(IDC_FEEDBACK, show_main_ui); 1214 #endif 1215 UpdateShowSyncState(show_main_ui); 1216 1217 // Settings page/subpages are forced to open in normal mode. We disable these 1218 // commands when incognito is forced. 1219 const bool options_enabled = show_main_ui && 1220 IncognitoModePrefs::GetAvailability( 1221 profile()->GetPrefs()) != IncognitoModePrefs::FORCED; 1222 command_updater_.UpdateCommandEnabled(IDC_OPTIONS, options_enabled); 1223 command_updater_.UpdateCommandEnabled(IDC_IMPORT_SETTINGS, options_enabled); 1224 1225 command_updater_.UpdateCommandEnabled(IDC_EDIT_SEARCH_ENGINES, show_main_ui); 1226 command_updater_.UpdateCommandEnabled(IDC_VIEW_PASSWORDS, show_main_ui); 1227 command_updater_.UpdateCommandEnabled(IDC_ABOUT, show_main_ui); 1228 command_updater_.UpdateCommandEnabled(IDC_SHOW_APP_MENU, show_main_ui); 1229 #if defined (ENABLE_PROFILING) && !defined(NO_TCMALLOC) 1230 command_updater_.UpdateCommandEnabled(IDC_PROFILING_ENABLED, show_main_ui); 1231 #endif 1232 1233 // Disable explicit fullscreen toggling when in metro snap mode. 1234 bool fullscreen_enabled = window_state != WINDOW_STATE_METRO_SNAP; 1235 #if defined(OS_MACOSX) 1236 // The Mac implementation doesn't support switching to fullscreen while 1237 // a tab modal dialog is displayed. 1238 int tab_index = chrome::IndexOfFirstBlockedTab(browser_->tab_strip_model()); 1239 bool has_blocked_tab = tab_index != browser_->tab_strip_model()->count(); 1240 fullscreen_enabled &= !has_blocked_tab; 1241 #else 1242 if (window_state == WINDOW_STATE_NOT_FULLSCREEN && 1243 !profile()->GetPrefs()->GetBoolean(prefs::kFullscreenAllowed)) { 1244 // Disable toggling into fullscreen mode if disallowed by pref. 1245 fullscreen_enabled = false; 1246 } 1247 #endif 1248 1249 command_updater_.UpdateCommandEnabled(IDC_FULLSCREEN, fullscreen_enabled); 1250 command_updater_.UpdateCommandEnabled(IDC_PRESENTATION_MODE, 1251 fullscreen_enabled); 1252 1253 UpdateCommandsForBookmarkBar(); 1254 UpdateCommandsForMultipleProfiles(); 1255 } 1256 1257 void BrowserCommandController::UpdateCommandsForMultipleProfiles() { 1258 bool is_regular_or_guest_session = 1259 profile()->IsGuestSession() || !profile()->IsOffTheRecord(); 1260 bool enable = IsShowingMainUI() && 1261 is_regular_or_guest_session && 1262 profile_manager_ && 1263 AvatarMenu::ShouldShowAvatarMenu(); 1264 command_updater_.UpdateCommandEnabled(IDC_SHOW_AVATAR_MENU, 1265 enable); 1266 } 1267 1268 void BrowserCommandController::UpdatePrintingState() { 1269 bool print_enabled = CanPrint(browser_); 1270 command_updater_.UpdateCommandEnabled(IDC_PRINT, print_enabled); 1271 command_updater_.UpdateCommandEnabled(IDC_ADVANCED_PRINT, 1272 CanAdvancedPrint(browser_)); 1273 command_updater_.UpdateCommandEnabled(IDC_PRINT_TO_DESTINATION, 1274 print_enabled); 1275 #if defined(OS_WIN) 1276 HMODULE metro_module = base::win::GetMetroModule(); 1277 if (metro_module != NULL) { 1278 typedef void (*MetroEnablePrinting)(BOOL); 1279 MetroEnablePrinting metro_enable_printing = 1280 reinterpret_cast<MetroEnablePrinting>( 1281 ::GetProcAddress(metro_module, "MetroEnablePrinting")); 1282 if (metro_enable_printing) 1283 metro_enable_printing(print_enabled); 1284 } 1285 #endif 1286 } 1287 1288 void BrowserCommandController::UpdateSaveAsState() { 1289 command_updater_.UpdateCommandEnabled(IDC_SAVE_PAGE, CanSavePage(browser_)); 1290 } 1291 1292 void BrowserCommandController::UpdateShowSyncState(bool show_main_ui) { 1293 command_updater_.UpdateCommandEnabled( 1294 IDC_SHOW_SYNC_SETUP, show_main_ui && pref_signin_allowed_.GetValue()); 1295 } 1296 1297 // static 1298 void BrowserCommandController::UpdateOpenFileState( 1299 CommandUpdater* command_updater) { 1300 bool enabled = true; 1301 PrefService* local_state = g_browser_process->local_state(); 1302 if (local_state) 1303 enabled = local_state->GetBoolean(prefs::kAllowFileSelectionDialogs); 1304 1305 command_updater->UpdateCommandEnabled(IDC_OPEN_FILE, enabled); 1306 } 1307 1308 void BrowserCommandController::UpdateReloadStopState(bool is_loading, 1309 bool force) { 1310 window()->UpdateReloadStopState(is_loading, force); 1311 command_updater_.UpdateCommandEnabled(IDC_STOP, is_loading); 1312 } 1313 1314 void BrowserCommandController::UpdateCommandsForFind() { 1315 TabStripModel* model = browser_->tab_strip_model(); 1316 bool enabled = !model->IsTabBlocked(model->active_index()) && 1317 !browser_->is_devtools(); 1318 1319 command_updater_.UpdateCommandEnabled(IDC_FIND, enabled); 1320 command_updater_.UpdateCommandEnabled(IDC_FIND_NEXT, enabled); 1321 command_updater_.UpdateCommandEnabled(IDC_FIND_PREVIOUS, enabled); 1322 } 1323 1324 void BrowserCommandController::AddInterstitialObservers(WebContents* contents) { 1325 interstitial_observers_.push_back(new InterstitialObserver(this, contents)); 1326 } 1327 1328 void BrowserCommandController::RemoveInterstitialObservers( 1329 WebContents* contents) { 1330 for (size_t i = 0; i < interstitial_observers_.size(); i++) { 1331 if (interstitial_observers_[i]->web_contents() != contents) 1332 continue; 1333 1334 delete interstitial_observers_[i]; 1335 interstitial_observers_.erase(interstitial_observers_.begin() + i); 1336 return; 1337 } 1338 } 1339 1340 BrowserWindow* BrowserCommandController::window() { 1341 return browser_->window(); 1342 } 1343 1344 Profile* BrowserCommandController::profile() { 1345 return browser_->profile(); 1346 } 1347 1348 } // namespace chrome 1349
