Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2521)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/policy/configuration_policy_handler.cc

Issue 8139029: Make policy errors available to display in about:policy. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Fix bad commit Created 9 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« chrome/browser/policy/configuration_policy_handler.h ('K') | « chrome/browser/policy/configuration_policy_handler.h ('k') | chrome/browser/policy/configuration_policy_pref_store.h » ('j') | chrome/browser/policy/configuration_policy_pref_store.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/policy/configuration_policy_handler.cc
diff --git a/chrome/browser/policy/configuration_policy_handler.cc b/chrome/browser/policy/configuration_policy_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e44716d94fc7d1081cbecf10ee18b07ef206be65
--- /dev/null
+++ b/chrome/browser/policy/configuration_policy_handler.cc
@@ -0,0 +1,1272 @@
+// 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_handler.h"
+
+#include <string>
+#include <vector>
+
+#include "base/file_path.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 "base/utf_string_conversions.h"
+#include "base/values.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/incognito_mode_prefs.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/search_engines/search_terms_data.h"
+#include "chrome/browser/search_engines/template_url.h"
+#include "chrome/common/pref_names.h"
+#include "grit/generated_resources.h"
+#include "policy/configuration_policy_type.h"
+
+namespace policy {
+
+namespace {
+
+
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 remove some extra white space?
Joao da Silva 2011/10/11 15:09:23 Done.
+// Implementations of ConfigurationPolicyHandler -------------------------------
+
+
+// Abstract class derived from ConfigurationPolicyHandler that should be
+// subclassed to handle a single policy (not a combination of policies).
+class TypeCheckingPolicyHandler : public ConfigurationPolicyHandler {
+ public:
+ TypeCheckingPolicyHandler(ConfigurationPolicyType policy_type,
+ base::Value::Type value_type);
+
+ // ConfigurationPolicyHandler methods:
+ virtual bool CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) OVERRIDE;
+
+ protected:
+ virtual ~TypeCheckingPolicyHandler();
+
+ ConfigurationPolicyType policy_type() const;
+
+ private:
+ // The ConfigurationPolicyType of the policy.
+ ConfigurationPolicyType policy_type_;
+
+ // The type the value of the policy should have.
+ base::Value::Type value_type_;
+
+ DISALLOW_COPY_AND_ASSIGN(TypeCheckingPolicyHandler);
+};
+
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 nit: remove extra blank line? also below.
Joao da Silva 2011/10/11 15:09:23 Done.
+
+// ConfigurationPolicyHandler for policies that map directly to a preference.
+class SimplePolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ SimplePolicyHandler(ConfigurationPolicyType policy_type,
+ base::Value::Type value_type,
+ const char* pref_path);
+ virtual ~SimplePolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ // The DictionaryValue path of the preference the policy maps to.
+ const char* pref_path_;
+
+ DISALLOW_COPY_AND_ASSIGN(SimplePolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the SyncDisabled policy.
+class SyncPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ SyncPolicyHandler();
+ virtual ~SyncPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(SyncPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the AutofillEnabled policy.
+class AutofillPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ AutofillPolicyHandler();
+ virtual ~AutofillPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AutofillPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the DownloadDirectory policy.
+class DownloadDirPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ DownloadDirPolicyHandler();
+ virtual ~DownloadDirPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DownloadDirPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the DiskCacheDir policy.
+class DiskCacheDirPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ explicit DiskCacheDirPolicyHandler();
+ virtual ~DiskCacheDirPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DiskCacheDirPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the FileSelectionDialogsHandler policy.
+class FileSelectionDialogsHandler : public TypeCheckingPolicyHandler {
+ public:
+ FileSelectionDialogsHandler();
+ virtual ~FileSelectionDialogsHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(FileSelectionDialogsHandler);
+};
+
+
+// ConfigurationPolicyHandler for the incognito mode policies.
+class IncognitoModePolicyHandler : public ConfigurationPolicyHandler {
+ public:
+ IncognitoModePolicyHandler();
+ virtual ~IncognitoModePolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual bool CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) OVERRIDE;
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ IncognitoModePrefs::Availability GetAvailabilityValueAsEnum(
+ const Value* availability);
+
+ DISALLOW_COPY_AND_ASSIGN(IncognitoModePolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the DefaultSearchEncodings policy.
+class DefaultSearchEncodingsPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+ DefaultSearchEncodingsPolicyHandler();
+ virtual ~DefaultSearchEncodingsPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DefaultSearchEncodingsPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the default search policies.
+class DefaultSearchPolicyHandler : public ConfigurationPolicyHandler {
+ public:
+ DefaultSearchPolicyHandler();
+ virtual ~DefaultSearchPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual bool CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) OVERRIDE;
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ // Calls |CheckPolicySettings()| on each of the handlers in |handlers_|
+ // and returns true if all of the calls return true and false otherwise.
+ bool CheckIndividualPolicies(const PolicyMap* policies,
+ PolicyErrorMap* errors);
+
+ // Returns true if there is a value for |policy_type| in |policies| and false
+ // otherwise.
+ bool HasDefaultSearchPolicy(const PolicyMap* policies,
+ ConfigurationPolicyType policy_type);
+
+ // Returns true if any default search policies are specified in |policies| and
+ // false otherwise.
+ bool AnyDefaultSearchPoliciesSpecified(const PolicyMap* policies);
+
+ // Returns true if the default search provider is disabled and false
+ // otherwise.
+ bool DefaultSearchProviderIsDisabled(const PolicyMap* policies);
+
+ // Returns true if the default search URL was set and is valid and false
+ // otherwise.
+ bool DefaultSearchURLIsValid(const PolicyMap* policies);
+
+ // Make sure that the |path| if present in |prefs_|. If not, set it to
+ // a blank string.
+ void EnsureStringPrefExists(PrefValueMap* prefs, const std::string& path);
+
+ // The ConfigurationPolicyHandler handlers for each default search policy.
+ HandlerList handlers_;
+
+ DISALLOW_COPY_AND_ASSIGN(DefaultSearchPolicyHandler);
+};
+
+
+// ConfigurationPolicyHandler for the proxy policies.
+class ProxyPolicyHandler : public ConfigurationPolicyHandler {
+ public:
+ ProxyPolicyHandler();
+ virtual ~ProxyPolicyHandler();
+
+ // ConfigurationPolicyHandler methods:
+ virtual bool CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) OVERRIDE;
+ virtual void ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) OVERRIDE;
+
+ private:
+ const Value* GetProxyPolicyValue(const PolicyMap* policies,
+ ConfigurationPolicyType policy);
+
+ // Converts the deprecated ProxyServerMode policy value to a ProxyMode value
+ // and places the result in |mode_value|. Returns true if the conversion
+ // succeeded and false otherwise.
+ bool CheckProxyModeAndServerMode(const PolicyMap* policies,
+ PolicyErrorMap* errors,
+ std::string* mode_value);
+
+ DISALLOW_COPY_AND_ASSIGN(ProxyPolicyHandler);
+};
+
+
+// Helper classes --------------------------------------------------------------
+
+
+// Implementation of SearchTermsData just for validation.
+class SearchTermsDataForValidation : public SearchTermsData {
+ public:
+ SearchTermsDataForValidation() {}
+
+ // Implementation of SearchTermsData.
+ virtual std::string GoogleBaseURLValue() const {
+ return "http://www.google.com/";
+ }
+ virtual std::string GetApplicationLocale() const {
+ return "en";
+ }
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+ virtual string16 GetRlzParameterValue() const {
+ return string16();
+ }
+#endif
+ private:
+ DISALLOW_COPY_AND_ASSIGN(SearchTermsDataForValidation);
+};
+
+
+// This is used to check whether for a given ProxyMode value, the ProxyPacUrl,
+// the ProxyBypassList and the ProxyServer policies are allowed to be specified.
+// |error_message_id| is the message id of the localized error message to show
+// when the policies are not specified as allowed. Each value of ProxyMode
+// has a ProxyModeValidationEntry in the |kProxyModeValidationMap| below.
+struct ProxyModeValidationEntry {
+ const char* mode_value;
+ bool pac_url_allowed;
+ bool bypass_list_allowed;
+ bool server_allowed;
+ int error_message_id;
+};
+
+
+// Maps a policy type to a preference path, and to the expected value type.
+// This is the entry type of |kSimplePolicyMap| below.
+struct PolicyToPreferenceMapEntry {
+ base::Value::Type value_type;
+ ConfigurationPolicyType policy_type;
+ const char* preference_path;
+};
+
+
+// Static data -----------------------------------------------------------------
+
+
+// List of policy types to preference names. This is used for simple policies
+// that directly map to a single preference.
+const PolicyToPreferenceMapEntry kSimplePolicyMap[] = {
+ { Value::TYPE_STRING, kPolicyHomepageLocation, prefs::kHomePage },
+ { Value::TYPE_BOOLEAN, kPolicyHomepageIsNewTabPage,
+ prefs::kHomePageIsNewTabPage },
+ { Value::TYPE_INTEGER, kPolicyRestoreOnStartup,
+ prefs::kRestoreOnStartup},
+ { Value::TYPE_LIST, kPolicyRestoreOnStartupURLs,
+ prefs::kURLsToRestoreOnStartup },
+ { Value::TYPE_BOOLEAN, kPolicyAlternateErrorPagesEnabled,
+ prefs::kAlternateErrorPagesEnabled },
+ { Value::TYPE_BOOLEAN, kPolicySearchSuggestEnabled,
+ prefs::kSearchSuggestEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyDnsPrefetchingEnabled,
+ prefs::kNetworkPredictionEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyDisableSpdy,
+ prefs::kDisableSpdy },
+ { Value::TYPE_LIST, kPolicyDisabledSchemes,
+ prefs::kDisabledSchemes },
+ { Value::TYPE_BOOLEAN, kPolicySafeBrowsingEnabled,
+ prefs::kSafeBrowsingEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyPasswordManagerEnabled,
+ prefs::kPasswordManagerEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyPasswordManagerAllowShowPasswords,
+ prefs::kPasswordManagerAllowShowPasswords },
+ { Value::TYPE_BOOLEAN, kPolicyPrintingEnabled,
+ prefs::kPrintingEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyMetricsReportingEnabled,
+ prefs::kMetricsReportingEnabled },
+ { Value::TYPE_STRING, kPolicyApplicationLocaleValue,
+ prefs::kApplicationLocale},
+ { Value::TYPE_LIST, kPolicyExtensionInstallWhitelist,
+ prefs::kExtensionInstallAllowList},
+ { Value::TYPE_LIST, kPolicyExtensionInstallBlacklist,
+ prefs::kExtensionInstallDenyList},
+ { Value::TYPE_LIST, kPolicyExtensionInstallForcelist,
+ prefs::kExtensionInstallForceList},
+ { 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, 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 },
+ { Value::TYPE_INTEGER, kPolicyDefaultImagesSetting,
+ prefs::kManagedDefaultImagesSetting },
+ { Value::TYPE_INTEGER, kPolicyDefaultJavaScriptSetting,
+ prefs::kManagedDefaultJavaScriptSetting },
+ { Value::TYPE_INTEGER, kPolicyDefaultPluginsSetting,
+ prefs::kManagedDefaultPluginsSetting },
+ { Value::TYPE_INTEGER, kPolicyDefaultPopupsSetting,
+ prefs::kManagedDefaultPopupsSetting },
+ { Value::TYPE_LIST, kPolicyAutoSelectCertificateForUrls,
+ prefs::kManagedAutoSelectCertificateForUrls},
+ { Value::TYPE_LIST, kPolicyCookiesAllowedForUrls,
+ prefs::kManagedCookiesAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyCookiesBlockedForUrls,
+ prefs::kManagedCookiesBlockedForUrls },
+ { Value::TYPE_LIST, kPolicyCookiesSessionOnlyForUrls,
+ prefs::kManagedCookiesSessionOnlyForUrls },
+ { Value::TYPE_LIST, kPolicyImagesAllowedForUrls,
+ prefs::kManagedImagesAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyImagesBlockedForUrls,
+ prefs::kManagedImagesBlockedForUrls },
+ { Value::TYPE_LIST, kPolicyJavaScriptAllowedForUrls,
+ prefs::kManagedJavaScriptAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyJavaScriptBlockedForUrls,
+ prefs::kManagedJavaScriptBlockedForUrls },
+ { Value::TYPE_LIST, kPolicyPluginsAllowedForUrls,
+ prefs::kManagedPluginsAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyPluginsBlockedForUrls,
+ prefs::kManagedPluginsBlockedForUrls },
+ { Value::TYPE_LIST, kPolicyPopupsAllowedForUrls,
+ prefs::kManagedPopupsAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyPopupsBlockedForUrls,
+ prefs::kManagedPopupsBlockedForUrls },
+ { Value::TYPE_LIST, kPolicyNotificationsAllowedForUrls,
+ prefs::kManagedNotificationsAllowedForUrls },
+ { Value::TYPE_LIST, kPolicyNotificationsBlockedForUrls,
+ prefs::kManagedNotificationsBlockedForUrls },
+ { Value::TYPE_INTEGER, kPolicyDefaultNotificationsSetting,
+ prefs::kManagedDefaultNotificationsSetting },
+ { Value::TYPE_INTEGER, kPolicyDefaultGeolocationSetting,
+ prefs::kManagedDefaultGeolocationSetting },
+ { Value::TYPE_STRING, kPolicyAuthSchemes,
+ prefs::kAuthSchemes },
+ { Value::TYPE_BOOLEAN, kPolicyDisableAuthNegotiateCnameLookup,
+ prefs::kDisableAuthNegotiateCnameLookup },
+ { Value::TYPE_BOOLEAN, kPolicyEnableAuthNegotiatePort,
+ prefs::kEnableAuthNegotiatePort },
+ { Value::TYPE_STRING, kPolicyAuthServerWhitelist,
+ prefs::kAuthServerWhitelist },
+ { Value::TYPE_STRING, kPolicyAuthNegotiateDelegateWhitelist,
+ prefs::kAuthNegotiateDelegateWhitelist },
+ { Value::TYPE_STRING, kPolicyGSSAPILibraryName,
+ prefs::kGSSAPILibraryName },
+ { Value::TYPE_BOOLEAN, kPolicyAllowCrossOriginAuthPrompt,
+ prefs::kAllowCrossOriginAuthPrompt },
+ { Value::TYPE_BOOLEAN, kPolicyDisable3DAPIs,
+ prefs::kDisable3DAPIs },
+ { Value::TYPE_BOOLEAN, kPolicyDisablePluginFinder,
+ prefs::kDisablePluginFinder },
+ { Value::TYPE_INTEGER, kPolicyPolicyRefreshRate,
+ prefs::kUserPolicyRefreshRate },
+ { Value::TYPE_INTEGER, kPolicyDevicePolicyRefreshRate,
+ prefs::kDevicePolicyRefreshRate },
+ { Value::TYPE_BOOLEAN, kPolicyInstantEnabled, prefs::kInstantEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyDefaultBrowserSettingEnabled,
+ prefs::kDefaultBrowserSettingEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyRemoteAccessClientFirewallTraversal,
+ prefs::kRemoteAccessClientFirewallTraversal },
+ { Value::TYPE_BOOLEAN, kPolicyRemoteAccessHostFirewallTraversal,
+ prefs::kRemoteAccessHostFirewallTraversal },
+ { Value::TYPE_BOOLEAN, kPolicyCloudPrintProxyEnabled,
+ prefs::kCloudPrintProxyEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyTranslateEnabled, prefs::kEnableTranslate },
+ { Value::TYPE_BOOLEAN, kPolicyAllowOutdatedPlugins,
+ prefs::kPluginsAllowOutdated },
+ { Value::TYPE_BOOLEAN, kPolicyAlwaysAuthorizePlugins,
+ prefs::kPluginsAlwaysAuthorize },
+ { Value::TYPE_BOOLEAN, kPolicyBookmarkBarEnabled,
+ prefs::kShowBookmarkBar },
+ { Value::TYPE_BOOLEAN, kPolicyEditBookmarksEnabled,
+ prefs::kEditBookmarksEnabled },
+ { Value::TYPE_BOOLEAN, kPolicyAllowFileSelectionDialogs,
+ prefs::kAllowFileSelectionDialogs },
+ { Value::TYPE_BOOLEAN, kPolicyImportBookmarks,
+ prefs::kImportBookmarks},
+ { Value::TYPE_BOOLEAN, kPolicyImportHistory,
+ prefs::kImportHistory},
+ { Value::TYPE_BOOLEAN, kPolicyImportHomepage,
+ prefs::kImportHomepage},
+ { Value::TYPE_BOOLEAN, kPolicyImportSearchEngine,
+ prefs::kImportSearchEngine },
+ { Value::TYPE_BOOLEAN, kPolicyImportSavedPasswords,
+ prefs::kImportSavedPasswords },
+ { Value::TYPE_INTEGER, kPolicyMaxConnectionsPerProxy,
+ prefs::kMaxConnectionsPerProxy },
+ { Value::TYPE_BOOLEAN, kPolicyHideWebStorePromo,
+ prefs::kNTPHideWebStorePromo },
+ { Value::TYPE_LIST, kPolicyURLBlacklist,
+ prefs::kUrlBlacklist },
+ { Value::TYPE_LIST, kPolicyURLWhitelist,
+ prefs::kUrlWhitelist },
+
+#if defined(OS_CHROMEOS)
+ { Value::TYPE_BOOLEAN, kPolicyChromeOsLockOnIdleSuspend,
+ prefs::kEnableScreenLock },
+ { Value::TYPE_STRING, kPolicyChromeOsReleaseChannel,
+ prefs::kChromeOsReleaseChannel },
+#endif
+};
+
+// List of policy types to preference names, for policies affecting the default
+// search provider.
+const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[] = {
+ { Value::TYPE_BOOLEAN, kPolicyDefaultSearchProviderEnabled,
+ prefs::kDefaultSearchProviderEnabled },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderName,
+ prefs::kDefaultSearchProviderName },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderKeyword,
+ prefs::kDefaultSearchProviderKeyword },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderSearchURL,
+ prefs::kDefaultSearchProviderSearchURL },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderSuggestURL,
+ prefs::kDefaultSearchProviderSuggestURL },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderInstantURL,
+ prefs::kDefaultSearchProviderInstantURL },
+ { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
+ prefs::kDefaultSearchProviderIconURL },
+ { Value::TYPE_LIST, kPolicyDefaultSearchProviderEncodings,
+ prefs::kDefaultSearchProviderEncodings },
+};
+
+// List of entries determining which proxy policies can be specified, depending
+// on the ProxyMode.
+const ProxyModeValidationEntry kProxyModeValidationMap[] = {
+ { ProxyPrefs::kDirectProxyModeName,
+ false, false, false, IDS_POLICY_PROXY_MODE_DISABLED_ERROR },
+ { ProxyPrefs::kAutoDetectProxyModeName,
+ false, false, false, IDS_POLICY_PROXY_MODE_AUTO_DETECT_ERROR },
+ { ProxyPrefs::kPacScriptProxyModeName,
+ true, false, false, IDS_POLICY_PROXY_MODE_PAC_URL_ERROR },
+ { ProxyPrefs::kFixedServersProxyModeName,
+ false, true, true, IDS_POLICY_PROXY_MODE_FIXED_SERVERS_ERROR },
+ { ProxyPrefs::kSystemProxyModeName,
+ false, false, false, IDS_POLICY_PROXY_MODE_SYSTEM_ERROR },
+};
+
+
+// Helper functions ------------------------------------------------------------
+
+
+std::string ValueTypeToString(Value::Type type) {
+ static const char* strings[] = {
+ "null",
+ "boolean",
+ "integer",
+ "double",
+ "string",
+ "binary",
+ "dictionary",
+ "list"
+ };
+ DCHECK(static_cast<size_t>(type) < arraysize(strings));
+ return std::string(strings[type]);
+}
+
+
+// TypeCheckingPolicyHandler implementation ------------------------------------
+
+
+TypeCheckingPolicyHandler::TypeCheckingPolicyHandler(
+ ConfigurationPolicyType policy_type,
+ Value::Type value_type)
+ : policy_type_(policy_type),
+ value_type_(value_type) {
+}
+
+TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() {
+}
+
+ConfigurationPolicyType TypeCheckingPolicyHandler::policy_type() const {
+ return policy_type_;
+}
+
+bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) {
+ const Value* value = policies->Get(policy_type_);
+ if (value && value_type_ != value->GetType()) {
+ errors->AddError(policy_type_,
+ IDS_POLICY_TYPE_ERROR, ValueTypeToString(value_type_));
+ return false;
+ }
+ return true;
+}
+
+
+// SimplePolicyHandler implementation ------------------------------------------
+
+
+SimplePolicyHandler::SimplePolicyHandler(
+ ConfigurationPolicyType policy_type,
+ Value::Type value_type,
+ const char* pref_path)
+ : TypeCheckingPolicyHandler(policy_type, value_type),
+ pref_path_(pref_path) {
+}
+
+SimplePolicyHandler::~SimplePolicyHandler() {
+}
+
+void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* value = policies->Get(policy_type());
+ if (value)
+ prefs->SetValue(pref_path_, value->DeepCopy());
+}
+
+
+// SyncPolicyHandler implementation --------------------------------------------
+
+
+SyncPolicyHandler::SyncPolicyHandler()
+ : TypeCheckingPolicyHandler(kPolicySyncDisabled,
+ Value::TYPE_BOOLEAN) {
+}
+
+SyncPolicyHandler::~SyncPolicyHandler() {
+}
+
+void SyncPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* value = policies->Get(policy_type());
+ bool disable_sync;
+ if (value && value->GetAsBoolean(&disable_sync) && disable_sync)
+ prefs->SetValue(prefs::kSyncManaged, value->DeepCopy());
+}
+
+
+// AutofillPolicyHandler implementation ----------------------------------------
+
+
+AutofillPolicyHandler::AutofillPolicyHandler()
+ : TypeCheckingPolicyHandler(kPolicyAutoFillEnabled,
+ Value::TYPE_BOOLEAN) {
+}
+
+AutofillPolicyHandler::~AutofillPolicyHandler() {
+}
+
+void AutofillPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* value = policies->Get(policy_type());
+ bool auto_fill_enabled;
+ if (value && value->GetAsBoolean(&auto_fill_enabled) && !auto_fill_enabled) {
+ prefs->SetValue(prefs::kAutofillEnabled,
+ Value::CreateBooleanValue(false));
+ }
+}
+
+
+// DownloadDirPolicyHandler implementation -------------------------------------
+
+
+DownloadDirPolicyHandler::DownloadDirPolicyHandler()
+ : TypeCheckingPolicyHandler(kPolicyDownloadDirectory,
+ Value::TYPE_STRING) {
+}
+
+DownloadDirPolicyHandler::~DownloadDirPolicyHandler() {
+}
+
+void DownloadDirPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* value = policies->Get(policy_type());
+ FilePath::StringType string_value;
+ if (!value || !value->GetAsString(&string_value))
+ return;
+
+ FilePath::StringType expanded_value =
+ policy::path_parser::ExpandPathVariables(string_value);
+ // Make sure the path isn't empty, since that will point to an undefined
+ // location; the default location is used instead in that case.
+ // This is checked after path expansion because a non-empty policy value can
+ // lead to an empty path value after expansion (e.g. "\"\"").
+ if (expanded_value.empty())
+ expanded_value = download_util::GetDefaultDownloadDirectory().value();
+ prefs->SetValue(prefs::kDownloadDefaultDirectory,
+ Value::CreateStringValue(expanded_value));
+ prefs->SetValue(prefs::kPromptForDownload,
+ Value::CreateBooleanValue(false));
+}
+
+
+// DiskCacheDirPolicyHandler implementation ------------------------------------
+
+
+DiskCacheDirPolicyHandler::DiskCacheDirPolicyHandler()
+ : TypeCheckingPolicyHandler(kPolicyDiskCacheDir,
+ Value::TYPE_STRING) {
+}
+
+DiskCacheDirPolicyHandler::~DiskCacheDirPolicyHandler() {
+}
+
+void DiskCacheDirPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* value = policies->Get(policy_type());
+ FilePath::StringType string_value;
+ if (value && value->GetAsString(&string_value)) {
+ FilePath::StringType expanded_value =
+ policy::path_parser::ExpandPathVariables(string_value);
+ prefs->SetValue(prefs::kDiskCacheDir,
+ Value::CreateStringValue(expanded_value));
+ }
+}
+
+
+// FileSelectionDialogsHandler implementation ----------------------------------
+
+
+FileSelectionDialogsHandler::FileSelectionDialogsHandler()
+ : TypeCheckingPolicyHandler(kPolicyAllowFileSelectionDialogs,
+ Value::TYPE_BOOLEAN) {
+}
+
+FileSelectionDialogsHandler::~FileSelectionDialogsHandler() {
+}
+
+void FileSelectionDialogsHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ bool allow_dialogs;
+ const Value* value = policies->Get(policy_type());
+ if (value && value->GetAsBoolean(&allow_dialogs)) {
+ prefs->SetValue(prefs::kAllowFileSelectionDialogs,
+ Value::CreateBooleanValue(allow_dialogs));
+ // Disallow selecting the download location if file dialogs are disabled.
+ if (!allow_dialogs) {
+ prefs->SetValue(prefs::kPromptForDownload,
+ Value::CreateBooleanValue(false));
+ }
+ }
+}
+
+
+// IncognitoModePolicyHandler implementation -----------------------------------
+
+
+IncognitoModePolicyHandler::IncognitoModePolicyHandler() {
+}
+
+IncognitoModePolicyHandler::~IncognitoModePolicyHandler() {
+}
+
+bool IncognitoModePolicyHandler::CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) {
+ int int_value = IncognitoModePrefs::ENABLED;
+ const Value* availability = policies->Get(kPolicyIncognitoModeAvailability);
+
+ if (availability) {
+ if (availability->GetAsInteger(&int_value)) {
+ IncognitoModePrefs::Availability availability_enum_value;
+ if (!IncognitoModePrefs::IntToAvailability(int_value,
+ &availability_enum_value)) {
+ errors->AddError(kPolicyIncognitoModeAvailability,
+ IDS_POLICY_OUT_OF_RANGE_ERROR,
+ base::IntToString(int_value));
+ return false;
+ }
+ } else {
+ errors->AddError(kPolicyIncognitoModeAvailability,
+ IDS_POLICY_TYPE_ERROR,
+ ValueTypeToString(Value::TYPE_INTEGER));
+ return false;
+ }
+ } else {
+ const Value* deprecated_enabled = policies->Get(kPolicyIncognitoEnabled);
+ if (deprecated_enabled &&
+ !deprecated_enabled->IsType(Value::TYPE_BOOLEAN)) {
+ errors->AddError(kPolicyIncognitoEnabled,
+ IDS_POLICY_TYPE_ERROR,
+ ValueTypeToString(Value::TYPE_BOOLEAN));
+ return false;
+ }
+ }
+ return true;
+}
+
+void IncognitoModePolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* availability = policies->Get(kPolicyIncognitoModeAvailability);
+ const Value* deprecated_enabled = policies->Get(kPolicyIncognitoEnabled);
+ if (availability) {
+ int int_value = IncognitoModePrefs::ENABLED;
+ IncognitoModePrefs::Availability availability_enum_value;
+ if (availability->GetAsInteger(&int_value) &&
+ IncognitoModePrefs::IntToAvailability(int_value,
+ &availability_enum_value)) {
+ prefs->SetValue(prefs::kIncognitoModeAvailability,
+ Value::CreateIntegerValue(availability_enum_value));
+ } else {
+ NOTREACHED();
+ }
+ } else if (deprecated_enabled) {
+ // If kPolicyIncognitoModeAvailability is not specified, check the obsolete
+ // kPolicyIncognitoEnabled.
+ bool enabled = true;
+ if (deprecated_enabled->GetAsBoolean(&enabled)) {
+ prefs->SetInteger(prefs::kIncognitoModeAvailability,
+ enabled ? IncognitoModePrefs::ENABLED :
+ IncognitoModePrefs::DISABLED);
+ } else {
+ NOTREACHED();
+ }
+ }
+}
+
+
+// DefaultSearchEncodingsPolicyHandler implementation --------------------------
+
+
+DefaultSearchEncodingsPolicyHandler::DefaultSearchEncodingsPolicyHandler()
+ : TypeCheckingPolicyHandler(kPolicyDefaultSearchProviderEncodings,
+ Value::TYPE_LIST) {
+}
+
+DefaultSearchEncodingsPolicyHandler::~DefaultSearchEncodingsPolicyHandler() {
+}
+
+void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings(
+ const PolicyMap* policies, PrefValueMap* prefs) {
+ // The DefaultSearchProviderEncodings policy has type list, but the related
+ // preference has type string. Convert one into the other here, using
+ // ';' as a separator.
+ const Value* value = policies->Get(policy_type());
+ const ListValue* list;
+ if (!value || !value->GetAsList(&list))
+ return;
+
+ ListValue::const_iterator iter(list->begin());
+ ListValue::const_iterator end(list->end());
+ std::vector<std::string> string_parts;
+ for (; iter != end; ++iter) {
+ std::string s;
+ if ((*iter)->GetAsString(&s)) {
+ string_parts.push_back(s);
+ }
+ }
+ std::string encodings = JoinString(string_parts, ';');
+ prefs->SetValue(prefs::kDefaultSearchProviderEncodings,
+ Value::CreateStringValue(encodings));
+}
+
+
+// DefaultSearchPolicyHandler implementation -----------------------------------
+
+
+DefaultSearchPolicyHandler::DefaultSearchPolicyHandler() {
+ for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
+ ConfigurationPolicyType policy_type =
+ kDefaultSearchPolicyMap[i].policy_type;
+ if (policy_type == kPolicyDefaultSearchProviderEncodings) {
+ handlers_.push_back(new DefaultSearchEncodingsPolicyHandler());
+ } else {
+ handlers_.push_back(
+ new SimplePolicyHandler(policy_type,
+ kDefaultSearchPolicyMap[i].value_type,
+ kDefaultSearchPolicyMap[i].preference_path));
+ }
+ }
+}
+
+DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() {
+ STLDeleteElements(&handlers_);
+}
+
+bool DefaultSearchPolicyHandler::CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) {
+ if (!CheckIndividualPolicies(policies, errors))
+ return false;
+
+ if (DefaultSearchProviderIsDisabled(policies)) {
+ // Add an error for all specified default search policies except
+ // DefaultSearchProviderEnabled.
+ for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
+ ConfigurationPolicyType policy_type =
+ kDefaultSearchPolicyMap[i].policy_type;
+ if (policy_type != kPolicyDefaultSearchProviderEnabled &&
+ HasDefaultSearchPolicy(policies, policy_type)) {
+ errors->AddError(policy_type, IDS_POLICY_DEFAULT_SEARCH_DISABLED);
+ }
+ }
+ return true;
+ }
+
+ const Value* search_url =
+ policies->Get(kPolicyDefaultSearchProviderSearchURL);
+ if (!search_url && AnyDefaultSearchPoliciesSpecified(policies)) {
+ errors->AddError(kPolicyDefaultSearchProviderSearchURL,
+ IDS_POLICY_NOT_SPECIFIED_ERROR);
+ return false;
+ }
+
+ if (search_url && !DefaultSearchURLIsValid(policies)) {
+ errors->AddError(kPolicyDefaultSearchProviderSearchURL,
+ IDS_POLICY_INVALID_SEARCH_URL_ERROR);
+ return false;
+ }
+ return true;
+}
+
+void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ if (DefaultSearchProviderIsDisabled(policies)) {
+ // If default search is disabled, the other fields are ignored.
+ prefs->SetString(prefs::kDefaultSearchProviderName, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderSearchURL, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderIconURL, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderEncodings, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderKeyword, std::string());
+ prefs->SetString(prefs::kDefaultSearchProviderInstantURL, std::string());
+ return;
+ }
+
+ const Value* search_url =
+ policies->Get(kPolicyDefaultSearchProviderSearchURL);
+ // The search URL is required.
+ if (!search_url)
+ return;
+
+ // The other entries are optional. Just make sure that they are all
+ // specified via policy, so that the regular prefs aren't used.
+ if (DefaultSearchURLIsValid(policies)) {
+ PrefValueMap tmp_prefs;
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 Since we don't bail out here, we can just fill in
Joao da Silva 2011/10/11 15:09:23 Done.
+ HandlerList::const_iterator handler = handlers_.begin();
+ for ( ; handler != handlers_.end(); ++handler)
+ (*handler)->ApplyPolicySettings(policies, &tmp_prefs);
+
+ EnsureStringPrefExists(&tmp_prefs, prefs::kDefaultSearchProviderSuggestURL);
+ EnsureStringPrefExists(&tmp_prefs, prefs::kDefaultSearchProviderIconURL);
+ EnsureStringPrefExists(&tmp_prefs, prefs::kDefaultSearchProviderEncodings);
+ EnsureStringPrefExists(&tmp_prefs, prefs::kDefaultSearchProviderKeyword);
+ EnsureStringPrefExists(&tmp_prefs, prefs::kDefaultSearchProviderInstantURL);
+
+ // For the name, default to the host if not specified.
+ std::string name;
+ if (!tmp_prefs.GetString(prefs::kDefaultSearchProviderName, &name) ||
+ name.empty()) {
+ std::string search_url_string;
+ if (search_url->GetAsString(&search_url_string)) {
+ tmp_prefs.SetString(prefs::kDefaultSearchProviderName,
+ GURL(search_url_string).host());
+ }
+ }
+
+ // And clear the IDs since these are not specified via policy.
+ tmp_prefs.SetString(prefs::kDefaultSearchProviderID, std::string());
+ tmp_prefs.SetString(prefs::kDefaultSearchProviderPrepopulateID,
+ std::string());
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 indentation.
Joao da Silva 2011/10/11 15:09:23 Done.
+ prefs->MergeFrom(&tmp_prefs);
+ }
+}
+
+bool DefaultSearchPolicyHandler::CheckIndividualPolicies(
+ const PolicyMap* policies, PolicyErrorMap* errors) {
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 break after comma.
Joao da Silva 2011/10/11 15:09:23 Done.
+ HandlerList::const_iterator handler = handlers_.begin();
+ for ( ; handler != handlers_.end(); ++handler) {
+ if (!(*handler)->CheckPolicySettings(policies, errors))
+ return false;
+ }
+ return true;
+}
+
+bool DefaultSearchPolicyHandler::HasDefaultSearchPolicy(
+ const PolicyMap* policies, ConfigurationPolicyType policy_type) {
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 break after comma
Joao da Silva 2011/10/11 15:09:23 Done.
+ return policies->Get(policy_type) != NULL;
+}
+
+bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified(
+ const PolicyMap* policies) {
+ for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
+ if (policies->Get(kDefaultSearchPolicyMap[i].policy_type))
+ return true;
+ }
+ return false;
+}
+
+bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled(
+ const PolicyMap* policies) {
+ const Value* provider_enabled =
+ policies->Get(kPolicyDefaultSearchProviderEnabled);
+ bool enabled = true;
+ return provider_enabled &&
+ provider_enabled->GetAsBoolean(&enabled) &&
+ !enabled;
+}
+
+bool DefaultSearchPolicyHandler::DefaultSearchURLIsValid(
+ const PolicyMap* policies) {
+ const Value* search_url =
+ policies->Get(kPolicyDefaultSearchProviderSearchURL);
+ if (!search_url)
+ return false;
+
+ std::string search_url_string;
+ if (search_url->GetAsString(&search_url_string)) {
+ SearchTermsDataForValidation search_terms_data;
+ const TemplateURLRef search_url_ref(search_url_string, 0, 0);
+ // It must support replacement (which implies it is valid).
+ return search_url_ref.SupportsReplacementUsingTermsData(search_terms_data);
+ }
+ return false;
+}
+
+void DefaultSearchPolicyHandler::EnsureStringPrefExists(
+ PrefValueMap* prefs, const std::string& path) {
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 break after comma
Joao da Silva 2011/10/11 15:09:23 Done.
+ std::string value;
+ if (!prefs->GetString(path, &value))
+ prefs->SetString(path, value);
+}
+
+
+// ProxyPolicyHandler implementation -------------------------------------------
+
+
+ProxyPolicyHandler::ProxyPolicyHandler() {
+}
+
+ProxyPolicyHandler::~ProxyPolicyHandler() {
+}
+
+bool ProxyPolicyHandler::CheckPolicySettings(const PolicyMap* policies,
+ PolicyErrorMap* errors) {
+ const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
+ const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+ const Value* server_mode =
+ GetProxyPolicyValue(policies, kPolicyProxyServerMode);
+ const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+ const Value* bypass_list =
+ GetProxyPolicyValue(policies, kPolicyProxyBypassList);
+
+ if ((server || pac_url || bypass_list) && !(mode || server_mode)) {
+ errors->AddError(kPolicyProxyMode,
+ IDS_POLICY_NOT_SPECIFIED_ERROR);
+ return false;
+ }
+
+ std::string mode_value;
+ if (!CheckProxyModeAndServerMode(policies, errors, &mode_value))
+ return false;
+
+ // If neither ProxyMode nor ProxyServerMode are specified, mode_value will be
+ // empty and the proxy shouldn't be configured at all.
Mattias Nissler (ping if slow) 2011/10/11 11:10:57 Maybe we should check other proxy policies and add
Joao da Silva 2011/10/11 15:09:23 Line 1019 above checks and reports that.
Mattias Nissler (ping if slow) 2011/10/12 17:10:00 I see.
+ if (mode_value.empty())
+ return true;
+
+ bool is_valid_mode = false;
+ for (size_t i = 0; i != arraysize(kProxyModeValidationMap); ++i) {
+ const ProxyModeValidationEntry& entry = kProxyModeValidationMap[i];
+ if (entry.mode_value != mode_value)
+ continue;
+
+ is_valid_mode = true;
+
+ if (!entry.pac_url_allowed && pac_url)
+ errors->AddError(kPolicyProxyPacUrl, entry.error_message_id);
+ if (!entry.bypass_list_allowed && bypass_list)
+ errors->AddError(kPolicyProxyPacUrl, entry.error_message_id);
+ if (!entry.server_allowed && server)
+ errors->AddError(kPolicyProxyPacUrl, entry.error_message_id);
+
+ if ((!entry.pac_url_allowed && pac_url) ||
+ (!entry.bypass_list_allowed && bypass_list) ||
+ (!entry.server_allowed && server)) {
+ return false;
+ }
+ }
+
+ if (!is_valid_mode) {
+ errors->AddError(mode ? kPolicyProxyMode : kPolicyProxyServerMode,
+ IDS_POLICY_OUT_OF_RANGE_ERROR, mode_value);
+ return false;
+ }
+ return true;
+}
+
+void ProxyPolicyHandler::ApplyPolicySettings(const PolicyMap* policies,
+ PrefValueMap* prefs) {
+ const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
+ const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+ const Value* server_mode =
+ GetProxyPolicyValue(policies, kPolicyProxyServerMode);
+ const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+ const Value* bypass_list =
+ GetProxyPolicyValue(policies, kPolicyProxyBypassList);
+
+ ProxyPrefs::ProxyMode proxy_mode;
+ if (mode) {
+ std::string string_mode;
+ CHECK(mode->GetAsString(&string_mode));
+ CHECK(ProxyPrefs::StringToProxyMode(string_mode, &proxy_mode));
+ } else if (server_mode) {
+ int int_mode = 0;
+ CHECK(server_mode->GetAsInteger(&int_mode));
+
+ switch (int_mode) {
+ case kPolicyNoProxyServerMode:
+ proxy_mode = ProxyPrefs::MODE_DIRECT;
+ break;
+ case kPolicyAutoDetectProxyServerMode:
+ proxy_mode = ProxyPrefs::MODE_AUTO_DETECT;
+ break;
+ case kPolicyManuallyConfiguredProxyServerMode:
+ proxy_mode = ProxyPrefs::MODE_FIXED_SERVERS;
+ if (pac_url)
+ proxy_mode = ProxyPrefs::MODE_PAC_SCRIPT;
+ break;
+ case kPolicyUseSystemProxyServerMode:
+ proxy_mode = ProxyPrefs::MODE_SYSTEM;
+ break;
+ default:
+ proxy_mode = ProxyPrefs::MODE_DIRECT;
+ NOTREACHED();
+ }
+ } else {
+ return;
+ }
+
+ switch (proxy_mode) {
+ case ProxyPrefs::MODE_DIRECT:
+ prefs->SetValue(prefs::kProxy, ProxyConfigDictionary::CreateDirect());
+ break;
+ case ProxyPrefs::MODE_AUTO_DETECT:
+ prefs->SetValue(prefs::kProxy, ProxyConfigDictionary::CreateAutoDetect());
+ break;
+ case ProxyPrefs::MODE_PAC_SCRIPT: {
+ std::string pac_url_string;
+ if (pac_url->GetAsString(&pac_url_string)) {
+ prefs->SetValue(prefs::kProxy,
+ ProxyConfigDictionary::CreatePacScript(pac_url_string, false));
+ } else {
+ NOTREACHED();
+ }
+ break;
+ }
+ case ProxyPrefs::MODE_FIXED_SERVERS: {
+ std::string proxy_server;
+ std::string bypass_list_string;
+ if (server->GetAsString(&proxy_server)) {
+ if (bypass_list)
+ bypass_list->GetAsString(&bypass_list_string);
+ prefs->SetValue(prefs::kProxy,
+ ProxyConfigDictionary::CreateFixedServers(
+ proxy_server, bypass_list_string));
+ }
+ break;
+ }
+ case ProxyPrefs::MODE_SYSTEM:
+ prefs->SetValue(prefs::kProxy,
+ ProxyConfigDictionary::CreateSystem());
+ break;
+ case ProxyPrefs::kModeCount:
+ NOTREACHED();
+ }
+}
+
+const Value* ProxyPolicyHandler::GetProxyPolicyValue(
+ const PolicyMap* policies, ConfigurationPolicyType policy) {
+ const Value* value = policies->Get(policy);
+ std::string tmp;
+ if (!value ||
+ value->IsType(Value::TYPE_NULL) ||
+ (value->IsType(Value::TYPE_STRING) &&
+ value->GetAsString(&tmp) &&
+ tmp.empty())) {
+ return NULL;
+ }
+ return value;
+}
+
+bool ProxyPolicyHandler::CheckProxyModeAndServerMode(const PolicyMap* policies,
+ PolicyErrorMap* errors,
+ std::string* mode_value) {
+ const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
+ const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+ const Value* server_mode =
+ GetProxyPolicyValue(policies, kPolicyProxyServerMode);
+ const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+
+ // If there's a server mode, convert it into a mode.
+ // When both are specified, the mode takes precedence.
+ if (mode) {
+ if (server_mode) {
+ errors->AddError(kPolicyProxyServerMode,
+ IDS_POLICY_PROXY_SERVER_MODE_IGNORED);
+ }
+ if (!mode->GetAsString(mode_value)) {
+ errors->AddError(kPolicyProxyMode, IDS_POLICY_TYPE_ERROR,
+ ValueTypeToString(Value::TYPE_BOOLEAN));
+ return false;
+ }
+
+ ProxyPrefs::ProxyMode mode;
+ if (!ProxyPrefs::StringToProxyMode(*mode_value, &mode)) {
+ errors->AddError(kPolicyProxyMode, IDS_POLICY_INVALID_PROXY_MODE_ERROR);
+ return false;
+ }
+
+ if (mode == ProxyPrefs::MODE_PAC_SCRIPT && !pac_url) {
+ errors->AddError(kPolicyProxyPacUrl, IDS_POLICY_NOT_SPECIFIED_ERROR);
+ return false;
+ } else if (mode == ProxyPrefs::MODE_FIXED_SERVERS && !server) {
+ errors->AddError(kPolicyProxyServer, IDS_POLICY_NOT_SPECIFIED_ERROR);
+ return false;
+ }
+ } else if (server_mode) {
+ int server_mode_value;
+ if (!server_mode->GetAsInteger(&server_mode_value)) {
+ errors->AddError(kPolicyProxyServerMode, IDS_POLICY_TYPE_ERROR,
+ ValueTypeToString(Value::TYPE_INTEGER));
+ return false;
+ }
+
+ switch (server_mode_value) {
+ case kPolicyNoProxyServerMode:
+ *mode_value = ProxyPrefs::kDirectProxyModeName;
+ break;
+ case kPolicyAutoDetectProxyServerMode:
+ *mode_value = ProxyPrefs::kAutoDetectProxyModeName;
+ break;
+ case kPolicyManuallyConfiguredProxyServerMode:
+ if (server && pac_url) {
+ int message_id = IDS_POLICY_PROXY_BOTH_SPECIFIED_ERROR;
+ errors->AddError(kPolicyProxyServer, message_id);
+ errors->AddError(kPolicyProxyPacUrl, message_id);
+ return false;
+ }
+ if (!server && !pac_url) {
+ int message_id = IDS_POLICY_PROXY_NEITHER_SPECIFIED_ERROR;
+ errors->AddError(kPolicyProxyServer, message_id);
+ errors->AddError(kPolicyProxyPacUrl, message_id);
+ return false;
+ }
+ if (pac_url)
+ *mode_value = ProxyPrefs::kPacScriptProxyModeName;
+ else
+ *mode_value = ProxyPrefs::kFixedServersProxyModeName;
+ break;
+ case kPolicyUseSystemProxyServerMode:
+ *mode_value = ProxyPrefs::kSystemProxyModeName;
+ break;
+ default:
+ errors->AddError(kPolicyProxyServerMode, IDS_POLICY_OUT_OF_RANGE_ERROR,
+ base::IntToString(server_mode_value));
+ return false;
+ }
+ }
+ return true;
+}
+
+
+} // namespace
+
+
+// ConfigurationPolicyHandler implementation -----------------------------------
+
+
+// static
+ConfigurationPolicyHandler::HandlerList*
+ ConfigurationPolicyHandler::CreateHandlerList() {
+ HandlerList* list = new HandlerList;
+
+ for (size_t i = 0; i < arraysize(kSimplePolicyMap); ++i) {
+ list->push_back(
+ new SimplePolicyHandler(kSimplePolicyMap[i].policy_type,
+ kSimplePolicyMap[i].value_type,
+ kSimplePolicyMap[i].preference_path));
+ }
+ list->push_back(new SyncPolicyHandler());
+ list->push_back(new AutofillPolicyHandler());
+
+#if !defined(OS_CHROMEOS)
+ list->push_back(new DownloadDirPolicyHandler());
+#endif // !defined(OS_CHROME0S)
+
+ list->push_back(new DiskCacheDirPolicyHandler());
+ list->push_back(new FileSelectionDialogsHandler());
+ list->push_back(new ProxyPolicyHandler());
+ list->push_back(new IncognitoModePolicyHandler());
+ list->push_back(new DefaultSearchPolicyHandler());
+
+ return list;
+}
+
+} // namespace policy
« chrome/browser/policy/configuration_policy_handler.h ('K') | « chrome/browser/policy/configuration_policy_handler.h ('k') | chrome/browser/policy/configuration_policy_pref_store.h » ('j') | chrome/browser/policy/configuration_policy_pref_store.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698