[Chrome Settings UI] If User Exceptions are not allowed, prevent editing / viewing.

chrome/browser/ui/webui/options/content_settings_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/ui/webui/options/content_settings_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 860 matching lines @@
       content_settings::ContentSettingToString(default_setting);
   DCHECK(!setting_string.empty());
 
   filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
                             setting_string);
   filter_settings.SetString(
       ContentSettingsTypeToGroupName(type) + ".managedBy", provider_id);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
+
+  // We assume that special cases covered above to get |provider_id| are not
+  // needed in AreUserExceptionsAllowedForType().
+  bool maybe_enable_exceptions =
+      GetContentSettingsMap()->AreUserExceptionsAllowedForType(type);
+
+  web_ui()->CallJavascriptFunction(
+      "ContentSettings.setUserExceptionsAllowed",
+      base::StringValue(ContentSettingsTypeToGroupName(type)),
+      base::FundamentalValue(maybe_enable_exceptions));
 }
 
 void ContentSettingsHandler::UpdateMediaSettingsFromPrefs(
     ContentSettingsType type) {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
   std::string policy_pref = (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
       ? prefs::kAudioCaptureAllowed
       : prefs::kVideoCaptureAllowed;
 
@@ skipping 65 matching lines @@
       std::string(),
       &all_settings);
 
   // Group geolocation settings by primary_pattern.
   site_settings::AllPatternsSettings all_patterns_settings;
   for (ContentSettingsForOneType::iterator i = all_settings.begin();
        i != all_settings.end(); ++i) {
     // Don't add default settings.
     if (i->primary_pattern == ContentSettingsPattern::Wildcard() &&
         i->secondary_pattern == ContentSettingsPattern::Wildcard() &&
-        i
-          ->source != site_settings::kPreferencesSource) {
+        i->source != site_settings::kPreferencesSource) {
       continue;
     }
     all_patterns_settings[std::make_pair(i->primary_pattern, i->source)]
         [i->secondary_pattern] = i->setting;
   }
 
   base::ListValue exceptions;
   AddExceptionsGrantedByHostedApps(
       profile,
       HostedAppHasPermission<APIPermission::kGeolocation>,
@@ skipping 490 matching lines @@
   const ExceptionsInfoMap& exceptions_info_map = GetExceptionsInfoMap();
   const auto& it = exceptions_info_map.find(content_type);
   if (it != exceptions_info_map.end())
     content::RecordAction(it->second.uma);
 }
 
 void ContentSettingsHandler::RemoveException(const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
 
+  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
+
+  // If user exceptions are disabled for |type|, don't remove.
+  if (!GetContentSettingsMap()->AreUserExceptionsAllowedForType(type))
+    return;
+
   // Zoom levels are no actual content type so we need to handle them
   // separately. They would not be recognized by
   // ContentSettingsTypeFromGroupName.
   if (type_string == kZoomContentType) {
     RemoveZoomLevelException(args);
     return;
   }
 
   const ChooserTypeNameEntry* chooser_type =
       ChooserTypeFromGroupName(type_string);
   if (chooser_type) {
     RemoveChooserException(chooser_type, args);
     return;
   }
 
-  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   RemoveExceptionFromHostContentSettingsMap(args, type);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(
       type, ContentSetting::CONTENT_SETTING_DEFAULT);
 }
 
 void ContentSettingsHandler::SetException(const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
   std::string mode;
   CHECK(args->GetString(1, &mode));
   std::string pattern;
   CHECK(args->GetString(2, &pattern));
   std::string setting;
   CHECK(args->GetString(3, &setting));
 
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
 
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
       type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
       type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
     NOTREACHED();
   } else {
+    // If user exceptions are disabled for |type|, don't set.
+    if (!GetContentSettingsMap()->AreUserExceptionsAllowedForType(type))
+      return;
+
     HostContentSettingsMap* settings_map =
         mode == "normal" ? GetContentSettingsMap() :
                            GetOTRContentSettingsMap();
 
     // The settings map could be null if the mode was OTR but the OTR profile
     // got destroyed before we received this message.
     if (!settings_map)
       return;
 
     ContentSetting setting_type;
@@ skipping 178 matching lines @@
 
   // Exceptions apply only when the feature is enabled.
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options