Stop using the MEDIASTREAM 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 <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 91 matching lines @@
   {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-mic"},
-  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"},
+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream"},

[msramek, 2015/03/05 16:19:38]

Nothing in the UI is currently labeled "media-stream-mic" or
"media-stream-camera", so we're not breaking anything here.

The point is that when we update the radio buttons for either MIC or CAMERA, we
want to refer to the pair of radio buttons that previously belonged to
MEDIASTREAM.

+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream"},
   {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 123 matching lines @@
 }  // namespace
 
 namespace options {
 
 ContentSettingsHandler::MediaSettingsInfo::MediaSettingsInfo()
     : flash_default_setting(CONTENT_SETTING_DEFAULT),
       flash_settings_initialized(false),
       last_flash_refresh_request_id(0),
       show_flash_default_link(false),
       show_flash_exceptions_link(false),
-      default_setting(CONTENT_SETTING_DEFAULT),
+      default_audio_setting(CONTENT_SETTING_DEFAULT),
+      default_video_setting(CONTENT_SETTING_DEFAULT),
       policy_disable_audio(false),
       policy_disable_video(false),
-      default_setting_initialized(false),
+      default_settings_initialized(false),
       exceptions_initialized(false) {
 }
 
 ContentSettingsHandler::MediaSettingsInfo::~MediaSettingsInfo() {
 }
 
 ContentSettingsHandler::ContentSettingsHandler() : observer_(this) {
 }
 
 ContentSettingsHandler::~ContentSettingsHandler() {
@@ skipping 320 matching lines @@
         sites, &media_settings_.flash_exceptions);
     PepperFlashContentSettingsUtils::SortMediaExceptions(
         &media_settings_.flash_exceptions);
 
     UpdateFlashMediaLinksVisibility();
   }
 }
 
 void ContentSettingsHandler::UpdateSettingDefaultFromModel(
     ContentSettingsType type) {
-  Profile* profile = Profile::FromWebUI(web_ui());
   std::string provider_id;
   ContentSetting default_setting =
-      profile->GetHostContentSettingsMap()->GetDefaultContentSetting(
-          type, &provider_id);
+      GetContentSettingsMap()->GetDefaultContentSetting(type, &provider_id);
 
   // For Plugins, display the obsolete ASK setting as BLOCK.
   if (type == ContentSettingsType::CONTENT_SETTINGS_TYPE_PLUGINS &&
       default_setting == ContentSetting::CONTENT_SETTING_ASK) {
     default_setting = ContentSetting::CONTENT_SETTING_BLOCK;
   }
 
   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() {
   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_setting =
+  media_settings_.default_audio_setting =
       GetContentSettingsMap()->GetDefaultContentSetting(
-          CONTENT_SETTINGS_TYPE_MEDIASTREAM, NULL);
-  media_settings_.default_setting_initialized = true;
+          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");
@@ skipping 69 matching lines @@
 void ContentSettingsHandler::UpdateExceptionsViewFromModel(
     ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UpdateGeolocationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
-      UpdateMediaSettingsView();
+      // 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();
       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;
@@ skipping 234 matching lines @@
   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);
 
-  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MEDIASTREAM);
+  // 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() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableWebMIDI)) {
     web_ui()->CallJavascriptFunction(
         "ContentSettings.showExperimentalWebMIDISettings",
         base::FundamentalValue(true));
   }
 
@@ skipping 342 matching lines @@
   ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group);
   Profile* profile = Profile::FromWebUI(web_ui());
 
 #if defined(OS_CHROMEOS)
   // ChromeOS special case : in Guest mode settings are opened in Incognito
   // mode, so we need original profile to actually modify settings.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     profile = profile->GetOriginalProfile();
 #endif
 
+  HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
-  HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
-  map->SetDefaultContentSetting(content_type, default_setting);
+  // MEDIASTREAM is deprecated and the two separate settings MEDIASTREAM_CAMERA
+  // and MEDIASTREAM_MIC should be used instead. However, we still only have
+  // one pair of radio buttons that sets both settings.
+  // TODO(msramek): Clean this up once we have the new UI for media.
+  if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {

[msramek, 2015/03/05 16:19:38]

Unfortunately, we create a lot of additional complexity in the UI code. However,
this is only temporary, as we already have plans to demonstrate the split of
MEDIASTREAM to MIC and CAMERA in the UI as well.

+    map->SetDefaultContentSetting(
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, default_setting);
+    map->SetDefaultContentSetting(
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, default_setting);
+  } else {
+    map->SetDefaultContentSetting(content_type, default_setting);
+  }
 
   switch (content_type) {
     case CONTENT_SETTINGS_TYPE_COOKIES:
       content::RecordAction(
           UserMetricsAction("Options_DefaultCookieSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_IMAGES:
       content::RecordAction(
           UserMetricsAction("Options_DefaultImagesSettingChanged"));
       break;
@@ skipping 180 matching lines @@
         link_type == DEFAULT_SETTING ?
             "ContentSettings.showMediaPepperFlashDefaultLink" :
             "ContentSettings.showMediaPepperFlashExceptionsLink",
         base::FundamentalValue(show));
     show_link = show;
   }
 }
 
 void ContentSettingsHandler::UpdateFlashMediaLinksVisibility() {
   if (!media_settings_.flash_settings_initialized ||
-      !media_settings_.default_setting_initialized ||
+      !media_settings_.default_settings_initialized ||
       !media_settings_.exceptions_initialized) {
     return;
   }
 
   // Flash won't send us notifications when its settings get changed, which
   // means the Flash settings in |media_settings_| may be out-dated, especially
   // after we show links to change Flash settings.
   // In order to avoid confusion, we won't hide the links once they are showed.
   // One exception is that we will hide them when Pepper Flash is disabled
   // (handled in OnPepperFlashPrefChanged()).
   if (media_settings_.show_flash_default_link &&
       media_settings_.show_flash_exceptions_link) {
     return;
   }
 
   if (!media_settings_.show_flash_default_link) {
     // If both audio and video capture are disabled by policy, the link
     // shouldn't be showed. Flash conforms to the policy in this case because
     // it cannot open those devices. We don't have to look at the Flash
     // settings.
     if (!(media_settings_.policy_disable_audio &&
           media_settings_.policy_disable_video) &&
-        media_settings_.flash_default_setting !=
-            media_settings_.default_setting) {
+        ((media_settings_.flash_default_setting !=
+          media_settings_.default_audio_setting) ||
+         (media_settings_.flash_default_setting !=
+          media_settings_.default_video_setting))) {
       ShowFlashMediaLink(DEFAULT_SETTING, true);
     }
   }
   if (!media_settings_.show_flash_exceptions_link) {
     // If audio or video capture is disabled by policy, we skip comparison of
     // exceptions for audio or video capture, respectively.
     if (!PepperFlashContentSettingsUtils::AreMediaExceptionsEqual(
-            media_settings_.default_setting,
+            media_settings_.default_audio_setting,
+            media_settings_.default_video_setting,
             media_settings_.exceptions,
             media_settings_.flash_default_setting,
+            media_settings_.flash_default_setting,
             media_settings_.flash_exceptions,
             media_settings_.policy_disable_audio,
             media_settings_.policy_disable_video)) {
       ShowFlashMediaLink(EXCEPTIONS, true);
     }
   }
 }
 
 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() {
 #if defined(OS_CHROMEOS)
   // Guests cannot modify exceptions. UIAccountTweaks will disabled the button.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     return;
 #endif
 
   // 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