Add policy for fullscreen mode; disallow fullscreen in public sessions

chrome/browser/ui/browser_command_controller.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_command_controller.h"
 
 #include "base/prefs/pref_service.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 42 matching lines @@
 #if defined(USE_ASH)
 #include "chrome/browser/ui/ash/ash_util.h"
 #endif
 
 using content::NavigationEntry;
 using content::NavigationController;
 using content::WebContents;
 
 namespace {
 
+enum FullScreenMode {
+  // Not in fullscreen mode.
+  FULLSCREEN_DISABLED,

[sky, 2013/08/22 21:33:55]

Am I the only one that finds this name totally misleading?

[scheib, 2013/08/22 23:57:26]

WINDOW_STATE_NORMAL,
WINDOW_STATE_FULLSCREEN,
WINDOW_STATE_METRO_SNAP,

[sky, 2013/08/23 00:00:37]

Much better, but NORMAL is a bit ambiguous here, I would go with
WINDOW_STATE_NOT_FULLSCREEN.

I wasn't clear on why I didn't like the current name. Currently
FULLSCREEN_DISABLED means 'not in fullscreen', which is very confusing.

[bartfab (slow), 2013/08/23 11:54:21]

Done.

+
+  // Fullscreen mode, occupying the whole screen.
+  FULLSCREEN_NORMAL,
+
+  // Fullscreen mode for metro snap, occupying the full height and 20% of
+  // the screen width.
+  FULLSCREEN_METRO_SNAP,
+};
+
 // Returns |true| if entry has an internal chrome:// URL, |false| otherwise.
 bool HasInternalURL(const NavigationEntry* entry) {
   if (!entry)
     return false;
 
   // Check the |virtual_url()| first. This catches regular chrome:// URLs
   // including URLs that were rewritten (such as chrome://bookmarks).
   if (entry->GetVirtualURL().SchemeIs(chrome::kChromeUIScheme))
     return true;
 
@@ skipping 117 matching lines @@
                  base::Unretained(this)));
   profile_pref_registrar_.Add(
       prefs::kIncognitoModeAvailability,
       base::Bind(
           &BrowserCommandController::UpdateCommandsForIncognitoAvailability,
           base::Unretained(this)));
   profile_pref_registrar_.Add(
       prefs::kPrintingEnabled,
       base::Bind(&BrowserCommandController::UpdatePrintingState,
                  base::Unretained(this)));
+#if !defined(OS_MACOSX)
+  profile_pref_registrar_.Add(
+      prefs::kFullscreenAllowed,
+      base::Bind(&BrowserCommandController::UpdateCommandsForFullscreenMode,
+                 base::Unretained(this)));
+#endif
   pref_signin_allowed_.Init(
       prefs::kSigninAllowed,
       profile()->GetOriginalProfile()->GetPrefs(),
       base::Bind(&BrowserCommandController::OnSigninAllowedPrefChange,
                  base::Unretained(this)));
 
   InitCommandState();
 
   TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(profile());
@@ skipping 69 matching lines @@
 
 void BrowserCommandController::TabStateChanged() {
   UpdateCommandsForTabState();
 }
 
 void BrowserCommandController::ContentRestrictionsChanged() {
   UpdateCommandsForContentRestrictionState();
 }
 
 void BrowserCommandController::FullscreenStateChanged() {
-  FullScreenMode fullscreen_mode = FULLSCREEN_DISABLED;
-  if (window()->IsFullscreen()) {
-#if defined(OS_WIN)
-    fullscreen_mode = window()->IsInMetroSnapMode() ? FULLSCREEN_METRO_SNAP :
-                                                      FULLSCREEN_NORMAL;
-#else
-    fullscreen_mode = FULLSCREEN_NORMAL;
-#endif
-  }
-  UpdateCommandsForFullscreenMode(fullscreen_mode);
+  UpdateCommandsForFullscreenMode();
 }
 
 void BrowserCommandController::PrintingStateChanged() {
   UpdatePrintingState();
 }
 
 void BrowserCommandController::LoadingStateChanged(bool is_loading,
                                                    bool force) {
   UpdateReloadStopState(is_loading, force);
 }
@@ skipping 620 matching lines @@
   // The upgrade entry and the view incompatibility entry should always be
   // enabled. Whether they are visible is a separate matter determined on menu
   // show.
   command_updater_.UpdateCommandEnabled(IDC_UPGRADE_DIALOG, true);
   command_updater_.UpdateCommandEnabled(IDC_VIEW_INCOMPATIBILITIES, true);
 
   // Toggle speech input
   command_updater_.UpdateCommandEnabled(IDC_TOGGLE_SPEECH_INPUT, true);
 
   // Initialize other commands whose state changes based on fullscreen mode.
-  UpdateCommandsForFullscreenMode(FULLSCREEN_DISABLED);
+  UpdateCommandsForFullscreenMode();
 
   UpdateCommandsForContentRestrictionState();
 
   UpdateCommandsForBookmarkEditing();
 
   UpdateCommandsForIncognitoAvailability();
 }
 
 // static
 void BrowserCommandController::UpdateSharedCommandsForIncognitoAvailability(
@@ skipping 130 matching lines @@
       browser_defaults::bookmarks_enabled &&
       !profile()->GetPrefs()->IsManagedPreference(prefs::kShowBookmarkBar) &&
       IsShowingMainUI());
 }
 
 void BrowserCommandController::UpdateCommandsForFileSelectionDialogs() {
   UpdateSaveAsState();
   UpdateOpenFileState(&command_updater_);
 }
 
-void BrowserCommandController::UpdateCommandsForFullscreenMode(
-    FullScreenMode fullscreen_mode) {
+void BrowserCommandController::UpdateCommandsForFullscreenMode() {
+  FullScreenMode fullscreen_mode = FULLSCREEN_DISABLED;
+  if (window() && window()->IsFullscreen()) {
+#if defined(OS_WIN)
+    fullscreen_mode = window()->IsInMetroSnapMode() ? FULLSCREEN_METRO_SNAP :
+                                                      FULLSCREEN_NORMAL;
+#else
+    fullscreen_mode = FULLSCREEN_NORMAL;
+#endif
+  }
   bool show_main_ui = IsShowingMainUI();
   bool main_not_fullscreen = show_main_ui &&
                              (fullscreen_mode == FULLSCREEN_DISABLED);
 
   // Navigation commands
   command_updater_.UpdateCommandEnabled(IDC_OPEN_CURRENT_URL, show_main_ui);
 
   // Window management commands
   command_updater_.UpdateCommandEnabled(
       IDC_SHOW_AS_TAB,
@@ skipping 36 matching lines @@
 #endif
 
   // Disable explicit fullscreen toggling when in metro snap mode.
   bool fullscreen_enabled = fullscreen_mode != FULLSCREEN_METRO_SNAP;
 #if defined(OS_MACOSX)
   // The Mac implementation doesn't support switching to fullscreen while
   // a tab modal dialog is displayed.
   int tab_index = chrome::IndexOfFirstBlockedTab(browser_->tab_strip_model());
   bool has_blocked_tab = tab_index != browser_->tab_strip_model()->count();
   fullscreen_enabled &= !has_blocked_tab;
+#else
+  if (fullscreen_mode == FULLSCREEN_DISABLED &&
+      !profile()->GetPrefs()->GetBoolean(prefs::kFullscreenAllowed)) {
+    // Disable toggling into fullscreen mode if disallowed by pref.
+    fullscreen_enabled = false;
+  }
 #endif
 
   command_updater_.UpdateCommandEnabled(IDC_FULLSCREEN, fullscreen_enabled);
   command_updater_.UpdateCommandEnabled(IDC_PRESENTATION_MODE,
                                         fullscreen_enabled);
 
   UpdateCommandsForBookmarkBar();
   UpdateCommandsForMultipleProfiles();
 }
 
@@ skipping 80 matching lines @@
 
 BrowserWindow* BrowserCommandController::window() {
   return browser_->window();
 }
 
 Profile* BrowserCommandController::profile() {
   return browser_->profile();
 }
 
 }  // namespace chrome