Deprecate and re-wire the ClearSiteDataOnExit policy.

chrome/browser/policy/configuration_policy_handler.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/policy/configuration_policy_handler.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/policy_error_map.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_path_parser.h"
 #include "chrome/browser/prefs/pref_value_map.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/content_settings.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 namespace {
 
@@ skipping 1050 matching lines @@
       setting = CONTENT_SETTING_BLOCK;
     }
   }
 
   if (setting != CONTENT_SETTING_DEFAULT) {
     prefs->SetValue(prefs::kManagedDefaultJavaScriptSetting,
                     Value::CreateIntegerValue(setting));
   }
 }
 
+// ClearSiteDataOnExitPolicyHandler implementation -----------------------------
+
+ClearSiteDataOnExitPolicyHandler::ClearSiteDataOnExitPolicyHandler()
+    : TypeCheckingPolicyHandler(key::kClearSiteDataOnExit,
+                                Value::TYPE_BOOLEAN) {
+}
+
+ClearSiteDataOnExitPolicyHandler::~ClearSiteDataOnExitPolicyHandler() {
+}
+
+bool ClearSiteDataOnExitPolicyHandler::CheckPolicySettings(
+    const PolicyMap& policies,
+    PolicyErrorMap* errors) {
+  ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+  if (ClearSiteDataEnabled(policies) &&
+      GetContentSetting(policies, &content_setting) &&
+      content_setting == CONTENT_SETTING_ALLOW) {
+    errors->AddError(key::kDefaultCookiesSetting,
+                     IDS_POLICY_OVERRIDDEN,
+                     policy_name());
+  }
+
+  return TypeCheckingPolicyHandler::CheckPolicySettings(policies, errors);
+}
+
+void ClearSiteDataOnExitPolicyHandler::ApplyPolicySettings(
+    const PolicyMap& policies,
+    PrefValueMap* prefs) {
+  if (ClearSiteDataEnabled(policies)) {
+    ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+    if (!GetContentSetting(policies, &content_setting) ||
+        content_setting == CONTENT_SETTING_ALLOW) {
+      prefs->SetValue(
+          prefs::kManagedDefaultCookiesSetting,
+          Value::CreateIntegerValue(CONTENT_SETTING_SESSION_ONLY));
+    }
+  }
+}
+
+bool ClearSiteDataOnExitPolicyHandler::ClearSiteDataEnabled(
+    const PolicyMap& policies) {
+  const base::Value* value = NULL;
+  PolicyErrorMap errors;
+  bool clear_site_data = false;
+
+  return (CheckAndGetValue(policies, &errors, &value) &&
+          value &&
+          value->GetAsBoolean(&clear_site_data) &&
+          clear_site_data);
+}
+
+// static
+bool ClearSiteDataOnExitPolicyHandler::GetContentSetting(
+    const PolicyMap& policies,
+    ContentSetting* content_setting) {
+  const base::Value* value = policies.GetValue(key::kDefaultCookiesSetting);
+  int setting = CONTENT_SETTING_DEFAULT;
+  if (value && value->GetAsInteger(&setting)) {
+    *content_setting = static_cast<ContentSetting>(setting);
+    return true;
+  }
+
+  return false;
+}
+
 // RestoreOnStartupPolicyHandler implementation --------------------------------
 
 RestoreOnStartupPolicyHandler::RestoreOnStartupPolicyHandler()
     : TypeCheckingPolicyHandler(key::kRestoreOnStartup,
                                 Value::TYPE_INTEGER) {
 }
 
 RestoreOnStartupPolicyHandler::~RestoreOnStartupPolicyHandler() {
 }
 
@@ skipping 95 matching lines @@
           errors->AddError(policy_name(),
                            IDS_POLICY_OUT_OF_RANGE_ERROR,
                            base::IntToString(restore_value));
       }
     }
   }
   return true;
 }
 
 }  // namespace policy