Converted IncognitoForced boolean policy into IncognitoModeAvailability enum policy.

chrome/browser/policy/configuration_policy_pref_store.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/policy/configuration_policy_pref_store.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_path_parser.h"
+#include "chrome/browser/prefs/incognito_mode_availability_prefs.h"
 #include "chrome/browser/prefs/pref_value_map.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_service.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
@@ skipping 80 matching lines @@
   // finalizes the policy-specified configuration by initializing the
   // unspecified map entries.  Otherwise wipes all default search related
   // map entries from |prefs_|.
   void FinalizeDefaultSearchPolicySettings();
 
   // If the required entries for the proxy settings are specified and valid,
   // finalizes the policy-specified configuration by initializing the
   // respective values in |prefs_|.
   void FinalizeProxyPolicySettings();
 
+  // If the required entries for the Incognito mode availability settings
+  // are specified and valid, finalizes the policy-specified configuration
+  // by initializing the respective values in |prefs_|.
+  void FinalizeIncognitoModeSettings();
+
   // Returns true if the policy values stored in proxy_* represent a valid proxy
   // configuration, including the case in which there is no configuration at
   // all.
   bool CheckProxySettings();
 
   // Assumes CheckProxySettings returns true and applies the values stored
   // in proxy_*.
   void ApplyProxySettings();
 
   bool HasProxyPolicy(ConfigurationPolicyType policy) const;
@@ skipping 52 matching lines @@
   { Value::TYPE_LIST, kPolicyDisabledPluginsExceptions,
     prefs::kPluginsDisabledPluginsExceptions},
   { Value::TYPE_LIST, kPolicyEnabledPlugins,
     prefs::kPluginsEnabledPlugins},
   { Value::TYPE_BOOLEAN, kPolicyShowHomeButton,
     prefs::kShowHomeButton },
   { Value::TYPE_BOOLEAN, kPolicyJavascriptEnabled,
     prefs::kWebKitJavascriptEnabled },
   { Value::TYPE_BOOLEAN, kPolicyIncognitoEnabled,
     prefs::kIncognitoEnabled },
-  { Value::TYPE_BOOLEAN, kPolicyIncognitoForced,
-    prefs::kIncognitoForced },
+  { Value::TYPE_INTEGER, kPolicyIncognitoModeAvailability,
+    prefs::kIncognitoModeAvailability },
   { Value::TYPE_BOOLEAN, kPolicySavingBrowserHistoryDisabled,
     prefs::kSavingBrowserHistoryDisabled },
   { Value::TYPE_BOOLEAN, kPolicyClearSiteDataOnExit,
     prefs::kClearSiteDataOnExit },
   { Value::TYPE_BOOLEAN, kPolicyDeveloperToolsDisabled,
     prefs::kDevToolsDisabled },
   { Value::TYPE_BOOLEAN, kPolicyBlockThirdPartyCookies,
     prefs::kBlockThirdPartyCookies },
   { Value::TYPE_INTEGER, kPolicyDefaultCookiesSetting,
     prefs::kManagedDefaultCookiesSetting },
@@ skipping 102 matching lines @@
   { Value::TYPE_LIST, kPolicyDefaultSearchProviderEncodings,
     prefs::kDefaultSearchProviderEncodings },
 };
 
 ConfigurationPolicyPrefKeeper::ConfigurationPolicyPrefKeeper(
     ConfigurationPolicyProvider* provider) {
   if (!provider->Provide(this))
     LOG(WARNING) << "Failed to get policy from provider.";
   FinalizeProxyPolicySettings();
   FinalizeDefaultSearchPolicySettings();
+  FinalizeIncognitoModeSettings();
 }
 
 ConfigurationPolicyPrefKeeper::~ConfigurationPolicyPrefKeeper() {
   DCHECK(proxy_policies_.empty());
 }
 
 PrefStore::ReadResult
 ConfigurationPolicyPrefKeeper::GetValue(const std::string& key,
                                         const Value** result) const {
   const Value* stored_value = NULL;
@@ skipping 300 matching lines @@
       prefs_.SetString(prefs::kDefaultSearchProviderPrepopulateID,
                         std::string());
       return;
     }
   }
   // Required entries are not there.  Remove any related entries.
   RemovePreferencesOfMap(kDefaultSearchPolicyMap,
                          arraysize(kDefaultSearchPolicyMap));
 }
 
+void ConfigurationPolicyPrefKeeper::FinalizeIncognitoModeSettings() {
+  IncognitoModeAvailabilityPrefs::IncognitoModeAvailability available;
+  int int_value;
+  if (prefs_.GetInteger(prefs::kIncognitoModeAvailability, &int_value))

[Mattias Nissler (ping if slow), 2011/07/28 11:08:50]

need curlies due to multi-line block below

[rustema, 2011/07/29 06:49:23]

Done.

+    IncognitoModeAvailabilityPrefs::IntToIngocnitoModeAvailability(

[Bernhard Bauer, 2011/07/28 11:34:03]

To be very thorough, you should also check the return value of this method.
Also, I think you should initialize the values above, otherwise coverity might
complain.

[rustema, 2011/07/29 06:49:23]

Done.

+        int_value, &available);
+  else
+    available = IncognitoModeAvailabilityPrefs::ENABLED;
+
+  bool obsolete_incognito_enabled;
+  if (!prefs_.GetBoolean(prefs::kIncognitoEnabled, &obsolete_incognito_enabled))

[Mattias Nissler (ping if slow), 2011/07/28 11:08:50]

we shouldn't have that pref any longer. Just remove it. Write an
ApplyIncognito() function that grabs the policy value. Then check here whether
the new policy is present. If not, set the new pref according to what the old
IncognitoEnabled policy value says.

[rustema, 2011/07/29 06:49:23]

Done.

+    obsolete_incognito_enabled = true;
+
+  // If the user has set the obsolete IncognitoEnabled to false, override
+  // the availability preference.
+  // Note that kPolicyIncognitoModeAvailability trumps kPolicyIncognitoEnabled
+  // in case the user wants to force Incognito through the former.
+  if (!obsolete_incognito_enabled &&
+      available != IncognitoModeAvailabilityPrefs::FORCED) {
+    available = IncognitoModeAvailabilityPrefs::DISABLED;
+  }
+
+  prefs_.SetInteger(prefs::kIncognitoModeAvailability, available);
+}
+
 void ConfigurationPolicyPrefKeeper::FinalizeProxyPolicySettings() {
   if (CheckProxySettings())
     ApplyProxySettings();
 
   STLDeleteContainerPairSecondPointers(proxy_policies_.begin(),
                                        proxy_policies_.end());
   proxy_policies_.clear();
 }
 
 bool ConfigurationPolicyPrefKeeper::CheckProxySettings() {
@@ skipping 342 matching lines @@
     { kPolicyExtensionInstallWhitelist, Value::TYPE_LIST,
       key::kExtensionInstallWhitelist },
     { kPolicyExtensionInstallBlacklist, Value::TYPE_LIST,
       key::kExtensionInstallBlacklist },
     { kPolicyExtensionInstallForcelist, Value::TYPE_LIST,
       key::kExtensionInstallForcelist },
     { kPolicyShowHomeButton, Value::TYPE_BOOLEAN, key::kShowHomeButton },
     { kPolicyPrintingEnabled, Value::TYPE_BOOLEAN, key::kPrintingEnabled },
     { kPolicyJavascriptEnabled, Value::TYPE_BOOLEAN, key::kJavascriptEnabled },
     { kPolicyIncognitoEnabled, Value::TYPE_BOOLEAN, key::kIncognitoEnabled },
-    { kPolicyIncognitoForced, Value::TYPE_BOOLEAN, key::kIncognitoForced },
+    { kPolicyIncognitoModeAvailability, Value::TYPE_INTEGER,
+      key::kIncognitoModeAvailability },
     { kPolicySavingBrowserHistoryDisabled, Value::TYPE_BOOLEAN,
       key::kSavingBrowserHistoryDisabled },
     { kPolicyClearSiteDataOnExit, Value::TYPE_BOOLEAN,
       key::kClearSiteDataOnExit },
     { kPolicyDeveloperToolsDisabled, Value::TYPE_BOOLEAN,
       key::kDeveloperToolsDisabled },
     { kPolicyBlockThirdPartyCookies, Value::TYPE_BOOLEAN,
       key::kBlockThirdPartyCookies },
     { kPolicyDefaultCookiesSetting, Value::TYPE_INTEGER,
       key::kDefaultCookiesSetting },
@@ skipping 125 matching lines @@
   // Update the initialization flag.
   if (!initialization_complete_ &&
       provider_->IsInitializationComplete()) {
     initialization_complete_ = true;
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted(true));
   }
 }
 
 }  // namespace policy