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"},
+  {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) {
+    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