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_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 65 matching lines @@
   // ApplyFileSelectionDialogsPolicy assumes the ownership of |value| in the
   // case that the policy is recognized.
   bool ApplyFileSelectionDialogsPolicy(ConfigurationPolicyType policy,
                                        Value* value);
 
   // Processes default search provider policies. Returns true if the specified
   // policy is a default search provider related policy. In that case,
   // ApplyDefaultSearchPolicy takes ownership of |value|.
   bool ApplyDefaultSearchPolicy(ConfigurationPolicyType policy, Value* value);
 
+  // Processes incognito mode availability related policies. Returns true if the
+  // specified policy is pertinent to incognito mode availability. In that case,
+  // the function takes ownership of |value|.
+  bool ApplyIncognitoModePolicy(ConfigurationPolicyType policy, Value* value);
+
   // Make sure that the |path| if present in |prefs_|.  If not, set it to
   // a blank string.
   void EnsureStringPrefExists(const std::string& path);
 
   // If the required entries for default search are specified and valid,
   // 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;
 
   // Temporary cache that stores values until FinalizeProxyPolicySettings()
   // is called.
   std::map<ConfigurationPolicyType, Value*> proxy_policies_;
 
+  // Saved state of the deprecated kPolicyIncognitoEnabled. If is still used for

[Mattias Nissler (ping if slow), 2011/08/01 11:13:40]

s/If/It/

[rustema, 2011/08/01 23:55:33]

Done.

+  // backward compatibility to set the new kIncognitoAvailabilityMode pref in
+  // case the corresponding policy for the latter is not specified.
+  bool deprecated_incognito_enabled_;
+
   PrefValueMap prefs_;
 
   static const PolicyToPreferenceMapEntry kSimplePolicyMap[];
   static const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[];
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyPrefKeeper);
 };
 
 const ConfigurationPolicyPrefKeeper::PolicyToPreferenceMapEntry
     ConfigurationPolicyPrefKeeper::kSimplePolicyMap[] = {
@@ skipping 35 matching lines @@
   { Value::TYPE_LIST, kPolicyDisabledPlugins,
     prefs::kPluginsDisabledPlugins},
   { 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_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 98 matching lines @@
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderInstantURL,
     prefs::kDefaultSearchProviderInstantURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
     prefs::kDefaultSearchProviderIconURL },
   { Value::TYPE_LIST, kPolicyDefaultSearchProviderEncodings,
     prefs::kDefaultSearchProviderEncodings },
 };
 
 ConfigurationPolicyPrefKeeper::ConfigurationPolicyPrefKeeper(
     ConfigurationPolicyProvider* provider) {
+  deprecated_incognito_enabled_ = true;
   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 32 matching lines @@
 
   if (ApplyDiskCacheDirPolicy(policy, value))
     return;
 
   if (ApplyFileSelectionDialogsPolicy(policy, value))
     return;
 
   if (ApplyDefaultSearchPolicy(policy, value))
     return;
 
+  if (ApplyIncognitoModePolicy(policy, value))
+    return;
+
   if (ApplyPolicyFromMap(policy, value, kSimplePolicyMap,
                          arraysize(kSimplePolicyMap)))
     return;
 
   // Other policy implementations go here.
   NOTIMPLEMENTED();
   delete value;
 }
 
 bool ConfigurationPolicyPrefKeeper::RemovePreferencesOfMap(
@@ skipping 167 matching lines @@
     return true;
   }
 
   if (ApplyPolicyFromMap(policy, value, kDefaultSearchPolicyMap,
                          arraysize(kDefaultSearchPolicyMap))) {
     return true;
   }
   return false;
 }
 
+bool ConfigurationPolicyPrefKeeper::ApplyIncognitoModePolicy(
+    ConfigurationPolicyType policy,
+    Value* value) {
+  if (policy == kPolicyIncognitoModeAvailability) {
+    int availability = IncognitoModePrefs::ENABLED;
+    bool result = value->GetAsInteger(&availability);
+    DCHECK(result);
+    delete value;
+    IncognitoModePrefs::Availability availability_enum_value;
+    result = IncognitoModePrefs::IntToAvailability(availability,
+                                                   &availability_enum_value);
+    DCHECK(result);
+    prefs_.SetValue(prefs::kIncognitoModeAvailability,
+                    Value::CreateIntegerValue(availability_enum_value));
+    return true;
+  }
+  if (policy == kPolicyIncognitoEnabled) {

[Mattias Nissler (ping if slow), 2011/08/01 11:13:40]

else if

[rustema, 2011/08/01 23:55:33]

But there's a return statement in the previous if block. I thought having if
blocks with return statements was cleaner. Do you insist that I change it to
"else if"?

[Mattias Nissler (ping if slow), 2011/08/03 09:16:08]

Yes, right, sorry for the noise.

+    bool result = value->GetAsBoolean(&deprecated_incognito_enabled_);
+    DCHECK(result);
+    delete value;
+    return true;
+  }
+  // The policy is not relevant to incognito.
+  return false;
+}
+
 void ConfigurationPolicyPrefKeeper::EnsureStringPrefExists(
     const std::string& path) {
   std::string value;
   if (!prefs_.GetString(path, &value))
     prefs_.SetString(path, value);
 }
 
 namespace {
 
 // Implementation of SearchTermsData just for validation.
@@ skipping 61 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() {
+  int int_value;
+  if (!prefs_.GetInteger(prefs::kIncognitoModeAvailability, &int_value)) {
+    // If kPolicyIncognitoModeAvailability is not specified, check the obsolete
+    // kPolicyIncognitoEnabled.
+    if (!deprecated_incognito_enabled_) {

[Mattias Nissler (ping if slow), 2011/08/01 11:13:40]

It's not correct to treat the cases "not set" and "set to true" the same. If the
legacy policy is set to true, you should set the pref below, but you don't. This
is important s.t. client code asking IsManaged() on the pref will get the right
value.

To accomplish this, I suggest you keep a scoped_ptr<Value> to save the value of
the deprecated policy in instead of the  boolean flag you have at the moment.

[rustema, 2011/08/01 23:55:33]

Done.

+      // If the obsolete policy says that incognito is disabled,
+      prefs_.SetInteger(prefs::kIncognitoModeAvailability,
+                        IncognitoModePrefs::DISABLED);
+    }
+  }
+}
+
 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