[Policy Experimental] Add "recommended" policies for URL exceptions.

components/content_settings/core/browser/content_settings_policy_provider.cc

Index: components/content_settings/core/browser/content_settings_policy_provider.cc
diff --git a/components/content_settings/core/browser/content_settings_policy_provider.cc b/components/content_settings/core/browser/content_settings_policy_provider.cc
index d8d1b831e6139ad04347a859550e20777ed3d101..3c0ccbfbe6915be839a7ee0c7123b8fb88daf3c0 100644
--- a/components/content_settings/core/browser/content_settings_policy_provider.cc
+++ b/components/content_settings/core/browser/content_settings_policy_provider.cc
@@ -18,6 +18,7 @@
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
+#include "components/prefs/pref_value_store.h"
 
 namespace {
 
@@ -136,11 +137,17 @@ void PolicyProvider::RegisterProfilePrefs(
                                 CONTENT_SETTING_DEFAULT);
 }
 
-PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
+PolicyProvider::PolicyProvider(PrefService* prefs)
+    : PolicyProvider(prefs, false) {
+}
+
+PolicyProvider::PolicyProvider(PrefService* prefs, bool want_recommended)
+    : prefs_(prefs), want_recommended_(want_recommended) {
   ReadManagedDefaultSettings();
   ReadManagedContentSettings(false);
 
   pref_change_registrar_.Init(prefs_);
+
   PrefChangeRegistrar::NamedChangeCallback callback =
       base::Bind(&PolicyProvider::OnPreferenceChanged, base::Unretained(this));
   pref_change_registrar_.Add(
@@ -201,18 +208,16 @@ void PolicyProvider::GetContentSettingsFromPreferences(
     OriginIdentifierValueMap* value_map) {
   for (size_t i = 0; i < arraysize(kPrefsForManagedContentSettingsMap); ++i) {
     const char* pref_name = kPrefsForManagedContentSettingsMap[i].pref_name;
+    const base::Value* value = GetWantedPreferenceValue(pref_name);
+
     // Skip unset policies.
-    if (!prefs_->HasPrefPath(pref_name)) {
+    if (!value) {
       VLOG(2) << "Skipping unset preference: " << pref_name;
       continue;
     }
 
-    const PrefService::Preference* pref = prefs_->FindPreference(pref_name);
-    DCHECK(pref);
-    DCHECK(pref->IsManaged());
-
     const base::ListValue* pattern_str_list = nullptr;
-    if (!pref->GetValue()->GetAsList(&pattern_str_list)) {
+    if (!value->GetAsList(&pattern_str_list)) {
       NOTREACHED();
       return;
     }
@@ -250,18 +255,15 @@ void PolicyProvider::GetContentSettingsFromPreferences(
 void PolicyProvider::GetAutoSelectCertificateSettingsFromPreferences(
     OriginIdentifierValueMap* value_map) {
   const char* pref_name = prefs::kManagedAutoSelectCertificateForUrls;
+  const base::Value* value = GetWantedPreferenceValue(pref_name);
 
-  if (!prefs_->HasPrefPath(pref_name)) {
+  if (!value) {
     VLOG(2) << "Skipping unset preference: " << pref_name;
     return;
   }
 
-  const PrefService::Preference* pref = prefs_->FindPreference(pref_name);
-  DCHECK(pref);
-  DCHECK(pref->IsManaged());
-
   const base::ListValue* pattern_filter_str_list = nullptr;
-  if (!pref->GetValue()->GetAsList(&pattern_filter_str_list)) {
+  if (value->GetAsList(&pattern_filter_str_list)) {
     NOTREACHED();
     return;
   }
@@ -331,6 +333,16 @@ void PolicyProvider::GetAutoSelectCertificateSettingsFromPreferences(
   }
 }
 
+const base::Value* PolicyProvider::GetWantedPreferenceValue(
+    const char* pref_name) const {
+  const PrefService::Preference* pref = prefs_->FindPreference(pref_name);
+  if (!pref)
+    return nullptr;
+
+  return want_recommended_ ?
+      pref->GetRecommendedValue() : pref->GetManagedValue();
+}
+
 void PolicyProvider::ReadManagedDefaultSettings() {
   for (const PrefsForManagedDefaultMapEntry& entry : kPrefsForManagedDefault)
     UpdateManagedDefaultSetting(entry);
@@ -339,24 +351,31 @@ void PolicyProvider::ReadManagedDefaultSettings() {
 void PolicyProvider::UpdateManagedDefaultSetting(
     const PrefsForManagedDefaultMapEntry& entry) {
   // If a pref to manage a default-content-setting was not set (NOTICE:
-  // "HasPrefPath" returns false if no value was set for a registered pref) then
-  // the default value of the preference is used. The default value of a
-  // preference to manage a default-content-settings is CONTENT_SETTING_DEFAULT.
-  // This indicates that no managed value is set. If a pref was set, than it
-  // MUST be managed.
-  DCHECK(!prefs_->HasPrefPath(entry.pref_name) ||
-         prefs_->IsManagedPreference(entry.pref_name));
+  // GetWantedPreferenceValue() returns null if the wanted value was not set
+  // for a registered pref) then the default value of the preference is used.
+  // The default value of a preference to manage a default-content-settings is
+  // CONTENT_SETTING_DEFAULT. This indicates that no managed value is set.
+  int setting = CONTENT_SETTING_DEFAULT;
+  const base::Value* value = GetWantedPreferenceValue(entry.pref_name);
+  if (value && value->IsType(base::Value::TYPE_INTEGER)) {
+    bool result = value->GetAsInteger(&setting);
+    DCHECK(result);
+    // |setting| can still be CONTENT_SETTING_DEFAULT.
+  }
+
   base::AutoLock auto_lock(lock_);
 
-  int setting = prefs_->GetInteger(entry.pref_name);
   if (setting == CONTENT_SETTING_DEFAULT) {
     value_map_.DeleteValue(ContentSettingsPattern::Wildcard(),
                            ContentSettingsPattern::Wildcard(),
-                           entry.content_type, std::string());
+                           entry.content_type,
+                           std::string());
   } else {
     value_map_.SetValue(ContentSettingsPattern::Wildcard(),
-                        ContentSettingsPattern::Wildcard(), entry.content_type,
-                        std::string(), new base::FundamentalValue(setting));
+                        ContentSettingsPattern::Wildcard(),
+                        entry.content_type,
+                        std::string(),
+                        new base::FundamentalValue(setting));
   }
 }