Converted IncognitoForced boolean policy into IncognitoModeAvailability enum policy.

chrome/browser/ui/browser.cc

 // Copyright (c) 2011 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.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 37 matching lines @@
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/instant/instant_unload_handler.h"
 #include "chrome/browser/net/browser_url_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/notifications/notification_ui_manager.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/cloud_print/cloud_print_setup_flow.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
@@ skipping 217 matching lines @@
   if (local_state) {
     local_pref_registrar_.Init(local_state);
     local_pref_registrar_.Add(prefs::kPrintingEnabled, this);
     local_pref_registrar_.Add(prefs::kAllowFileSelectionDialogs, this);
   }
 
   profile_pref_registrar_.Init(profile_->GetPrefs());
   profile_pref_registrar_.Add(prefs::kDevToolsDisabled, this);
   profile_pref_registrar_.Add(prefs::kEditBookmarksEnabled, this);
   profile_pref_registrar_.Add(prefs::kInstantEnabled, this);
-  profile_pref_registrar_.Add(prefs::kIncognitoEnabled, this);
+  profile_pref_registrar_.Add(prefs::kIncognitoModeAvailability, this);
 
   InitCommandState();
   BrowserList::AddBrowser(this);
 
   // NOTE: These prefs all need to be explicitly destroyed in the destructor
   // or you'll get a nasty surprise when you run the incognito tests.
   encoding_auto_detect_.Init(prefs::kWebKitUsesUniversalDetector,
                              profile_->GetPrefs(), NULL);
   use_vertical_tabs_.Init(prefs::kUseVerticalTabs, profile_->GetPrefs(), this);
   use_compact_navigation_bar_.Init(prefs::kUseCompactNavigationBar,
@@ skipping 1157 matching lines @@
                               extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
   }
 }
 
 void Browser::Stop() {
   UserMetrics::RecordAction(UserMetricsAction("Stop"));
   GetSelectedTabContentsWrapper()->tab_contents()->Stop();
 }
 
 void Browser::NewWindow() {
+  IncognitoModePrefs::Availability incognito_avail =
+      IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
+      incognito_avail != IncognitoModePrefs::DISABLED &&
       (CommandLine::ForCurrentProcess()->HasSwitch(switches::kIncognito) ||
-       profile_->GetPrefs()->GetBoolean(prefs::kIncognitoForced)) &&
-      profile_->GetPrefs()->GetBoolean(prefs::kIncognitoEnabled)) {
+       incognito_avail == IncognitoModePrefs::FORCED)) {
     NewIncognitoWindow();
     return;
   }
   UserMetrics::RecordAction(UserMetricsAction("NewWindow"));
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile_->GetOriginalProfile());
   if (!session_service ||
       !session_service->RestoreIfNecessary(std::vector<GURL>())) {
     Browser::OpenEmptyWindow(profile_->GetOriginalProfile());
   }
 }
 
 void Browser::NewIncognitoWindow() {
-  if (!profile_->GetPrefs()->GetBoolean(prefs::kIncognitoEnabled)) {
+  if (IncognitoModePrefs::GetAvailability(profile_->GetPrefs()) ==
+          IncognitoModePrefs::DISABLED) {
     NewWindow();
     return;
   }
 
   UserMetrics::RecordAction(UserMetricsAction("NewIncognitoWindow"));
   Browser::OpenEmptyWindow(profile_->GetOffTheRecordProfile());
 }
 
 void Browser::CloseWindow() {
   UserMetrics::RecordAction(UserMetricsAction("CloseWindow"));
@@ skipping 744 matching lines @@
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kCloudPrintEmail,
                             std::string(),
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kCloudPrintProxyEnabled,
                              true,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kDevToolsDisabled,
                              false,
                              PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kIncognitoEnabled,
-                             true,
-                             PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kIncognitoForced,
-                             false,
-                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation,
                              -1,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kBrowserWindowPlacement,
                                 PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kPreferencesWindowPlacement,
                                 PrefService::UNSYNCABLE_PREF);
   // We need to register the type of these preferences in order to query
   // them even though they're only typically controlled via policy.
   prefs->RegisterBooleanPref(prefs::kDisable3DAPIs,
@@ skipping 1417 matching lines @@
       } else if (pref_name == prefs::kInstantEnabled) {
         if (!InstantController::IsEnabled(profile())) {
           if (instant()) {
             instant()->DestroyPreviewContents();
             instant_.reset();
             instant_unload_handler_.reset();
           }
         } else {
           CreateInstantIfNecessary();
         }
-      } else if (pref_name == prefs::kIncognitoEnabled) {
+      } else if (pref_name == prefs::kIncognitoModeAvailability) {
+        IncognitoModePrefs::Availability available =
+            IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
+        command_updater_.UpdateCommandEnabled(
+            IDC_NEW_WINDOW,
+            available != IncognitoModePrefs::FORCED);
         command_updater_.UpdateCommandEnabled(
             IDC_NEW_INCOGNITO_WINDOW,
-            profile_->GetPrefs()->GetBoolean(prefs::kIncognitoEnabled));
+            available != IncognitoModePrefs::DISABLED);
       } else if (pref_name == prefs::kDevToolsDisabled) {
         UpdateCommandsForDevTools();
         if (profile_->GetPrefs()->GetBoolean(prefs::kDevToolsDisabled))
           g_browser_process->devtools_manager()->CloseAllClientHosts();
       } else if (pref_name == prefs::kEditBookmarksEnabled) {
         UpdateCommandsForBookmarkEditing();
       } else if (pref_name == prefs::kAllowFileSelectionDialogs) {
         UpdateSaveAsState(GetContentRestrictionsForSelectedTab());
         UpdateOpenFileState();
       } else {
@@ skipping 114 matching lines @@
 void Browser::InitCommandState() {
   // All browser commands whose state isn't set automagically some other way
   // (like Back & Forward with initial page load) must have their state
   // initialized here, otherwise they will be forever disabled.
 
   // Navigation commands
   command_updater_.UpdateCommandEnabled(IDC_RELOAD, true);
   command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE, true);
 
   // Window management commands
-  command_updater_.UpdateCommandEnabled(IDC_NEW_WINDOW, true);
+  IncognitoModePrefs::Availability incognito_avail =
+      IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
+  command_updater_.UpdateCommandEnabled(
+      IDC_NEW_WINDOW,
+      incognito_avail != IncognitoModePrefs::FORCED);
   command_updater_.UpdateCommandEnabled(
       IDC_NEW_INCOGNITO_WINDOW,
-      profile_->GetPrefs()->GetBoolean(prefs::kIncognitoEnabled));
+      incognito_avail != IncognitoModePrefs::DISABLED);
+
   command_updater_.UpdateCommandEnabled(IDC_CLOSE_WINDOW, true);
   command_updater_.UpdateCommandEnabled(IDC_NEW_TAB, true);
   command_updater_.UpdateCommandEnabled(IDC_CLOSE_TAB, true);
   command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB, true);
   command_updater_.UpdateCommandEnabled(IDC_RESTORE_TAB, false);
   command_updater_.UpdateCommandEnabled(IDC_EXIT, true);
   command_updater_.UpdateCommandEnabled(IDC_TOGGLE_VERTICAL_TABS, true);
   command_updater_.UpdateCommandEnabled(IDC_DEBUG_FRAME_TOGGLE, true);
 
   // Page-related commands
@@ skipping 953 matching lines @@
   window_->BookmarkBarStateChanged(animate_type);
 }
 
 void Browser::ShowSyncSetup() {
   ProfileSyncService* service = profile()->GetProfileSyncService();
   if (service->HasSyncSetupCompleted())
     ShowOptionsTab(chrome::kSyncSetupSubPage);
   else
     profile()->GetProfileSyncService()->ShowLoginDialog();
 }