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

chrome/browser/ui/browser_commands.cc

 // 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.
 
 #include "chrome/browser/ui/browser_commands.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/bookmarks/bookmark_editor.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_page_zoom.h"
 #include "chrome/browser/debugger/devtools_window.h"
+#include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
+#include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/feedback_ui.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
+#include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/url_util.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/common/content_restriction.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/escape.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 66 matching lines @@
   WebContents* web_contents = GetOrCloneTabForDisposition(browser, disposition);
   web_contents->UserGestureDone();
   if (!web_contents->FocusLocationBarByDefault())
     web_contents->Focus();
   if (ignore_cache)
     web_contents->GetController().ReloadIgnoringCache(true);
   else
     web_contents->GetController().Reload(true);
 }
 
+bool HasConstrainedWindow(const Browser* browser) {
+  TabContents* tab_contents = browser->GetActiveTabContents();
+  return tab_contents && tab_contents->constrained_window_tab_helper()->
+      constrained_window_count();
+}
+
+bool PrintPreviewShowing(const Browser* browser) {
+  TabContents* contents = browser->GetActiveTabContents();
+  printing::PrintPreviewTabController* controller =
+      printing::PrintPreviewTabController::GetInstance();
+  return controller && (controller->GetPrintPreviewForTab(contents) ||
+                        controller->is_creating_print_preview_tab());
+}
+
 }  // namespace
 
+bool IsCommandEnabled(Browser* browser, int command) {
+  return browser->command_controller()->command_updater()->IsCommandEnabled(
+      command);
+}
+
+bool SupportsCommand(Browser* browser, int command) {
+  return browser->command_controller()->command_updater()->SupportsCommand(
+      command);
+}
+
+bool ExecuteCommand(Browser* browser, int command) {
+  return browser->command_controller()->command_updater()->ExecuteCommand(
+      command);
+}
+
+bool ExecuteCommandWithDisposition(Browser* browser,
+                                   int command,
+                                   WindowOpenDisposition disposition) {
+  return browser->command_controller()->command_updater()->
+      ExecuteCommandWithDisposition(command, disposition);
+}
+
+void UpdateCommandEnabled(Browser* browser, int command, bool enabled) {
+  browser->command_controller()->command_updater()->UpdateCommandEnabled(
+      command, enabled);
+}
+
+void AddCommandObserver(Browser* browser,
+                        int command,
+                        CommandObserver* observer) {
+  browser->command_controller()->command_updater()->AddCommandObserver(
+      command, observer);
+}
+
+void RemoveCommandObserver(Browser* browser,
+                           int command,
+                           CommandObserver* observer) {
+  browser->command_controller()->command_updater()->RemoveCommandObserver(
+      command, observer);
+}
+
+int GetContentRestrictions(const Browser* browser) {
+  int content_restrictions = 0;
+  WebContents* current_tab = browser->GetActiveWebContents();
+  if (current_tab) {
+    content_restrictions = current_tab->GetContentRestrictions();
+    NavigationEntry* active_entry =
+        current_tab->GetController().GetActiveEntry();
+    // See comment in UpdateCommandsForTabState about why we call url().
+    if (!download_util::IsSavableURL(
+            active_entry ? active_entry->GetURL() : GURL())
+        || current_tab->ShowingInterstitialPage())

[sky, 2012/06/27 03:09:28]

nit: || on previous line.

+      content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
+    if (current_tab->ShowingInterstitialPage())
+      content_restrictions |= content::CONTENT_RESTRICTION_PRINT;
+  }
+  return content_restrictions;
+}
+
 void NewEmptyWindow(Profile* profile) {
   bool incognito = profile->IsOffTheRecord();
   PrefService* prefs = profile->GetPrefs();
   if (incognito) {
     if (IncognitoModePrefs::GetAvailability(prefs) ==
           IncognitoModePrefs::DISABLED) {
       incognito = false;
     }
   } else {
     if (browser_defaults::kAlwaysOpenIncognitoWindow &&
@@ skipping 30 matching lines @@
     service->RestoreMostRecentEntry(NULL);
 }
 
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser* browser = browser::FindOrCreateTabbedBrowser(
       profile->GetOffTheRecordProfile());
   browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_LINK);
   browser->window()->Show();
 }
 
-bool CanGoBack(Browser* browser) {
+bool CanGoBack(const Browser* browser) {
   return browser->GetActiveWebContents()->GetController().CanGoBack();
 }
 
 void GoBack(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Back"));
 
   TabContents* current_tab = browser->GetActiveTabContents();
   if (CanGoBack(browser)) {
     WebContents* new_tab = GetOrCloneTabForDisposition(browser, disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->web_contents()->ShowingInterstitialPage() &&
         (new_tab != current_tab->web_contents()))
       return;
     new_tab->GetController().GoBack();
   }
 }
 
-bool CanGoForward(Browser* browser) {
+bool CanGoForward(const Browser* browser) {
   return browser->GetActiveWebContents()->GetController().CanGoForward();
 }
 
 void GoForward(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward(browser)) {
     GetOrCloneTabForDisposition(browser, disposition)->
         GetController().GoForward();
   }
 }
@@ skipping 12 matching lines @@
 void Reload(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Reload"));
   ReloadInternal(browser, disposition, false);
 }
 
 void ReloadIgnoringCache(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("ReloadIgnoringCache"));
   ReloadInternal(browser, disposition, true);
 }
 
+bool CanReload(const Browser* browser) {
+  return !browser->is_devtools();
+}
+
 void Home(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Home"));
   browser->OpenURL(OpenURLParams(
       browser->profile()->GetHomePage(), Referrer(), disposition,
       content::PageTransitionFromInt(
           content::PAGE_TRANSITION_AUTO_BOOKMARK |
           content::PAGE_TRANSITION_HOME_PAGE),
       false));
 }
 
@@ skipping 68 matching lines @@
     // See http://crbug.com/6380.
     b->GetActiveWebContents()->GetView()->RestoreFocus();
   }
 }
 
 void CloseTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   browser->tab_strip_model()->CloseSelectedTabs();
 }
 
+void RestoreTab(Browser* browser) {
+  content::RecordAction(UserMetricsAction("RestoreTab"));
+  TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(browser->profile());
+  if (service)
+    service->RestoreMostRecentEntry(browser->tab_restore_service_delegate());
+}
+
+bool CanRestoreTab(const Browser* browser) {
+  TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(browser->profile());
+  return service ? !service->entries().empty() : false;

[sky, 2012/06/27 03:09:28]

nit: return service && !service->entries().empty();

+}
+
 void SelectNextTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("SelectNextTab"));
   browser->tab_strip_model()->SelectNextTab();
 }
 
 void SelectPreviousTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("SelectPrevTab"));
   browser->tab_strip_model()->SelectPreviousTab();
 }
 
@@ skipping 31 matching lines @@
 void SelectLastTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("SelectLastTab"));
   browser->tab_strip_model()->SelectLastTab();
 }
 
 void DuplicateTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("Duplicate"));
   browser->DuplicateContentsAt(browser->active_index());
 }
 
+bool CanDuplicateTab(const Browser* browser) {
+  WebContents* contents = browser->GetActiveWebContents();
+  return contents && contents->GetController().GetLastCommittedEntry();
+}
+
 void WriteCurrentURLToClipboard(Browser* browser) {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
 
   WebContents* contents = browser->GetActiveWebContents();
   if (!browser->toolbar_model()->ShouldDisplayURL())
     return;
 
   chrome_common_net::WriteURLToClipboard(
@@ skipping 36 matching lines @@
   bookmark_utils::AddIfNotBookmarked(model, url, title);
   // Make sure the model actually added a bookmark before showing the star. A
   // bookmark isn't created if the url is invalid.
   if (browser->window()->IsActive() && model->IsBookmarked(url)) {
     // Only show the bubble if the window is active, otherwise we may get into
     // weird situations where the bubble is deleted as soon as it is shown.
     browser->window()->ShowBookmarkBubble(url, was_bookmarked);
   }
 }
 
+bool CanBookmarkCurrentPage(const Browser* browser) {
+  BookmarkModel* model = browser->profile()->GetBookmarkModel();
+  return browser_defaults::bookmarks_enabled &&
+      browser->profile()->GetPrefs()->GetBoolean(
+          prefs::kEditBookmarksEnabled) &&
+      model && model->IsLoaded() && browser->is_type_tabbed();
+}
+
+void BookmarkAllTabs(Browser* browser) {
+  BookmarkEditor::ShowBookmarkAllTabsDialog(browser);
+}
+
+bool CanBookmarkAllTabs(const Browser* browser) {
+  return browser->tab_count() > 1 && CanBookmarkCurrentPage(browser);
+}
+
 #if !defined(OS_WIN)
 void PinCurrentPageToStartScreen(Browser* browser) {
 }
 #endif
 
 void SavePage(Browser* browser) {
   content::RecordAction(UserMetricsAction("SavePage"));
   WebContents* current_tab = browser->GetActiveWebContents();
   if (current_tab && current_tab->GetContentsMimeType() == "application/pdf")
     content::RecordAction(UserMetricsAction("PDF.SavePage"));
   current_tab->OnSavePage();
 }
 
+bool CanSavePage(const Browser* browser) {
+  if (!g_browser_process->local_state()->GetBoolean(
+      prefs::kAllowFileSelectionDialogs)) {
+    return false;
+  }
+  return !browser->is_devtools() &&
+      !(GetContentRestrictions(browser) & content::CONTENT_RESTRICTION_SAVE);
+}
+
 void ShowFindBar(Browser* browser) {
   browser->GetFindBarController()->Show();
 }
 
 void ShowPageInfo(Browser* browser,
                   content::WebContents* web_contents,
                   const GURL& url,
                   const SSLStatus& ssl,
                   bool show_history) {
   Profile* profile = Profile::FromBrowserContext(
@@ skipping 18 matching lines @@
 
 void Print(Browser* browser) {
   if (g_browser_process->local_state()->GetBoolean(
           prefs::kPrintPreviewDisabled)) {
     browser->GetActiveTabContents()->print_view_manager()->PrintNow();
   } else {
     browser->GetActiveTabContents()->print_view_manager()->PrintPreviewNow();
   }
 }
 
+bool CanPrint(const Browser* browser) {
+  if (!g_browser_process->local_state()->GetBoolean(prefs::kPrintingEnabled))
+    return false;
+
+  // Do not print when a constrained window is showing. It's confusing.
+  return !(HasConstrainedWindow(browser) ||
+      GetContentRestrictions(browser) & content::CONTENT_RESTRICTION_PRINT);
+}
+
 void AdvancedPrint(Browser* browser) {
   browser->GetActiveTabContents()->print_view_manager()->AdvancedPrintNow();
 }
 
+bool CanAdvancedPrint(const Browser* browser) {
+  if (!g_browser_process->local_state()->GetBoolean(prefs::kPrintingEnabled))
+    return false;
+
+  // It is always possible to advanced print when print preview is visible.
+  return PrintPreviewShowing(browser) || CanPrint(browser);
+}
+
 void EmailPageLocation(Browser* browser) {
   content::RecordAction(UserMetricsAction("EmailPageLocation"));
   WebContents* wc = browser->GetActiveWebContents();
   DCHECK(wc);
 
   std::string title = net::EscapeQueryParamValue(
       UTF16ToUTF8(wc->GetTitle()), false);
   std::string page_url = net::EscapeQueryParamValue(wc->GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(GURL(mailto));
 }
 
+bool CanEmailPageLocation(const Browser* browser) {
+  return browser->toolbar_model()->ShouldDisplayURL() &&
+      browser->GetActiveWebContents()->GetURL().is_valid();
+}
+
 void Cut(Browser* browser) {
   content::RecordAction(UserMetricsAction("Cut"));
   browser->window()->Cut();
 }
 
 void Copy(Browser* browser) {
   content::RecordAction(UserMetricsAction("Copy"));
   browser->window()->Copy();
 }
 
@@ skipping 246 matching lines @@
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(browser->profile());
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 void ViewSelectedSource(Browser* browser) {
   ViewSource(browser, browser->GetActiveTabContents());
 }
 
+bool CanViewSource(const Browser* browser) {
+  return browser->GetActiveWebContents()->GetController().CanViewSource();
+}
+
+bool CanCreateApplicationShortcuts(const Browser* browser) {
+  return web_app::IsValidUrl(browser->GetActiveWebContents()->GetURL());
+}
+
 }  // namespace chrome