Add revocation metrics from OIB and content setting

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 12 matching lines @@
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/web_site_settings_uma_util.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
+#include "chrome/browser/permissions/permission_uma_util.h"
+#include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/webui/site_settings_helper.h"
 #include "chrome/browser/usb/usb_chooser_context.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
@@ skipping 740 matching lines @@
 
     UpdateFlashMediaLinksVisibility(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
     UpdateFlashMediaLinksVisibility(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
   }
 }
 
 void ContentSettingsHandler::UpdateSettingDefaultFromModel(
     ContentSettingsType type) {
   std::string provider_id;
   ContentSetting default_setting =
-      GetContentSettingsMap()->GetDefaultContentSetting(type, &provider_id);
+      HostContentSettingsMapFactory::GetForProfile(GetProfile())
+          ->GetDefaultContentSetting(type, &provider_id);
 
 #if defined(ENABLE_PLUGINS)
   default_setting =
       content_settings::PluginsFieldTrial::EffectiveContentSetting(
           type, default_setting);
 #endif
 
   // Camera and microphone default content settings cannot be set by the policy.
   // However, the policy can disable them. Treat this case visually in the same
   // way as if the policy set the default setting to BLOCK. Furthermore, compare
@@ skipping 21 matching lines @@
       site_settings::ContentSettingsTypeToGroupName(type) + ".managedBy",
       provider_id);
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
 }
 
 void ContentSettingsHandler::UpdateMediaSettingsFromPrefs(
     ContentSettingsType type) {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(GetProfile());
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
   std::string policy_pref = (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
       ? prefs::kAudioCaptureAllowed
       : prefs::kVideoCaptureAllowed;
 
   settings.policy_disable = !prefs->GetBoolean(policy_pref) &&
       prefs->IsManagedPreference(policy_pref);
   settings.default_setting =
-      GetContentSettingsMap()->GetDefaultContentSetting(type, NULL);
+      settings_map->GetDefaultContentSetting(type, nullptr);
   settings.default_setting_initialized = true;
 
   UpdateFlashMediaLinksVisibility(type);
   UpdateMediaDeviceDropdownVisibility(type);
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
   base::FundamentalValue handlers_enabled(
       GetProtocolHandlerRegistry()->enabled());
 
@@ skipping 146 matching lines @@
                                          type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
 void ContentSettingsHandler::CompareMediaExceptionsWithFlash(
     ContentSettingsType type) {
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(GetProfile());
 
   base::ListValue exceptions;
-  site_settings::GetExceptionsFromHostContentSettingsMap(
-      GetContentSettingsMap(),
-      type,
-      web_ui(),
-      &exceptions);
+  site_settings::GetExceptionsFromHostContentSettingsMap(settings_map, type,
+                                                         web_ui(), &exceptions);
 
   settings.exceptions.clear();
   for (base::ListValue::const_iterator entry = exceptions.begin();
        entry != exceptions.end(); ++entry) {
     base::DictionaryValue* dict = nullptr;
     bool valid_dict = (*entry)->GetAsDictionary(&dict);
     DCHECK(valid_dict);
 
     std::string origin;
     std::string setting;
@@ skipping 117 matching lines @@
   }
 
   base::StringValue type_string(kZoomContentType);
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
                                          type_string, zoom_levels_exceptions);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   base::ListValue exceptions;
-  site_settings::GetExceptionsFromHostContentSettingsMap(
-      GetContentSettingsMap(), type, web_ui(), &exceptions);
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(GetProfile());
+  site_settings::GetExceptionsFromHostContentSettingsMap(settings_map, type,
+                                                         web_ui(), &exceptions);
   base::StringValue type_string(
       site_settings::ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
 
                                          type_string, exceptions);
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
 
   // Fullscreen and mouse lock have no global settings to update.
   // TODO(mgiuca): Delete this after removing these content settings entirely
   // (https://crbug.com/591896).
   if (type == CONTENT_SETTINGS_TYPE_FULLSCREEN ||
       type == CONTENT_SETTINGS_TYPE_MOUSELOCK) {
     return;
   }
 
 #if defined(OS_CHROMEOS)
   // Also the default for protected contents is managed in another place.
   if (type == CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER)
     return;
 #endif
 
   // The default may also have changed (we won't get a separate notification).
   // If it hasn't changed, this call will be harmless.
   UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
-  const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
+  const HostContentSettingsMap* otr_settings_map =
+      HostContentSettingsMapFactory::GetForProfile(GetOTRProfile());
   if (!otr_settings_map)
     return;
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       otr_settings_map, type, web_ui(), &exceptions);
   base::StringValue type_string(
       site_settings::ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setOTRExceptions",
                                          type_string, exceptions);
 }
@@ skipping 94 matching lines @@
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
   DCHECK(rv);
 
   // The fourth argument to this handler is optional.
-  std::string secondary_pattern;
+  std::string secondary_pattern_string;
   if (args->GetSize() >= 4U) {
-    rv = args->GetString(3, &secondary_pattern);
+    rv = args->GetString(3, &secondary_pattern_string);
     DCHECK(rv);
   }
 
+  Profile* profile = mode == "normal" ? GetProfile() : GetOTRProfile();
+  if (!profile)
+    return;
+
   HostContentSettingsMap* settings_map =
-      mode == "normal" ? GetContentSettingsMap() :
-                         GetOTRContentSettingsMap();
-  if (settings_map) {
-    settings_map->SetContentSettingCustomScope(
-        ContentSettingsPattern::FromString(pattern),
-        secondary_pattern.empty()
-            ? ContentSettingsPattern::Wildcard()
-            : ContentSettingsPattern::FromString(secondary_pattern),
-        type, std::string(), CONTENT_SETTING_DEFAULT);
-  }
+      HostContentSettingsMapFactory::GetForProfile(profile);
+  ContentSettingsPattern primary_pattern =
+      ContentSettingsPattern::FromString(pattern);
+  ContentSettingsPattern secondary_pattern =
+      secondary_pattern_string.empty()
+          ? ContentSettingsPattern::Wildcard()
+          : ContentSettingsPattern::FromString(secondary_pattern_string);
+  PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
+      profile, primary_pattern, secondary_pattern, type,
+      PermissionSourceUI::SITE_SETTINGS);
+
+  settings_map->SetContentSettingCustomScope(
+      primary_pattern, secondary_pattern, type, std::string(),
+      CONTENT_SETTING_DEFAULT);
 }
 
 void ContentSettingsHandler::RemoveZoomLevelException(
     const base::ListValue* args) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
@@ skipping 129 matching lines @@
   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 =
       site_settings::ContentSettingsTypeFromGroupName(type_string);
 
-  if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
-      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
-      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
-    NOTREACHED();
-  } else {
-    HostContentSettingsMap* settings_map =
-        mode == "normal" ? GetContentSettingsMap() :
-                           GetOTRContentSettingsMap();
+  DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION &&
+         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
+         type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 
-    // 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;
+  Profile* profile = mode == "normal" ? GetProfile() : GetOTRProfile();
 
-    ContentSetting setting_type;
-    bool result =
-        content_settings::ContentSettingFromString(setting, &setting_type);
-    DCHECK(result);
+  // The profile could be nullptr if the mode was OTR but the OTR profile
+  // got destroyed before we received this message.
+  if (!profile)
+    return;
 
-    settings_map->SetContentSettingCustomScope(
-        ContentSettingsPattern::FromString(pattern),
-        ContentSettingsPattern::Wildcard(), type, std::string(), setting_type);
-    WebSiteSettingsUmaUtil::LogPermissionChange(type, setting_type);
-  }
+  ContentSetting setting_type;
+  bool result =
+      content_settings::ContentSettingFromString(setting, &setting_type);
+  DCHECK(result);
+
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(profile);
+
+  PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
+      profile, ContentSettingsPattern::FromString(pattern),
+      ContentSettingsPattern::Wildcard(), type,
+      PermissionSourceUI::SITE_SETTINGS);
+
+  settings_map->SetContentSettingCustomScope(
+      ContentSettingsPattern::FromString(pattern),
+      ContentSettingsPattern::Wildcard(), type, std::string(), setting_type);
+  WebSiteSettingsUmaUtil::LogPermissionChange(type, setting_type);
 }
 
 void ContentSettingsHandler::CheckExceptionPatternValidity(
     const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
   std::string mode_string;
   CHECK(args->GetString(1, &mode_string));
   std::string pattern_string;
   CHECK(args->GetString(2, &pattern_string));
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString(pattern_string);
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.patternValidityCheckComplete",
       base::StringValue(type_string), base::StringValue(mode_string),
       base::StringValue(pattern_string),
       base::FundamentalValue(pattern.IsValid()));
 }
 
-HostContentSettingsMap* ContentSettingsHandler::GetContentSettingsMap() {
-  return HostContentSettingsMapFactory::GetForProfile(
-      Profile::FromWebUI(web_ui()));
+Profile* ContentSettingsHandler::GetProfile() {
+  return Profile::FromWebUI(web_ui());
 }
 
 ProtocolHandlerRegistry* ContentSettingsHandler::GetProtocolHandlerRegistry() {
   return ProtocolHandlerRegistryFactory::GetForBrowserContext(
       GetBrowserContext(web_ui()));
 }
 
-HostContentSettingsMap*
-    ContentSettingsHandler::GetOTRContentSettingsMap() {
-  Profile* profile = Profile::FromWebUI(web_ui());
-  if (profile->HasOffTheRecordProfile())
-    return HostContentSettingsMapFactory::GetForProfile(
-        profile->GetOffTheRecordProfile());
-  return NULL;
+Profile* ContentSettingsHandler::GetOTRProfile() {
+  return GetProfile()->HasOffTheRecordProfile()
+             ? GetProfile()->GetOffTheRecordProfile()
+             : nullptr;
 }
 
 void ContentSettingsHandler::RefreshFlashMediaSettings() {
   MediaSettingsInfo::ForFlash& settings = media_settings_->forFlash();
   settings.initialized = false;
 
   settings.last_refresh_request_id =
       flash_settings_manager_->GetPermissionSettings(
           PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC);
 }
@@ skipping 107 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()->CallJavascriptFunctionUnsafe(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options