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. It is still used for
+  // backward compatibility to set the new kIncognitoAvailabilityMode pref in
+  // case the corresponding policy for the latter is not specified.
+  scoped_ptr<Value> 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 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 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);
+    delete value;
+    if (result) {
+      IncognitoModePrefs::Availability availability_enum_value;
+      if (IncognitoModePrefs::IntToAvailability(availability,
+                                                &availability_enum_value)) {
+        prefs_.SetValue(prefs::kIncognitoModeAvailability,
+                        Value::CreateIntegerValue(availability_enum_value));
+      } else {
+        LOG(WARNING) << "IncognitoModeAvailability policy value is "
+                     << "out of range " << availability;
+      }
+    } else {
+      LOG(WARNING) << "IncognitoModeAvailability policy value could not be "
+                   << "parsed";
+    }
+    return true;
+  }
+  if (policy == kPolicyIncognitoEnabled) {
+    deprecated_incognito_enabled_.reset(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_.get()) {
+      bool enabled = true;
+      if (deprecated_incognito_enabled_->GetAsBoolean(&enabled)) {
+        prefs_.SetInteger(
+            prefs::kIncognitoModeAvailability,
+            enabled ? IncognitoModePrefs::ENABLED :
+                      IncognitoModePrefs::DISABLED);
+      } else {
+        LOG(WARNING) << "IncognitoEnabled policy value could not be parsed";
+      }
+    }
+  }
+}
+
 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