Split the Media settings UI into separate microphone and camera sections.

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 <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 71 matching lines @@
 // The AppFilter is used in AddExceptionsGrantedByHostedApps() to choose
 // extensions which should have their extent displayed.
 typedef bool (*AppFilter)(const extensions::Extension& app,
                           content::BrowserContext* profile);
 
 const char kExceptionsLearnMoreUrl[] =
     "https://support.google.com/chrome/?p=settings_manage_exceptions";
 
 const char kSetting[] = "setting";
 const char kOrigin[] = "origin";
+const char kPolicyProviderId[] = "policy";
 const char kSource[] = "source";
 const char kAppName[] = "appName";
 const char kAppId[] = "appId";
 const char kEmbeddingOrigin[] = "embeddingOrigin";
 const char kPreferencesSource[] = "preference";
 const char kVideoSetting[] = "video";
 const char kZoom[] = "zoom";
 
 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
   {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
   {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
   {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
   {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
   {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
   {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
   {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
   {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
   {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
   {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
   {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, "register-protocol-handler"},
-  // The MEDIASTREAM content setting is deprecated, but the settings for
-  // microphone and camera still live in the part of UI labeled "media-stream".
-  // TODO(msramek): Clean this up once we have a new UI for media.
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM, "media-stream"},
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream"},
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream"},
+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream-mic"},
+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"},
   {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, "ppapi-broker"},
   {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, "multiple-automatic-downloads"},
   {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, "midi-sysex"},
   {CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, "push-messaging"},
   {CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS, "ssl-cert-decisions"},
 #if defined(OS_CHROMEOS)
   {CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, "protectedContent"},
 #endif
 };
 
@@ skipping 224 matching lines @@
     {"mouselockAllow", IDS_MOUSE_LOCK_ALLOW_RADIO},
     {"mouselockAsk", IDS_MOUSE_LOCK_ASK_RADIO},
     {"mouselockBlock", IDS_MOUSE_LOCK_BLOCK_RADIO},
 #if defined(OS_CHROMEOS) || defined(OS_WIN)
     // Protected Content filter
     {"protectedContentTabLabel", IDS_PROTECTED_CONTENT_TAB_LABEL},
     {"protectedContentInfo", IDS_PROTECTED_CONTENT_INFO},
     {"protectedContentEnable", IDS_PROTECTED_CONTENT_ENABLE},
     {"protectedContentHeader", IDS_PROTECTED_CONTENT_HEADER},
 #endif  // defined(OS_CHROMEOS) || defined(OS_WIN)
-    // Media stream capture device filter.
-    {"mediaStreamTabLabel", IDS_MEDIA_STREAM_TAB_LABEL},
-    {"mediaStreamHeader", IDS_MEDIA_STREAM_HEADER},
-    {"mediaStreamAsk", IDS_MEDIA_STREAM_ASK_RADIO},
-    {"mediaStreamBlock", IDS_MEDIA_STREAM_BLOCK_RADIO},
-    {"mediaStreamAudioAsk", IDS_MEDIA_STREAM_ASK_AUDIO_ONLY_RADIO},
-    {"mediaStreamAudioBlock", IDS_MEDIA_STREAM_BLOCK_AUDIO_ONLY_RADIO},
-    {"mediaStreamVideoAsk", IDS_MEDIA_STREAM_ASK_VIDEO_ONLY_RADIO},
-    {"mediaStreamVideoBlock", IDS_MEDIA_STREAM_BLOCK_VIDEO_ONLY_RADIO},
-    {"mediaStreamBubbleAudio", IDS_MEDIA_STREAM_AUDIO_MANAGED},
-    {"mediaStreamBubbleVideo", IDS_MEDIA_STREAM_VIDEO_MANAGED},
-    {"mediaAudioExceptionHeader", IDS_MEDIA_AUDIO_EXCEPTION_HEADER},
-    {"mediaVideoExceptionHeader", IDS_MEDIA_VIDEO_EXCEPTION_HEADER},
+    // Microphone filter.
+    {"mediaStreamMicTabLabel", IDS_MEDIA_STREAM_MIC_TAB_LABEL},
+    {"mediaStreamMicHeader", IDS_MEDIA_STREAM_MIC_HEADER},
+    {"mediaStreamMicAsk", IDS_MEDIA_STREAM_ASK_AUDIO_ONLY_RADIO},
+    {"mediaStreamMicBlock", IDS_MEDIA_STREAM_BLOCK_AUDIO_ONLY_RADIO},
+    // Camera filter.
+    {"mediaStreamCameraTabLabel", IDS_MEDIA_STREAM_CAMERA_TAB_LABEL},
+    {"mediaStreamCameraHeader", IDS_MEDIA_STREAM_CAMERA_HEADER},
+    {"mediaStreamCameraAsk", IDS_MEDIA_STREAM_ASK_VIDEO_ONLY_RADIO},
+    {"mediaStreamCameraBlock", IDS_MEDIA_STREAM_BLOCK_VIDEO_ONLY_RADIO},
+    // Flash media settings.
     {"mediaPepperFlashDefaultDivergedLabel",
      IDS_MEDIA_PEPPER_FLASH_DEFAULT_DIVERGED_LABEL},
     {"mediaPepperFlashExceptionsDivergedLabel",
      IDS_MEDIA_PEPPER_FLASH_EXCEPTIONS_DIVERGED_LABEL},
     {"mediaPepperFlashChangeLink", IDS_MEDIA_PEPPER_FLASH_CHANGE_LINK},
     {"mediaPepperFlashGlobalPrivacyURL", IDS_FLASH_GLOBAL_PRIVACY_URL},
     {"mediaPepperFlashWebsitePrivacyURL", IDS_FLASH_WEBSITE_PRIVACY_URL},
     // PPAPI broker filter.
     {"ppapiBrokerHeader", IDS_PPAPI_BROKER_HEADER},
     {"ppapiBrokerTabLabel", IDS_PPAPI_BROKER_TAB_LABEL},
@@ skipping 56 matching lines @@
   RegisterTitle(localized_strings, "notifications",
                 IDS_NOTIFICATIONS_TAB_LABEL);
   RegisterTitle(localized_strings, "fullscreen",
                 IDS_FULLSCREEN_TAB_LABEL);
   RegisterTitle(localized_strings, "mouselock",
                 IDS_MOUSE_LOCK_TAB_LABEL);
 #if defined(OS_CHROMEOS)
   RegisterTitle(localized_strings, "protectedContent",
                 IDS_PROTECTED_CONTENT_TAB_LABEL);
 #endif
-  RegisterTitle(localized_strings, "media-stream",
-                IDS_MEDIA_STREAM_TAB_LABEL);
+  RegisterTitle(localized_strings, "media-stream-mic",
+                IDS_MEDIA_STREAM_MIC_TAB_LABEL);
+  RegisterTitle(localized_strings, "media-stream-camera",
+                IDS_MEDIA_STREAM_CAMERA_TAB_LABEL);
   RegisterTitle(localized_strings, "ppapi-broker",
                 IDS_PPAPI_BROKER_TAB_LABEL);
   RegisterTitle(localized_strings, "multiple-automatic-downloads",
                 IDS_AUTOMATIC_DOWNLOADS_TAB_LABEL);
   RegisterTitle(localized_strings, "midi-sysex",
                 IDS_MIDI_SYSEX_TAB_LABEL);
   RegisterTitle(localized_strings, "zoomlevels",
                 IDS_ZOOMLEVELS_HEADER_AND_TAB_LABEL);
 
   localized_strings->SetString("exceptionsLearnMoreUrl",
@@ skipping 17 matching lines @@
       content::Source<content::BrowserContext>(context));
 
   PrefService* prefs = user_prefs::UserPrefs::Get(context);
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(
       prefs::kPepperFlashSettingsEnabled,
       base::Bind(&ContentSettingsHandler::OnPepperFlashPrefChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kAudioCaptureAllowed,
-      base::Bind(&ContentSettingsHandler::UpdateMediaSettingsView,
-                 base::Unretained(this)));
+      base::Bind(&ContentSettingsHandler::UpdateSettingDefaultFromModel,
+                 base::Unretained(this),
+                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   pref_change_registrar_.Add(
       prefs::kVideoCaptureAllowed,
-      base::Bind(&ContentSettingsHandler::UpdateMediaSettingsView,
-                 base::Unretained(this)));
+      base::Bind(&ContentSettingsHandler::UpdateSettingDefaultFromModel,
+                 base::Unretained(this),
+                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   pref_change_registrar_.Add(
       prefs::kEnableDRM,
       base::Bind(
           &ContentSettingsHandler::UpdateProtectedContentExceptionsButton,
           base::Unretained(this)));
 
   // Here we only subscribe to the HostZoomMap for the default storage partition
   // since we don't allow the user to manage the zoom levels for apps.
   // We're only interested in zoom-levels that are persisted, since the user
   // is given the opportunity to view/delete these in the content-settings page.
@@ skipping 113 matching lines @@
   std::string provider_id;
   ContentSetting default_setting =
       GetContentSettingsMap()->GetDefaultContentSetting(type, &provider_id);
 
 #if defined(ENABLE_PLUGINS)
   default_setting =
       content_settings::PluginsFieldTrial::EffectiveContentSetting(
           type, default_setting);
 #endif
 
+  CompareMediaSettingsWithFlash();
+
+  // 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.
+  if ((type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
+       media_settings_.policy_disable_audio) ||
+      (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA &&
+       media_settings_.policy_disable_video)) {
+    default_setting = CONTENT_SETTING_BLOCK;
+    provider_id = kPolicyProviderId;
+  }
+
   base::DictionaryValue filter_settings;
   filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
                             ContentSettingToString(default_setting));
   filter_settings.SetString(
       ContentSettingsTypeToGroupName(type) + ".managedBy", provider_id);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
 }
 
-void ContentSettingsHandler::UpdateMediaSettingsView() {
+void ContentSettingsHandler::CompareMediaSettingsWithFlash() {
+  // TODO(msramek): Currently, we show the flash link if the combined
+  // camera and microphone content settings differ from the combined microphone
+  // and camera flash settings. Split this logic to only show the link for
+  // camera if camera settings differ, and analogically for microphone.

[Bernhard Bauer, 2015/07/17 08:37:11]

Nit: "analogously"

[msramek, 2015/07/17 11:59:50]

I wrote "analogously", then I checked a dictionary and I would have sworn that
"analogically" made more sense. It doesn't, but... yesterday it somehow did :)

   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool audio_disabled = !prefs->GetBoolean(prefs::kAudioCaptureAllowed) &&
       prefs->IsManagedPreference(prefs::kAudioCaptureAllowed);
   bool video_disabled = !prefs->GetBoolean(prefs::kVideoCaptureAllowed) &&
       prefs->IsManagedPreference(prefs::kVideoCaptureAllowed);
 
   media_settings_.policy_disable_audio = audio_disabled;
   media_settings_.policy_disable_video = video_disabled;
   media_settings_.default_audio_setting =
       GetContentSettingsMap()->GetDefaultContentSetting(
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, NULL);
   media_settings_.default_video_setting =
       GetContentSettingsMap()->GetDefaultContentSetting(
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, NULL);
   media_settings_.default_settings_initialized = true;
+
   UpdateFlashMediaLinksVisibility();
-
-  base::DictionaryValue media_ui_settings;
-  media_ui_settings.SetBoolean("cameraDisabled", video_disabled);
-  media_ui_settings.SetBoolean("micDisabled", audio_disabled);
-
-  // In case only video is enabled change the text appropriately.
-  if (audio_disabled && !video_disabled) {
-    media_ui_settings.SetString("askText", "mediaStreamVideoAsk");
-    media_ui_settings.SetString("blockText", "mediaStreamVideoBlock");
-    media_ui_settings.SetBoolean("showBubble", true);
-    media_ui_settings.SetString("bubbleText", "mediaStreamBubbleAudio");
-
-    web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI",
-                                     media_ui_settings);
-    return;
-  }
-
-  // In case only audio is enabled change the text appropriately.
-  if (video_disabled && !audio_disabled) {
-    base::DictionaryValue media_ui_settings;
-    media_ui_settings.SetString("askText", "mediaStreamAudioAsk");
-    media_ui_settings.SetString("blockText", "mediaStreamAudioBlock");
-    media_ui_settings.SetBoolean("showBubble", true);
-    media_ui_settings.SetString("bubbleText", "mediaStreamBubbleVideo");
-
-    web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI",
-                                     media_ui_settings);
-    return;
-  }
-
-  if (audio_disabled && video_disabled) {
-    // Fake policy controlled default because the user can not change anything
-    // until both audio and video are blocked.
-    base::DictionaryValue filter_settings;
-    std::string group_name =
-        ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_MEDIASTREAM);
-    filter_settings.SetString(group_name + ".value",
-                              ContentSettingToString(CONTENT_SETTING_BLOCK));
-    filter_settings.SetString(group_name + ".managedBy", "policy");
-    web_ui()->CallJavascriptFunction(
-        "ContentSettings.setContentFilterSettingsValue", filter_settings);
-  }
-
-  media_ui_settings.SetString("askText", "mediaStreamAsk");
-  media_ui_settings.SetString("blockText", "mediaStreamBlock");
-  media_ui_settings.SetBoolean("showBubble", false);
-  media_ui_settings.SetString("bubbleText", std::string());
-
-  web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI",
-                                   media_ui_settings);
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
   base::FundamentalValue handlers_enabled(
       GetProtocolHandlerRegistry()->enabled());
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.updateHandlersEnabledRadios",
       handlers_enabled);
 }
@@ skipping 23 matching lines @@
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
       // The content settings type CONTENT_SETTINGS_TYPE_MEDIASSTREAM
       // is deprecated.
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
-      UpdateMediaSettingsView();
-      UpdateMediaExceptionsView();
+      CompareMediaExceptionsWithFlash();
+      UpdateExceptionsViewFromHostContentSettingsMap(type);
       break;
     case CONTENT_SETTINGS_TYPE_MIXEDSCRIPT:
       // We don't yet support exceptions for mixed scripting.
       break;
     case CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE:
       // The content settings type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE
       // is supposed to be set by policy only. Hence there is no user facing UI
       // for this content type and we skip it here.
       break;
     case CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS:
@@ skipping 158 matching lines @@
   base::StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
-void ContentSettingsHandler::UpdateMediaExceptionsView() {
+void ContentSettingsHandler::CompareMediaExceptionsWithFlash() {
+  // TODO(msramek): Split the combined microphone-camera exceptions
+  // in PepperFlashContentSettingsUtils. The complicated comparison in this
+  // method will then not be necessary.
+
   base::ListValue media_exceptions;
   GetExceptionsFromHostContentSettingsMap(
       GetContentSettingsMap(),
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
       &media_exceptions);
 
   base::ListValue video_exceptions;
   GetExceptionsFromHostContentSettingsMap(
       GetContentSettingsMap(),
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
@@ skipping 60 matching lines @@
     media_dict->GetString(kVideoSetting, &video_setting);
     media_settings_.exceptions.push_back(MediaException(
         ContentSettingsPattern::FromString(origin),
         ContentSettingFromString(audio_setting),
         ContentSettingFromString(video_setting)));
   }
   PepperFlashContentSettingsUtils::SortMediaExceptions(
       &media_settings_.exceptions);
   media_settings_.exceptions_initialized = true;
   UpdateFlashMediaLinksVisibility();
-
-  base::StringValue type_string(
-       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_MEDIASTREAM));
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
-                                   type_string, media_exceptions);
-
-  // TODO(msramek): We currently don't have a UI to show separate default
-  // settings for microphone and camera. However, SetContentFilter always sets
-  // both defaults to the same value, so it doesn't matter which one we pick
-  // to show in the UI. Makes sure to update both when we have the new media UI.
-  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
 }
 
 void ContentSettingsHandler::UpdateMIDISysExExceptionsView() {
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
   UpdateExceptionsViewFromHostContentSettingsMap(
       CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
 void ContentSettingsHandler::AdjustZoomLevelsListForSigninPageIfNecessary(
     content::HostZoomMap::ZoomLevelVector* zoom_levels) {
@@ skipping 216 matching lines @@
     }
   }
 
   for (size_t i = 0; i < all_provider_exceptions.size(); ++i) {
     for (size_t j = 0; j < all_provider_exceptions[i].size(); ++j) {
       exceptions->Append(all_provider_exceptions[i][j]);
     }
   }
 }
 
-void ContentSettingsHandler::RemoveMediaException(const base::ListValue* args) {
-  std::string mode;
-  bool rv = args->GetString(1, &mode);
-  DCHECK(rv);
-
-  std::string pattern;
-  rv = args->GetString(2, &pattern);
-  DCHECK(rv);
-
-  HostContentSettingsMap* settings_map =
-      mode == "normal" ? GetContentSettingsMap() :
-                         GetOTRContentSettingsMap();
-  if (settings_map) {
-    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern),
-                                    ContentSettingsPattern::Wildcard(),
-                                    CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                                    std::string(),
-                                    NULL);
-    settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern),
-                                    ContentSettingsPattern::Wildcard(),
-                                    CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                                    std::string(),
-                                    NULL);
-  }
-}
-
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
   DCHECK(rv);
@@ skipping 161 matching lines @@
 
   // 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;
   }
 
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
-  if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM)
-    RemoveMediaException(args);
-  else
-    RemoveExceptionFromHostContentSettingsMap(args, type);
+  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));
@@ skipping 171 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