1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/webui/options/content_settings_handler.h" 6 7 #include <algorithm> 8 #include <map> 9 #include <vector> 10 11 #include "base/bind.h" 12 #include "base/bind_helpers.h" 13 #include "base/command_line.h" 14 #include "base/prefs/pref_service.h" 15 #include "base/strings/string_number_conversions.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "base/values.h" 18 #include "chrome/browser/browser_process.h" 19 #include "chrome/browser/chrome_notification_types.h" 20 #include "chrome/browser/content_settings/content_settings_utils.h" 21 #include "chrome/browser/content_settings/host_content_settings_map.h" 22 #include "chrome/browser/custom_handlers/protocol_handler_registry.h" 23 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h" 24 #include "chrome/browser/extensions/extension_special_storage_policy.h" 25 #include "chrome/browser/notifications/desktop_notification_profile_util.h" 26 #include "chrome/browser/profiles/profile.h" 27 #include "chrome/browser/ui/browser_list.h" 28 #include "chrome/common/chrome_switches.h" 29 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" 30 #include "chrome/common/pref_names.h" 31 #include "chrome/common/url_constants.h" 32 #include "chrome/grit/generated_resources.h" 33 #include "chrome/grit/locale_settings.h" 34 #include "components/content_settings/core/browser/content_settings_details.h" 35 #include "components/content_settings/core/common/content_settings.h" 36 #include "components/content_settings/core/common/content_settings_pattern.h" 37 #include "components/google/core/browser/google_util.h" 38 #include "components/user_prefs/user_prefs.h" 39 #include "content/public/browser/notification_service.h" 40 #include "content/public/browser/notification_source.h" 41 #include "content/public/browser/notification_types.h" 42 #include "content/public/browser/user_metrics.h" 43 #include "content/public/browser/web_contents.h" 44 #include "content/public/browser/web_ui.h" 45 #include "content/public/common/content_switches.h" 46 #include "content/public/common/page_zoom.h" 47 #include "extensions/browser/extension_registry.h" 48 #include "extensions/common/extension_set.h" 49 #include "extensions/common/permissions/api_permission.h" 50 #include "extensions/common/permissions/permissions_data.h" 51 #include "ui/base/l10n/l10n_util.h" 52 53 #if defined(OS_CHROMEOS) 54 #include "components/user_manager/user_manager.h" 55 #endif 56 57 using base::UserMetricsAction; 58 using content_settings::ContentSettingToString; 59 using content_settings::ContentSettingFromString; 60 using extensions::APIPermission; 61 62 namespace { 63 64 struct ContentSettingsTypeNameEntry { 65 ContentSettingsType type; 66 const char* name; 67 }; 68 69 // Maps from a secondary pattern to a setting. 70 typedef std::map<ContentSettingsPattern, ContentSetting> 71 OnePatternSettings; 72 // Maps from a primary pattern/source pair to a OnePatternSettings. All the 73 // mappings in OnePatternSettings share the given primary pattern and source. 74 typedef std::map<std::pair<ContentSettingsPattern, std::string>, 75 OnePatternSettings> 76 AllPatternsSettings; 77 78 // The AppFilter is used in AddExceptionsGrantedByHostedApps() to choose 79 // extensions which should have their extent displayed. 80 typedef bool (*AppFilter)(const extensions::Extension& app, 81 content::BrowserContext* profile); 82 83 const char kExceptionsLearnMoreUrl[] = 84 "https://support.google.com/chrome/?p=settings_manage_exceptions"; 85 86 const char* kSetting = "setting"; 87 const char* kOrigin = "origin"; 88 const char* kSource = "source"; 89 const char* kAppName = "appName"; 90 const char* kAppId = "appId"; 91 const char* kEmbeddingOrigin = "embeddingOrigin"; 92 const char* kPreferencesSource = "preference"; 93 const char* kVideoSetting = "video"; 94 const char* kZoom = "zoom"; 95 96 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = { 97 {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"}, 98 {CONTENT_SETTINGS_TYPE_IMAGES, "images"}, 99 {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"}, 100 {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"}, 101 {CONTENT_SETTINGS_TYPE_POPUPS, "popups"}, 102 {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"}, 103 {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"}, 104 {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"}, 105 {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"}, 106 {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"}, 107 {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, "register-protocol-handler"}, 108 {CONTENT_SETTINGS_TYPE_MEDIASTREAM, "media-stream"}, 109 {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream-mic"}, 110 {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"}, 111 {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, "ppapi-broker"}, 112 {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, "multiple-automatic-downloads"}, 113 {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, "midi-sysex"}, 114 {CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, "push-messaging"}, 115 {CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS, "ssl-cert-decisions"}, 116 #if defined(OS_CHROMEOS) 117 {CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, "protectedContent"}, 118 #endif 119 }; 120 121 // A pseudo content type. We use it to display data like a content setting even 122 // though it is not a real content setting. 123 const char* kZoomContentType = "zoomlevels"; 124 125 content::BrowserContext* GetBrowserContext(content::WebUI* web_ui) { 126 return web_ui->GetWebContents()->GetBrowserContext(); 127 } 128 129 ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) { 130 for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) { 131 if (name == kContentSettingsTypeGroupNames[i].name) 132 return kContentSettingsTypeGroupNames[i].type; 133 } 134 135 NOTREACHED() << name << " is not a recognized content settings type."; 136 return CONTENT_SETTINGS_TYPE_DEFAULT; 137 } 138 139 // Create a DictionaryValue* that will act as a data source for a single row 140 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies). 141 // Ownership of the pointer is passed to the caller. 142 base::DictionaryValue* GetExceptionForPage( 143 const ContentSettingsPattern& pattern, 144 const ContentSettingsPattern& secondary_pattern, 145 const ContentSetting& setting, 146 const std::string& provider_name) { 147 base::DictionaryValue* exception = new base::DictionaryValue(); 148 exception->SetString(kOrigin, pattern.ToString()); 149 exception->SetString(kEmbeddingOrigin, 150 secondary_pattern == ContentSettingsPattern::Wildcard() ? 151 std::string() : 152 secondary_pattern.ToString()); 153 exception->SetString(kSetting, ContentSettingToString(setting)); 154 exception->SetString(kSource, provider_name); 155 return exception; 156 } 157 158 // Create a DictionaryValue* that will act as a data source for a single row 159 // in the Geolocation exceptions table. Ownership of the pointer is passed to 160 // the caller. 161 base::DictionaryValue* GetGeolocationExceptionForPage( 162 const ContentSettingsPattern& origin, 163 const ContentSettingsPattern& embedding_origin, 164 ContentSetting setting) { 165 base::DictionaryValue* exception = new base::DictionaryValue(); 166 exception->SetString(kSetting, ContentSettingToString(setting)); 167 exception->SetString(kOrigin, origin.ToString()); 168 exception->SetString(kEmbeddingOrigin, embedding_origin.ToString()); 169 return exception; 170 } 171 172 // Create a DictionaryValue* that will act as a data source for a single row 173 // in the desktop notifications exceptions table. Ownership of the pointer is 174 // passed to the caller. 175 base::DictionaryValue* GetNotificationExceptionForPage( 176 const ContentSettingsPattern& primary_pattern, 177 const ContentSettingsPattern& secondary_pattern, 178 ContentSetting setting, 179 const std::string& provider_name) { 180 std::string embedding_origin; 181 if (secondary_pattern != ContentSettingsPattern::Wildcard()) 182 embedding_origin = secondary_pattern.ToString(); 183 184 base::DictionaryValue* exception = new base::DictionaryValue(); 185 exception->SetString(kSetting, ContentSettingToString(setting)); 186 exception->SetString(kOrigin, primary_pattern.ToString()); 187 exception->SetString(kEmbeddingOrigin, embedding_origin); 188 exception->SetString(kSource, provider_name); 189 return exception; 190 } 191 192 // Returns true whenever the |extension| is hosted and has |permission|. 193 // Must have the AppFilter signature. 194 template <APIPermission::ID permission> 195 bool HostedAppHasPermission(const extensions::Extension& extension, 196 content::BrowserContext* /* context */) { 197 return extension.is_hosted_app() && 198 extension.permissions_data()->HasAPIPermission(permission); 199 } 200 201 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from 202 // the web extent of a hosted |app|. 203 void AddExceptionForHostedApp(const std::string& url_pattern, 204 const extensions::Extension& app, base::ListValue* exceptions) { 205 base::DictionaryValue* exception = new base::DictionaryValue(); 206 exception->SetString(kSetting, ContentSettingToString(CONTENT_SETTING_ALLOW)); 207 exception->SetString(kOrigin, url_pattern); 208 exception->SetString(kEmbeddingOrigin, url_pattern); 209 exception->SetString(kSource, "HostedApp"); 210 exception->SetString(kAppName, app.name()); 211 exception->SetString(kAppId, app.id()); 212 exceptions->Append(exception); 213 } 214 215 // Asks the |profile| for hosted apps which have the |permission| set, and 216 // adds their web extent and launch URL to the |exceptions| list. 217 void AddExceptionsGrantedByHostedApps(content::BrowserContext* context, 218 AppFilter app_filter, 219 base::ListValue* exceptions) { 220 const extensions::ExtensionSet& extensions = 221 extensions::ExtensionRegistry::Get(context)->enabled_extensions(); 222 for (extensions::ExtensionSet::const_iterator extension = extensions.begin(); 223 extension != extensions.end(); ++extension) { 224 if (!app_filter(*extension->get(), context)) 225 continue; 226 227 extensions::URLPatternSet web_extent = (*extension)->web_extent(); 228 // Add patterns from web extent. 229 for (extensions::URLPatternSet::const_iterator pattern = web_extent.begin(); 230 pattern != web_extent.end(); ++pattern) { 231 std::string url_pattern = pattern->GetAsString(); 232 AddExceptionForHostedApp(url_pattern, *extension->get(), exceptions); 233 } 234 // Retrieve the launch URL. 235 GURL launch_url = 236 extensions::AppLaunchInfo::GetLaunchWebURL(extension->get()); 237 // Skip adding the launch URL if it is part of the web extent. 238 if (web_extent.MatchesURL(launch_url)) 239 continue; 240 AddExceptionForHostedApp(launch_url.spec(), *extension->get(), exceptions); 241 } 242 } 243 244 // Sort ZoomLevelChanges by host and scheme 245 // (a.com < http://a.com < https://a.com < b.com). 246 bool HostZoomSort(const content::HostZoomMap::ZoomLevelChange& a, 247 const content::HostZoomMap::ZoomLevelChange& b) { 248 return a.host == b.host ? a.scheme < b.scheme : a.host < b.host; 249 } 250 251 } // namespace 252 253 namespace options { 254 255 ContentSettingsHandler::MediaSettingsInfo::MediaSettingsInfo() 256 : flash_default_setting(CONTENT_SETTING_DEFAULT), 257 flash_settings_initialized(false), 258 last_flash_refresh_request_id(0), 259 show_flash_default_link(false), 260 show_flash_exceptions_link(false), 261 default_setting(CONTENT_SETTING_DEFAULT), 262 policy_disable_audio(false), 263 policy_disable_video(false), 264 default_setting_initialized(false), 265 exceptions_initialized(false) { 266 } 267 268 ContentSettingsHandler::MediaSettingsInfo::~MediaSettingsInfo() { 269 } 270 271 ContentSettingsHandler::ContentSettingsHandler() : observer_(this) { 272 } 273 274 ContentSettingsHandler::~ContentSettingsHandler() { 275 } 276 277 void ContentSettingsHandler::GetLocalizedValues( 278 base::DictionaryValue* localized_strings) { 279 DCHECK(localized_strings); 280 281 // TODO(dhnishi): Standardize to lowerCamelCase. 282 static OptionsStringResource resources[] = { 283 { "allowException", IDS_EXCEPTIONS_ALLOW_BUTTON }, 284 { "blockException", IDS_EXCEPTIONS_BLOCK_BUTTON }, 285 { "sessionException", IDS_EXCEPTIONS_SESSION_ONLY_BUTTON }, 286 { "askException", IDS_EXCEPTIONS_ASK_BUTTON }, 287 { "otr_exceptions_explanation", IDS_EXCEPTIONS_OTR_LABEL }, 288 { "addNewExceptionInstructions", IDS_EXCEPTIONS_ADD_NEW_INSTRUCTIONS }, 289 { "manageExceptions", IDS_EXCEPTIONS_MANAGE }, 290 { "manage_handlers", IDS_HANDLERS_MANAGE }, 291 { "exceptionPatternHeader", IDS_EXCEPTIONS_PATTERN_HEADER }, 292 { "exceptionBehaviorHeader", IDS_EXCEPTIONS_ACTION_HEADER }, 293 { "exceptionZoomHeader", IDS_EXCEPTIONS_ZOOM_HEADER }, 294 { "embeddedOnHost", IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ON_HOST }, 295 // Cookies filter. 296 { "cookiesTabLabel", IDS_COOKIES_TAB_LABEL }, 297 { "cookies_header", IDS_COOKIES_HEADER }, 298 { "cookiesAllow", IDS_COOKIES_ALLOW_RADIO }, 299 { "cookiesBlock", IDS_COOKIES_BLOCK_RADIO }, 300 { "cookies_session_only", IDS_COOKIES_SESSION_ONLY_RADIO }, 301 { "cookies_block_3rd_party", IDS_COOKIES_BLOCK_3RDPARTY_CHKBOX }, 302 { "cookies_clear_when_close", IDS_COOKIES_CLEAR_WHEN_CLOSE_CHKBOX }, 303 { "cookies_lso_clear_when_close", IDS_COOKIES_LSO_CLEAR_WHEN_CLOSE_CHKBOX }, 304 { "cookies_show_cookies", IDS_COOKIES_SHOW_COOKIES_BUTTON }, 305 { "flash_storage_settings", IDS_FLASH_STORAGE_SETTINGS }, 306 { "flash_storage_url", IDS_FLASH_STORAGE_URL }, 307 #if defined(ENABLE_GOOGLE_NOW) 308 { "googleGeolocationAccessEnable", 309 IDS_GEOLOCATION_GOOGLE_ACCESS_ENABLE_CHKBOX }, 310 #endif 311 // Image filter. 312 { "imagesTabLabel", IDS_IMAGES_TAB_LABEL }, 313 { "images_header", IDS_IMAGES_HEADER }, 314 { "imagesAllow", IDS_IMAGES_LOAD_RADIO }, 315 { "imagesBlock", IDS_IMAGES_NOLOAD_RADIO }, 316 // JavaScript filter. 317 { "javascriptTabLabel", IDS_JAVASCRIPT_TAB_LABEL }, 318 { "javascript_header", IDS_JAVASCRIPT_HEADER }, 319 { "javascriptAllow", IDS_JS_ALLOW_RADIO }, 320 { "javascriptBlock", IDS_JS_DONOTALLOW_RADIO }, 321 // Plug-ins filter. 322 { "pluginsTabLabel", IDS_PLUGIN_TAB_LABEL }, 323 { "plugins_header", IDS_PLUGIN_HEADER }, 324 { "pluginsAsk", IDS_PLUGIN_ASK_RADIO }, 325 { "pluginsAllow", IDS_PLUGIN_LOAD_RADIO }, 326 { "pluginsBlock", IDS_PLUGIN_NOLOAD_RADIO }, 327 { "disableIndividualPlugins", IDS_PLUGIN_SELECTIVE_DISABLE }, 328 // Pop-ups filter. 329 { "popupsTabLabel", IDS_POPUP_TAB_LABEL }, 330 { "popups_header", IDS_POPUP_HEADER }, 331 { "popupsAllow", IDS_POPUP_ALLOW_RADIO }, 332 { "popupsBlock", IDS_POPUP_BLOCK_RADIO }, 333 // Location filter. 334 { "locationTabLabel", IDS_GEOLOCATION_TAB_LABEL }, 335 { "location_header", IDS_GEOLOCATION_HEADER }, 336 { "locationAllow", IDS_GEOLOCATION_ALLOW_RADIO }, 337 { "locationAsk", IDS_GEOLOCATION_ASK_RADIO }, 338 { "locationBlock", IDS_GEOLOCATION_BLOCK_RADIO }, 339 { "set_by", IDS_GEOLOCATION_SET_BY_HOVER }, 340 // Notifications filter. 341 { "notificationsTabLabel", IDS_NOTIFICATIONS_TAB_LABEL }, 342 { "notifications_header", IDS_NOTIFICATIONS_HEADER }, 343 { "notificationsAllow", IDS_NOTIFICATIONS_ALLOW_RADIO }, 344 { "notificationsAsk", IDS_NOTIFICATIONS_ASK_RADIO }, 345 { "notificationsBlock", IDS_NOTIFICATIONS_BLOCK_RADIO }, 346 // Fullscreen filter. 347 { "fullscreenTabLabel", IDS_FULLSCREEN_TAB_LABEL }, 348 { "fullscreen_header", IDS_FULLSCREEN_HEADER }, 349 // Mouse Lock filter. 350 { "mouselockTabLabel", IDS_MOUSE_LOCK_TAB_LABEL }, 351 { "mouselock_header", IDS_MOUSE_LOCK_HEADER }, 352 { "mouselockAllow", IDS_MOUSE_LOCK_ALLOW_RADIO }, 353 { "mouselockAsk", IDS_MOUSE_LOCK_ASK_RADIO }, 354 { "mouselockBlock", IDS_MOUSE_LOCK_BLOCK_RADIO }, 355 #if defined(OS_CHROMEOS) || defined(OS_WIN) 356 // Protected Content filter 357 { "protectedContentTabLabel", IDS_PROTECTED_CONTENT_TAB_LABEL }, 358 { "protectedContentInfo", IDS_PROTECTED_CONTENT_INFO }, 359 { "protectedContentEnable", IDS_PROTECTED_CONTENT_ENABLE }, 360 { "protectedContent_header", IDS_PROTECTED_CONTENT_HEADER }, 361 #endif // defined(OS_CHROMEOS) || defined(OS_WIN) 362 // Media stream capture device filter. 363 { "mediaStreamTabLabel", IDS_MEDIA_STREAM_TAB_LABEL }, 364 { "media-stream_header", IDS_MEDIA_STREAM_HEADER }, 365 { "mediaStreamAsk", IDS_MEDIA_STREAM_ASK_RADIO }, 366 { "mediaStreamBlock", IDS_MEDIA_STREAM_BLOCK_RADIO }, 367 { "mediaStreamAudioAsk", IDS_MEDIA_STREAM_ASK_AUDIO_ONLY_RADIO }, 368 { "mediaStreamAudioBlock", IDS_MEDIA_STREAM_BLOCK_AUDIO_ONLY_RADIO }, 369 { "mediaStreamVideoAsk", IDS_MEDIA_STREAM_ASK_VIDEO_ONLY_RADIO }, 370 { "mediaStreamVideoBlock", IDS_MEDIA_STREAM_BLOCK_VIDEO_ONLY_RADIO }, 371 { "mediaStreamBubbleAudio", IDS_MEDIA_STREAM_AUDIO_MANAGED }, 372 { "mediaStreamBubbleVideo", IDS_MEDIA_STREAM_VIDEO_MANAGED }, 373 { "mediaAudioExceptionHeader", IDS_MEDIA_AUDIO_EXCEPTION_HEADER }, 374 { "mediaVideoExceptionHeader", IDS_MEDIA_VIDEO_EXCEPTION_HEADER }, 375 { "mediaPepperFlashDefaultDivergedLabel", 376 IDS_MEDIA_PEPPER_FLASH_DEFAULT_DIVERGED_LABEL }, 377 { "mediaPepperFlashExceptionsDivergedLabel", 378 IDS_MEDIA_PEPPER_FLASH_EXCEPTIONS_DIVERGED_LABEL }, 379 { "mediaPepperFlashChangeLink", IDS_MEDIA_PEPPER_FLASH_CHANGE_LINK }, 380 { "mediaPepperFlashGlobalPrivacyURL", IDS_FLASH_GLOBAL_PRIVACY_URL }, 381 { "mediaPepperFlashWebsitePrivacyURL", IDS_FLASH_WEBSITE_PRIVACY_URL }, 382 // PPAPI broker filter. 383 { "ppapi-broker_header", IDS_PPAPI_BROKER_HEADER }, 384 { "ppapiBrokerTabLabel", IDS_PPAPI_BROKER_TAB_LABEL }, 385 { "ppapiBrokerAllow", IDS_PPAPI_BROKER_ALLOW_RADIO }, 386 { "ppapiBrokerAsk", IDS_PPAPI_BROKER_ASK_RADIO }, 387 { "ppapiBrokerBlock", IDS_PPAPI_BROKER_BLOCK_RADIO }, 388 // Multiple automatic downloads 389 { "multipleAutomaticDownloadsTabLabel", 390 IDS_AUTOMATIC_DOWNLOADS_TAB_LABEL }, 391 { "multipleAutomaticDownloadsAllow", 392 IDS_AUTOMATIC_DOWNLOADS_ALLOW_RADIO }, 393 { "multipleAutomaticDownloadsAsk", 394 IDS_AUTOMATIC_DOWNLOADS_ASK_RADIO }, 395 { "multipleAutomaticDownloadsBlock", 396 IDS_AUTOMATIC_DOWNLOADS_BLOCK_RADIO }, 397 // MIDI system exclusive messages 398 { "midi-sysex_header", IDS_MIDI_SYSEX_TAB_LABEL }, 399 { "midiSysExAllow", IDS_MIDI_SYSEX_ALLOW_RADIO }, 400 { "midiSysExAsk", IDS_MIDI_SYSEX_ASK_RADIO }, 401 { "midiSysExBlock", IDS_MIDI_SYSEX_BLOCK_RADIO }, 402 // Push messaging strings 403 { "push-messaging_header", IDS_PUSH_MESSAGES_TAB_LABEL }, 404 { "pushMessagingAllow", IDS_PUSH_MESSSAGING_ALLOW_RADIO }, 405 { "pushMessagingAsk", IDS_PUSH_MESSSAGING_ASK_RADIO }, 406 { "pushMessagingBlock", IDS_PUSH_MESSSAGING_BLOCK_RADIO }, 407 { "zoomlevels_header", IDS_ZOOMLEVELS_HEADER_AND_TAB_LABEL }, 408 { "zoomLevelsManage", IDS_ZOOMLEVELS_MANAGE_BUTTON }, 409 }; 410 411 RegisterStrings(localized_strings, resources, arraysize(resources)); 412 RegisterTitle(localized_strings, "contentSettingsPage", 413 IDS_CONTENT_SETTINGS_TITLE); 414 415 // Register titles for each of the individual settings whose exception 416 // dialogs will be processed by |ContentSettingsHandler|. 417 RegisterTitle(localized_strings, "cookies", 418 IDS_COOKIES_TAB_LABEL); 419 RegisterTitle(localized_strings, "images", 420 IDS_IMAGES_TAB_LABEL); 421 RegisterTitle(localized_strings, "javascript", 422 IDS_JAVASCRIPT_TAB_LABEL); 423 RegisterTitle(localized_strings, "plugins", 424 IDS_PLUGIN_TAB_LABEL); 425 RegisterTitle(localized_strings, "popups", 426 IDS_POPUP_TAB_LABEL); 427 RegisterTitle(localized_strings, "location", 428 IDS_GEOLOCATION_TAB_LABEL); 429 RegisterTitle(localized_strings, "notifications", 430 IDS_NOTIFICATIONS_TAB_LABEL); 431 RegisterTitle(localized_strings, "fullscreen", 432 IDS_FULLSCREEN_TAB_LABEL); 433 RegisterTitle(localized_strings, "mouselock", 434 IDS_MOUSE_LOCK_TAB_LABEL); 435 #if defined(OS_CHROMEOS) 436 RegisterTitle(localized_strings, "protectedContent", 437 IDS_PROTECTED_CONTENT_TAB_LABEL); 438 #endif 439 RegisterTitle(localized_strings, "media-stream", 440 IDS_MEDIA_STREAM_TAB_LABEL); 441 RegisterTitle(localized_strings, "ppapi-broker", 442 IDS_PPAPI_BROKER_TAB_LABEL); 443 RegisterTitle(localized_strings, "multiple-automatic-downloads", 444 IDS_AUTOMATIC_DOWNLOADS_TAB_LABEL); 445 RegisterTitle(localized_strings, "midi-sysex", 446 IDS_MIDI_SYSEX_TAB_LABEL); 447 RegisterTitle(localized_strings, "zoomlevels", 448 IDS_ZOOMLEVELS_HEADER_AND_TAB_LABEL); 449 450 localized_strings->SetString("exceptionsLearnMoreUrl", 451 kExceptionsLearnMoreUrl); 452 } 453 454 void ContentSettingsHandler::InitializeHandler() { 455 notification_registrar_.Add( 456 this, chrome::NOTIFICATION_PROFILE_CREATED, 457 content::NotificationService::AllSources()); 458 notification_registrar_.Add( 459 this, chrome::NOTIFICATION_PROFILE_DESTROYED, 460 content::NotificationService::AllSources()); 461 462 notification_registrar_.Add( 463 this, chrome::NOTIFICATION_DESKTOP_NOTIFICATION_SETTINGS_CHANGED, 464 content::NotificationService::AllSources()); 465 content::BrowserContext* context = GetBrowserContext(web_ui()); 466 notification_registrar_.Add( 467 this, chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED, 468 content::Source<content::BrowserContext>(context)); 469 470 PrefService* prefs = user_prefs::UserPrefs::Get(context); 471 pref_change_registrar_.Init(prefs); 472 pref_change_registrar_.Add( 473 prefs::kPepperFlashSettingsEnabled, 474 base::Bind(&ContentSettingsHandler::OnPepperFlashPrefChanged, 475 base::Unretained(this))); 476 pref_change_registrar_.Add( 477 prefs::kAudioCaptureAllowed, 478 base::Bind(&ContentSettingsHandler::UpdateMediaSettingsView, 479 base::Unretained(this))); 480 pref_change_registrar_.Add( 481 prefs::kVideoCaptureAllowed, 482 base::Bind(&ContentSettingsHandler::UpdateMediaSettingsView, 483 base::Unretained(this))); 484 pref_change_registrar_.Add( 485 prefs::kEnableDRM, 486 base::Bind( 487 &ContentSettingsHandler::UpdateProtectedContentExceptionsButton, 488 base::Unretained(this))); 489 490 content::HostZoomMap* host_zoom_map = 491 content::HostZoomMap::GetDefaultForBrowserContext(context); 492 host_zoom_map_subscription_ = 493 host_zoom_map->AddZoomLevelChangedCallback( 494 base::Bind(&ContentSettingsHandler::OnZoomLevelChanged, 495 base::Unretained(this))); 496 497 flash_settings_manager_.reset(new PepperFlashSettingsManager(this, context)); 498 499 Profile* profile = Profile::FromWebUI(web_ui()); 500 observer_.Add(profile->GetHostContentSettingsMap()); 501 if (profile->HasOffTheRecordProfile()) { 502 auto map = profile->GetOffTheRecordProfile()->GetHostContentSettingsMap(); 503 if (!observer_.IsObserving(map)) 504 observer_.Add(map); 505 } 506 } 507 508 void ContentSettingsHandler::InitializePage() { 509 media_settings_ = MediaSettingsInfo(); 510 RefreshFlashMediaSettings(); 511 512 UpdateHandlersEnabledRadios(); 513 UpdateAllExceptionsViewsFromModel(); 514 UpdateProtectedContentExceptionsButton(); 515 } 516 517 void ContentSettingsHandler::OnContentSettingChanged( 518 const ContentSettingsPattern& primary_pattern, 519 const ContentSettingsPattern& secondary_pattern, 520 ContentSettingsType content_type, 521 std::string resource_identifier) { 522 const ContentSettingsDetails details( 523 primary_pattern, secondary_pattern, content_type, resource_identifier); 524 // TODO(estade): we pretend update_all() is always true. 525 if (details.update_all_types()) 526 UpdateAllExceptionsViewsFromModel(); 527 else 528 UpdateExceptionsViewFromModel(details.type()); 529 } 530 531 void ContentSettingsHandler::Observe( 532 int type, 533 const content::NotificationSource& source, 534 const content::NotificationDetails& details) { 535 switch (type) { 536 case chrome::NOTIFICATION_PROFILE_DESTROYED: { 537 Profile* profile = content::Source<Profile>(source).ptr(); 538 if (profile->IsOffTheRecord() && 539 observer_.IsObserving(profile->GetHostContentSettingsMap())) { 540 web_ui()->CallJavascriptFunction( 541 "ContentSettingsExceptionsArea.OTRProfileDestroyed"); 542 observer_.Remove(profile->GetHostContentSettingsMap()); 543 } 544 break; 545 } 546 547 case chrome::NOTIFICATION_PROFILE_CREATED: { 548 Profile* profile = content::Source<Profile>(source).ptr(); 549 if (profile->IsOffTheRecord()) { 550 UpdateAllOTRExceptionsViewsFromModel(); 551 observer_.Add(profile->GetHostContentSettingsMap()); 552 } 553 break; 554 } 555 556 case chrome::NOTIFICATION_DESKTOP_NOTIFICATION_SETTINGS_CHANGED: { 557 UpdateNotificationExceptionsView(); 558 break; 559 } 560 561 case chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED: { 562 UpdateHandlersEnabledRadios(); 563 break; 564 } 565 } 566 } 567 568 void ContentSettingsHandler::OnGetPermissionSettingsCompleted( 569 uint32 request_id, 570 bool success, 571 PP_Flash_BrowserOperations_Permission default_permission, 572 const ppapi::FlashSiteSettings& sites) { 573 if (success && request_id == media_settings_.last_flash_refresh_request_id) { 574 media_settings_.flash_settings_initialized = true; 575 media_settings_.flash_default_setting = 576 PepperFlashContentSettingsUtils::FlashPermissionToContentSetting( 577 default_permission); 578 PepperFlashContentSettingsUtils::FlashSiteSettingsToMediaExceptions( 579 sites, &media_settings_.flash_exceptions); 580 PepperFlashContentSettingsUtils::SortMediaExceptions( 581 &media_settings_.flash_exceptions); 582 583 UpdateFlashMediaLinksVisibility(); 584 } 585 } 586 587 void ContentSettingsHandler::UpdateSettingDefaultFromModel( 588 ContentSettingsType type) { 589 base::DictionaryValue filter_settings; 590 std::string provider_id; 591 filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value", 592 GetSettingDefaultFromModel(type, &provider_id)); 593 filter_settings.SetString( 594 ContentSettingsTypeToGroupName(type) + ".managedBy", provider_id); 595 596 web_ui()->CallJavascriptFunction( 597 "ContentSettings.setContentFilterSettingsValue", filter_settings); 598 } 599 600 void ContentSettingsHandler::UpdateMediaSettingsView() { 601 PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui())); 602 bool audio_disabled = !prefs->GetBoolean(prefs::kAudioCaptureAllowed) && 603 prefs->IsManagedPreference(prefs::kAudioCaptureAllowed); 604 bool video_disabled = !prefs->GetBoolean(prefs::kVideoCaptureAllowed) && 605 prefs->IsManagedPreference(prefs::kVideoCaptureAllowed); 606 607 media_settings_.policy_disable_audio = audio_disabled; 608 media_settings_.policy_disable_video = video_disabled; 609 media_settings_.default_setting = 610 GetContentSettingsMap()->GetDefaultContentSetting( 611 CONTENT_SETTINGS_TYPE_MEDIASTREAM, NULL); 612 media_settings_.default_setting_initialized = true; 613 UpdateFlashMediaLinksVisibility(); 614 615 base::DictionaryValue media_ui_settings; 616 media_ui_settings.SetBoolean("cameraDisabled", video_disabled); 617 media_ui_settings.SetBoolean("micDisabled", audio_disabled); 618 619 // In case only video is enabled change the text appropriately. 620 if (audio_disabled && !video_disabled) { 621 media_ui_settings.SetString("askText", "mediaStreamVideoAsk"); 622 media_ui_settings.SetString("blockText", "mediaStreamVideoBlock"); 623 media_ui_settings.SetBoolean("showBubble", true); 624 media_ui_settings.SetString("bubbleText", "mediaStreamBubbleAudio"); 625 626 web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI", 627 media_ui_settings); 628 return; 629 } 630 631 // In case only audio is enabled change the text appropriately. 632 if (video_disabled && !audio_disabled) { 633 base::DictionaryValue media_ui_settings; 634 media_ui_settings.SetString("askText", "mediaStreamAudioAsk"); 635 media_ui_settings.SetString("blockText", "mediaStreamAudioBlock"); 636 media_ui_settings.SetBoolean("showBubble", true); 637 media_ui_settings.SetString("bubbleText", "mediaStreamBubbleVideo"); 638 639 web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI", 640 media_ui_settings); 641 return; 642 } 643 644 if (audio_disabled && video_disabled) { 645 // Fake policy controlled default because the user can not change anything 646 // until both audio and video are blocked. 647 base::DictionaryValue filter_settings; 648 std::string group_name = 649 ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_MEDIASTREAM); 650 filter_settings.SetString(group_name + ".value", 651 ContentSettingToString(CONTENT_SETTING_BLOCK)); 652 filter_settings.SetString(group_name + ".managedBy", "policy"); 653 web_ui()->CallJavascriptFunction( 654 "ContentSettings.setContentFilterSettingsValue", filter_settings); 655 } 656 657 media_ui_settings.SetString("askText", "mediaStreamAsk"); 658 media_ui_settings.SetString("blockText", "mediaStreamBlock"); 659 media_ui_settings.SetBoolean("showBubble", false); 660 media_ui_settings.SetString("bubbleText", std::string()); 661 662 web_ui()->CallJavascriptFunction("ContentSettings.updateMediaUI", 663 media_ui_settings); 664 } 665 666 std::string ContentSettingsHandler::GetSettingDefaultFromModel( 667 ContentSettingsType type, std::string* provider_id) { 668 Profile* profile = Profile::FromWebUI(web_ui()); 669 ContentSetting default_setting; 670 default_setting = 671 profile->GetHostContentSettingsMap()->GetDefaultContentSetting( 672 type, provider_id); 673 674 return ContentSettingToString(default_setting); 675 } 676 677 void ContentSettingsHandler::UpdateHandlersEnabledRadios() { 678 base::FundamentalValue handlers_enabled( 679 GetProtocolHandlerRegistry()->enabled()); 680 681 web_ui()->CallJavascriptFunction( 682 "ContentSettings.updateHandlersEnabledRadios", 683 handlers_enabled); 684 } 685 686 void ContentSettingsHandler::UpdateAllExceptionsViewsFromModel() { 687 for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1; 688 type < CONTENT_SETTINGS_NUM_TYPES; ++type) { 689 UpdateExceptionsViewFromModel(static_cast<ContentSettingsType>(type)); 690 } 691 // Zoom levels are not actually a content type so we need to handle them 692 // separately. 693 UpdateZoomLevelsExceptionsView(); 694 } 695 696 void ContentSettingsHandler::UpdateAllOTRExceptionsViewsFromModel() { 697 for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1; 698 type < CONTENT_SETTINGS_NUM_TYPES; ++type) { 699 UpdateOTRExceptionsViewFromModel(static_cast<ContentSettingsType>(type)); 700 } 701 } 702 703 void ContentSettingsHandler::UpdateExceptionsViewFromModel( 704 ContentSettingsType type) { 705 switch (type) { 706 case CONTENT_SETTINGS_TYPE_GEOLOCATION: 707 UpdateGeolocationExceptionsView(); 708 break; 709 case CONTENT_SETTINGS_TYPE_NOTIFICATIONS: 710 UpdateNotificationExceptionsView(); 711 break; 712 case CONTENT_SETTINGS_TYPE_MEDIASTREAM: 713 UpdateMediaSettingsView(); 714 break; 715 case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC: 716 case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA: 717 UpdateMediaExceptionsView(); 718 break; 719 case CONTENT_SETTINGS_TYPE_MIXEDSCRIPT: 720 // We don't yet support exceptions for mixed scripting. 721 break; 722 case CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE: 723 // The content settings type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE 724 // is supposed to be set by policy only. Hence there is no user facing UI 725 // for this content type and we skip it here. 726 break; 727 case CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS: 728 // The RPH settings are retrieved separately. 729 break; 730 case CONTENT_SETTINGS_TYPE_MIDI_SYSEX: 731 UpdateMIDISysExExceptionsView(); 732 break; 733 case CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS: 734 // The content settings type CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS is 735 // supposed to be set by flags and field trials only, thus there is no 736 // user facing UI for this content type and we skip it here. 737 break; 738 #if defined(OS_WIN) 739 case CONTENT_SETTINGS_TYPE_METRO_SWITCH_TO_DESKTOP: 740 break; 741 #endif 742 default: 743 UpdateExceptionsViewFromHostContentSettingsMap(type); 744 break; 745 } 746 } 747 748 void ContentSettingsHandler::UpdateOTRExceptionsViewFromModel( 749 ContentSettingsType type) { 750 switch (type) { 751 case CONTENT_SETTINGS_TYPE_GEOLOCATION: 752 case CONTENT_SETTINGS_TYPE_NOTIFICATIONS: 753 case CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE: 754 case CONTENT_SETTINGS_TYPE_MIXEDSCRIPT: 755 #if defined(OS_WIN) 756 case CONTENT_SETTINGS_TYPE_METRO_SWITCH_TO_DESKTOP: 757 #endif 758 case CONTENT_SETTINGS_TYPE_MEDIASTREAM: 759 case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC: 760 case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA: 761 case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS: 762 case CONTENT_SETTINGS_TYPE_MIDI_SYSEX: 763 case CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS: 764 break; 765 default: 766 UpdateExceptionsViewFromOTRHostContentSettingsMap(type); 767 break; 768 } 769 } 770 771 // TODO(estade): merge with GetExceptionsFromHostContentSettingsMap. 772 void ContentSettingsHandler::UpdateGeolocationExceptionsView() { 773 Profile* profile = Profile::FromWebUI(web_ui()); 774 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); 775 776 ContentSettingsForOneType all_settings; 777 map->GetSettingsForOneType( 778 CONTENT_SETTINGS_TYPE_GEOLOCATION, 779 std::string(), 780 &all_settings); 781 782 // Group geolocation settings by primary_pattern. 783 AllPatternsSettings all_patterns_settings; 784 for (ContentSettingsForOneType::iterator i = all_settings.begin(); 785 i != all_settings.end(); ++i) { 786 // Don't add default settings. 787 if (i->primary_pattern == ContentSettingsPattern::Wildcard() && 788 i->secondary_pattern == ContentSettingsPattern::Wildcard() && 789 i->source != kPreferencesSource) { 790 continue; 791 } 792 all_patterns_settings[std::make_pair(i->primary_pattern, i->source)] 793 [i->secondary_pattern] = i->setting; 794 } 795 796 base::ListValue exceptions; 797 AddExceptionsGrantedByHostedApps( 798 profile, 799 HostedAppHasPermission<APIPermission::kGeolocation>, 800 &exceptions); 801 802 for (AllPatternsSettings::iterator i = all_patterns_settings.begin(); 803 i != all_patterns_settings.end(); ++i) { 804 const ContentSettingsPattern& primary_pattern = i->first.first; 805 const OnePatternSettings& one_settings = i->second; 806 807 OnePatternSettings::const_iterator parent = 808 one_settings.find(primary_pattern); 809 810 // Add the "parent" entry for the non-embedded setting. 811 ContentSetting parent_setting = 812 parent == one_settings.end() ? CONTENT_SETTING_DEFAULT : parent->second; 813 exceptions.Append(GetGeolocationExceptionForPage(primary_pattern, 814 primary_pattern, 815 parent_setting)); 816 817 // Add the "children" for any embedded settings. 818 for (OnePatternSettings::const_iterator j = one_settings.begin(); 819 j != one_settings.end(); 820 ++j) { 821 // Skip the non-embedded setting which we already added above. 822 if (j == parent) 823 continue; 824 825 exceptions.Append(GetGeolocationExceptionForPage( 826 primary_pattern, j->first, j->second)); 827 } 828 } 829 830 base::StringValue type_string( 831 ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION)); 832 web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", 833 type_string, exceptions); 834 835 // This is mainly here to keep this function ideologically parallel to 836 // UpdateExceptionsViewFromHostContentSettingsMap(). 837 UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION); 838 } 839 840 void ContentSettingsHandler::UpdateNotificationExceptionsView() { 841 Profile* profile = Profile::FromWebUI(web_ui()); 842 ContentSettingsForOneType settings; 843 DesktopNotificationProfileUtil::GetNotificationsSettings(profile, &settings); 844 845 base::ListValue exceptions; 846 AddExceptionsGrantedByHostedApps( 847 profile, 848 HostedAppHasPermission<APIPermission::kNotifications>, 849 &exceptions); 850 851 for (ContentSettingsForOneType::const_iterator i = 852 settings.begin(); 853 i != settings.end(); 854 ++i) { 855 // Don't add default settings. 856 if (i->primary_pattern == ContentSettingsPattern::Wildcard() && 857 i->secondary_pattern == ContentSettingsPattern::Wildcard() && 858 i->source != kPreferencesSource) { 859 continue; 860 } 861 862 exceptions.Append( 863 GetNotificationExceptionForPage(i->primary_pattern, 864 i->secondary_pattern, 865 i->setting, 866 i->source)); 867 } 868 869 base::StringValue type_string( 870 ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS)); 871 web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", 872 type_string, exceptions); 873 874 // This is mainly here to keep this function ideologically parallel to 875 // UpdateExceptionsViewFromHostContentSettingsMap(). 876 UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS); 877 } 878 879 void ContentSettingsHandler::UpdateMediaExceptionsView() { 880 base::ListValue media_exceptions; 881 GetExceptionsFromHostContentSettingsMap( 882 GetContentSettingsMap(), 883 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, 884 &media_exceptions); 885 886 base::ListValue video_exceptions; 887 GetExceptionsFromHostContentSettingsMap( 888 GetContentSettingsMap(), 889 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, 890 &video_exceptions); 891 892 // Merge the |video_exceptions| list to |media_exceptions| list. 893 std::map<std::string, base::DictionaryValue*> entries_map; 894 for (base::ListValue::const_iterator media_entry(media_exceptions.begin()); 895 media_entry != media_exceptions.end(); ++media_entry) { 896 base::DictionaryValue* media_dict = NULL; 897 if (!(*media_entry)->GetAsDictionary(&media_dict)) 898 NOTREACHED(); 899 900 media_dict->SetString(kVideoSetting, 901 ContentSettingToString(CONTENT_SETTING_ASK)); 902 903 std::string media_origin; 904 media_dict->GetString(kOrigin, &media_origin); 905 entries_map[media_origin] = media_dict; 906 } 907 908 for (base::ListValue::iterator video_entry = video_exceptions.begin(); 909 video_entry != video_exceptions.end(); ++video_entry) { 910 base::DictionaryValue* video_dict = NULL; 911 if (!(*video_entry)->GetAsDictionary(&video_dict)) 912 NOTREACHED(); 913 914 std::string video_origin; 915 std::string video_setting; 916 video_dict->GetString(kOrigin, &video_origin); 917 video_dict->GetString(kSetting, &video_setting); 918 919 std::map<std::string, base::DictionaryValue*>::iterator iter = 920 entries_map.find(video_origin); 921 if (iter == entries_map.end()) { 922 base::DictionaryValue* exception = new base::DictionaryValue(); 923 exception->SetString(kOrigin, video_origin); 924 exception->SetString(kSetting, 925 ContentSettingToString(CONTENT_SETTING_ASK)); 926 exception->SetString(kVideoSetting, video_setting); 927 exception->SetString(kSource, kPreferencesSource); 928 929 // Append the new entry to the list and map. 930 media_exceptions.Append(exception); 931 entries_map[video_origin] = exception; 932 } else { 933 // Modify the existing entry. 934 iter->second->SetString(kVideoSetting, video_setting); 935 } 936 } 937 938 media_settings_.exceptions.clear(); 939 for (base::ListValue::const_iterator media_entry = media_exceptions.begin(); 940 media_entry != media_exceptions.end(); ++media_entry) { 941 base::DictionaryValue* media_dict = NULL; 942 bool result = (*media_entry)->GetAsDictionary(&media_dict); 943 DCHECK(result); 944 945 std::string origin; 946 std::string audio_setting; 947 std::string video_setting; 948 media_dict->GetString(kOrigin, &origin); 949 media_dict->GetString(kSetting, &audio_setting); 950 media_dict->GetString(kVideoSetting, &video_setting); 951 media_settings_.exceptions.push_back(MediaException( 952 ContentSettingsPattern::FromString(origin), 953 ContentSettingFromString(audio_setting), 954 ContentSettingFromString(video_setting))); 955 } 956 PepperFlashContentSettingsUtils::SortMediaExceptions( 957 &media_settings_.exceptions); 958 media_settings_.exceptions_initialized = true; 959 UpdateFlashMediaLinksVisibility(); 960 961 base::StringValue type_string( 962 ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_MEDIASTREAM)); 963 web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", 964 type_string, media_exceptions); 965 966 UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MEDIASTREAM); 967 } 968 969 void ContentSettingsHandler::UpdateMIDISysExExceptionsView() { 970 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableWebMIDI)) { 971 web_ui()->CallJavascriptFunction( 972 "ContentSettings.showExperimentalWebMIDISettings", 973 base::FundamentalValue(true)); 974 } 975 976 UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MIDI_SYSEX); 977 UpdateExceptionsViewFromHostContentSettingsMap( 978 CONTENT_SETTINGS_TYPE_MIDI_SYSEX); 979 } 980 981 void ContentSettingsHandler::UpdateZoomLevelsExceptionsView() { 982 base::ListValue zoom_levels_exceptions; 983 984 content::HostZoomMap* host_zoom_map = 985 content::HostZoomMap::GetDefaultForBrowserContext( 986 GetBrowserContext(web_ui())); 987 content::HostZoomMap::ZoomLevelVector zoom_levels( 988 host_zoom_map->GetAllZoomLevels()); 989 std::sort(zoom_levels.begin(), zoom_levels.end(), HostZoomSort); 990 991 for (content::HostZoomMap::ZoomLevelVector::const_iterator i = 992 zoom_levels.begin(); 993 i != zoom_levels.end(); 994 ++i) { 995 scoped_ptr<base::DictionaryValue> exception(new base::DictionaryValue); 996 switch (i->mode) { 997 case content::HostZoomMap::ZOOM_CHANGED_FOR_HOST: 998 exception->SetString(kOrigin, i->host); 999 break; 1000 case content::HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST: 1001 // These are not stored in preferences and get cleared on next browser 1002 // start. Therefore, we don't care for them. 1003 break; 1004 case content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM: 1005 NOTREACHED(); 1006 } 1007 exception->SetString(kSetting, 1008 ContentSettingToString(CONTENT_SETTING_DEFAULT)); 1009 1010 // Calculate the zoom percent from the factor. Round up to the nearest whole 1011 // number. 1012 int zoom_percent = static_cast<int>( 1013 content::ZoomLevelToZoomFactor(i->zoom_level) * 100 + 0.5); 1014 exception->SetString( 1015 kZoom, 1016 l10n_util::GetStringFUTF16(IDS_ZOOM_PERCENT, 1017 base::IntToString16(zoom_percent))); 1018 exception->SetString(kSource, kPreferencesSource); 1019 // Append the new entry to the list and map. 1020 zoom_levels_exceptions.Append(exception.release()); 1021 } 1022 1023 base::StringValue type_string(kZoomContentType); 1024 web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", 1025 type_string, zoom_levels_exceptions); 1026 } 1027 1028 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap( 1029 ContentSettingsType type) { 1030 base::ListValue exceptions; 1031 GetExceptionsFromHostContentSettingsMap( 1032 GetContentSettingsMap(), type, &exceptions); 1033 base::StringValue type_string(ContentSettingsTypeToGroupName(type)); 1034 web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string, 1035 exceptions); 1036 1037 UpdateExceptionsViewFromOTRHostContentSettingsMap(type); 1038 1039 // TODO(koz): The default for fullscreen is always 'ask'. 1040 // http://crbug.com/104683 1041 if (type == CONTENT_SETTINGS_TYPE_FULLSCREEN) 1042 return; 1043 1044 #if defined(OS_CHROMEOS) 1045 // Also the default for protected contents is managed in another place. 1046 if (type == CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER) 1047 return; 1048 #endif 1049 1050 // The default may also have changed (we won't get a separate notification). 1051 // If it hasn't changed, this call will be harmless. 1052 UpdateSettingDefaultFromModel(type); 1053 } 1054 1055 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap( 1056 ContentSettingsType type) { 1057 const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap(); 1058 if (!otr_settings_map) 1059 return; 1060 base::ListValue exceptions; 1061 GetExceptionsFromHostContentSettingsMap(otr_settings_map, type, &exceptions); 1062 base::StringValue type_string(ContentSettingsTypeToGroupName(type)); 1063 web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions", 1064 type_string, exceptions); 1065 } 1066 1067 void ContentSettingsHandler::GetExceptionsFromHostContentSettingsMap( 1068 const HostContentSettingsMap* map, 1069 ContentSettingsType type, 1070 base::ListValue* exceptions) { 1071 ContentSettingsForOneType entries; 1072 map->GetSettingsForOneType(type, std::string(), &entries); 1073 // Group settings by primary_pattern. 1074 AllPatternsSettings all_patterns_settings; 1075 for (ContentSettingsForOneType::iterator i = entries.begin(); 1076 i != entries.end(); ++i) { 1077 // Don't add default settings. 1078 if (i->primary_pattern == ContentSettingsPattern::Wildcard() && 1079 i->secondary_pattern == ContentSettingsPattern::Wildcard() && 1080 i->source != kPreferencesSource) { 1081 continue; 1082 } 1083 1084 // Off-the-record HostContentSettingsMap contains incognito content settings 1085 // as well as normal content settings. Here, we use the incongnito settings 1086 // only. 1087 if (map->is_off_the_record() && !i->incognito) 1088 continue; 1089 1090 all_patterns_settings[std::make_pair(i->primary_pattern, i->source)] 1091 [i->secondary_pattern] = i->setting; 1092 } 1093 1094 // Keep the exceptions sorted by provider so they will be displayed in 1095 // precedence order. 1096 std::vector<std::vector<base::Value*> > all_provider_exceptions; 1097 all_provider_exceptions.resize(HostContentSettingsMap::NUM_PROVIDER_TYPES); 1098 1099 for (AllPatternsSettings::iterator i = all_patterns_settings.begin(); 1100 i != all_patterns_settings.end(); 1101 ++i) { 1102 const ContentSettingsPattern& primary_pattern = i->first.first; 1103 const OnePatternSettings& one_settings = i->second; 1104 1105 // The "parent" entry either has an identical primary and secondary pattern, 1106 // or has a wildcard secondary. The two cases are indistinguishable in the 1107 // UI. 1108 OnePatternSettings::const_iterator parent = 1109 one_settings.find(primary_pattern); 1110 if (parent == one_settings.end()) 1111 parent = one_settings.find(ContentSettingsPattern::Wildcard()); 1112 1113 const std::string& source = i->first.second; 1114 std::vector<base::Value*>* this_provider_exceptions = 1115 &all_provider_exceptions.at( 1116 HostContentSettingsMap::GetProviderTypeFromSource(source)); 1117 1118 // Add the "parent" entry for the non-embedded setting. 1119 ContentSetting parent_setting = 1120 parent == one_settings.end() ? CONTENT_SETTING_DEFAULT : parent->second; 1121 const ContentSettingsPattern& secondary_pattern = 1122 parent == one_settings.end() ? primary_pattern : parent->first; 1123 this_provider_exceptions->push_back(GetExceptionForPage(primary_pattern, 1124 secondary_pattern, 1125 parent_setting, 1126 source)); 1127 1128 // Add the "children" for any embedded settings. 1129 for (OnePatternSettings::const_iterator j = one_settings.begin(); 1130 j != one_settings.end(); ++j) { 1131 // Skip the non-embedded setting which we already added above. 1132 if (j == parent) 1133 continue; 1134 1135 ContentSetting content_setting = j->second; 1136 this_provider_exceptions->push_back(GetExceptionForPage( 1137 primary_pattern, 1138 j->first, 1139 content_setting, 1140 source)); 1141 } 1142 } 1143 1144 for (size_t i = 0; i < all_provider_exceptions.size(); ++i) { 1145 for (size_t j = 0; j < all_provider_exceptions[i].size(); ++j) { 1146 exceptions->Append(all_provider_exceptions[i][j]); 1147 } 1148 } 1149 } 1150 1151 void ContentSettingsHandler::RemoveMediaException(const base::ListValue* args) { 1152 std::string mode; 1153 bool rv = args->GetString(1, &mode); 1154 DCHECK(rv); 1155 1156 std::string pattern; 1157 rv = args->GetString(2, &pattern); 1158 DCHECK(rv); 1159 1160 HostContentSettingsMap* settings_map = 1161 mode == "normal" ? GetContentSettingsMap() : 1162 GetOTRContentSettingsMap(); 1163 if (settings_map) { 1164 settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern), 1165 ContentSettingsPattern::Wildcard(), 1166 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, 1167 std::string(), 1168 NULL); 1169 settings_map->SetWebsiteSetting(ContentSettingsPattern::FromString(pattern), 1170 ContentSettingsPattern::Wildcard(), 1171 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, 1172 std::string(), 1173 NULL); 1174 } 1175 } 1176 1177 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap( 1178 const base::ListValue* args, 1179 ContentSettingsType type) { 1180 std::string mode; 1181 bool rv = args->GetString(1, &mode); 1182 DCHECK(rv); 1183 1184 std::string pattern; 1185 rv = args->GetString(2, &pattern); 1186 DCHECK(rv); 1187 1188 // The fourth argument to this handler is optional. 1189 std::string secondary_pattern; 1190 if (args->GetSize() >= 4U) { 1191 rv = args->GetString(3, &secondary_pattern); 1192 DCHECK(rv); 1193 } 1194 1195 HostContentSettingsMap* settings_map = 1196 mode == "normal" ? GetContentSettingsMap() : 1197 GetOTRContentSettingsMap(); 1198 if (settings_map) { 1199 settings_map->SetWebsiteSetting( 1200 ContentSettingsPattern::FromString(pattern), 1201 secondary_pattern.empty() ? 1202 ContentSettingsPattern::Wildcard() : 1203 ContentSettingsPattern::FromString(secondary_pattern), 1204 type, 1205 std::string(), 1206 NULL); 1207 } 1208 } 1209 1210 void ContentSettingsHandler::RemoveZoomLevelException( 1211 const base::ListValue* args) { 1212 std::string mode; 1213 bool rv = args->GetString(1, &mode); 1214 DCHECK(rv); 1215 1216 std::string pattern; 1217 rv = args->GetString(2, &pattern); 1218 DCHECK(rv); 1219 1220 content::HostZoomMap* host_zoom_map = 1221 content::HostZoomMap::GetDefaultForBrowserContext( 1222 GetBrowserContext(web_ui())); 1223 double default_level = host_zoom_map->GetDefaultZoomLevel(); 1224 host_zoom_map->SetZoomLevelForHost(pattern, default_level); 1225 } 1226 1227 void ContentSettingsHandler::RegisterMessages() { 1228 web_ui()->RegisterMessageCallback("setContentFilter", 1229 base::Bind(&ContentSettingsHandler::SetContentFilter, 1230 base::Unretained(this))); 1231 web_ui()->RegisterMessageCallback("removeException", 1232 base::Bind(&ContentSettingsHandler::RemoveException, 1233 base::Unretained(this))); 1234 web_ui()->RegisterMessageCallback("setException", 1235 base::Bind(&ContentSettingsHandler::SetException, 1236 base::Unretained(this))); 1237 web_ui()->RegisterMessageCallback("checkExceptionPatternValidity", 1238 base::Bind(&ContentSettingsHandler::CheckExceptionPatternValidity, 1239 base::Unretained(this))); 1240 } 1241 1242 void ContentSettingsHandler::SetContentFilter(const base::ListValue* args) { 1243 DCHECK_EQ(2U, args->GetSize()); 1244 std::string group, setting; 1245 if (!(args->GetString(0, &group) && 1246 args->GetString(1, &setting))) { 1247 NOTREACHED(); 1248 return; 1249 } 1250 1251 ContentSetting default_setting = ContentSettingFromString(setting); 1252 ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group); 1253 Profile* profile = Profile::FromWebUI(web_ui()); 1254 1255 #if defined(OS_CHROMEOS) 1256 // ChromeOS special case : in Guest mode settings are opened in Incognito 1257 // mode, so we need original profile to actually modify settings. 1258 if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) 1259 profile = profile->GetOriginalProfile(); 1260 #endif 1261 1262 1263 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); 1264 map->SetDefaultContentSetting(content_type, default_setting); 1265 1266 switch (content_type) { 1267 case CONTENT_SETTINGS_TYPE_COOKIES: 1268 content::RecordAction( 1269 UserMetricsAction("Options_DefaultCookieSettingChanged")); 1270 break; 1271 case CONTENT_SETTINGS_TYPE_IMAGES: 1272 content::RecordAction( 1273 UserMetricsAction("Options_DefaultImagesSettingChanged")); 1274 break; 1275 case CONTENT_SETTINGS_TYPE_JAVASCRIPT: 1276 content::RecordAction( 1277 UserMetricsAction("Options_DefaultJavaScriptSettingChanged")); 1278 break; 1279 case CONTENT_SETTINGS_TYPE_PLUGINS: 1280 content::RecordAction( 1281 UserMetricsAction("Options_DefaultPluginsSettingChanged")); 1282 break; 1283 case CONTENT_SETTINGS_TYPE_POPUPS: 1284 content::RecordAction( 1285 UserMetricsAction("Options_DefaultPopupsSettingChanged")); 1286 break; 1287 case CONTENT_SETTINGS_TYPE_NOTIFICATIONS: 1288 content::RecordAction( 1289 UserMetricsAction("Options_DefaultNotificationsSettingChanged")); 1290 break; 1291 case CONTENT_SETTINGS_TYPE_GEOLOCATION: 1292 content::RecordAction( 1293 UserMetricsAction("Options_DefaultGeolocationSettingChanged")); 1294 break; 1295 case CONTENT_SETTINGS_TYPE_MOUSELOCK: 1296 content::RecordAction( 1297 UserMetricsAction("Options_DefaultMouseLockSettingChanged")); 1298 break; 1299 case CONTENT_SETTINGS_TYPE_MEDIASTREAM: 1300 content::RecordAction( 1301 UserMetricsAction("Options_DefaultMediaStreamMicSettingChanged")); 1302 break; 1303 case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS: 1304 content::RecordAction( 1305 UserMetricsAction("Options_DefaultMultipleAutomaticDLSettingChange")); 1306 break; 1307 case CONTENT_SETTINGS_TYPE_MIDI_SYSEX: 1308 content::RecordAction( 1309 UserMetricsAction("Options_DefaultMIDISysExSettingChanged")); 1310 break; 1311 case CONTENT_SETTINGS_TYPE_PUSH_MESSAGING: 1312 content::RecordAction( 1313 UserMetricsAction("Options_DefaultPushMessagingSettingChanged")); 1314 break; 1315 default: 1316 break; 1317 } 1318 } 1319 1320 void ContentSettingsHandler::RemoveException(const base::ListValue* args) { 1321 std::string type_string; 1322 CHECK(args->GetString(0, &type_string)); 1323 1324 // Zoom levels are no actual content type so we need to handle them 1325 // separately. They would not be recognized by 1326 // ContentSettingsTypeFromGroupName. 1327 if (type_string == kZoomContentType) { 1328 RemoveZoomLevelException(args); 1329 return; 1330 } 1331 1332 ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string); 1333 if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) 1334 RemoveMediaException(args); 1335 else 1336 RemoveExceptionFromHostContentSettingsMap(args, type); 1337 } 1338 1339 void ContentSettingsHandler::SetException(const base::ListValue* args) { 1340 std::string type_string; 1341 CHECK(args->GetString(0, &type_string)); 1342 std::string mode; 1343 CHECK(args->GetString(1, &mode)); 1344 std::string pattern; 1345 CHECK(args->GetString(2, &pattern)); 1346 std::string setting; 1347 CHECK(args->GetString(3, &setting)); 1348 1349 ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string); 1350 if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION || 1351 type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS || 1352 type == CONTENT_SETTINGS_TYPE_MEDIASTREAM || 1353 type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC || 1354 type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) { 1355 NOTREACHED(); 1356 } else { 1357 HostContentSettingsMap* settings_map = 1358 mode == "normal" ? GetContentSettingsMap() : 1359 GetOTRContentSettingsMap(); 1360 1361 // The settings map could be null if the mode was OTR but the OTR profile 1362 // got destroyed before we received this message. 1363 if (!settings_map) 1364 return; 1365 settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern), 1366 ContentSettingsPattern::Wildcard(), 1367 type, 1368 std::string(), 1369 ContentSettingFromString(setting)); 1370 } 1371 } 1372 1373 void ContentSettingsHandler::CheckExceptionPatternValidity( 1374 const base::ListValue* args) { 1375 std::string type_string; 1376 CHECK(args->GetString(0, &type_string)); 1377 std::string mode_string; 1378 CHECK(args->GetString(1, &mode_string)); 1379 std::string pattern_string; 1380 CHECK(args->GetString(2, &pattern_string)); 1381 1382 ContentSettingsPattern pattern = 1383 ContentSettingsPattern::FromString(pattern_string); 1384 1385 web_ui()->CallJavascriptFunction( 1386 "ContentSettings.patternValidityCheckComplete", 1387 base::StringValue(type_string), 1388 base::StringValue(mode_string), 1389 base::StringValue(pattern_string), 1390 base::FundamentalValue(pattern.IsValid())); 1391 } 1392 1393 // static 1394 std::string ContentSettingsHandler::ContentSettingsTypeToGroupName( 1395 ContentSettingsType type) { 1396 for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) { 1397 if (type == kContentSettingsTypeGroupNames[i].type) 1398 return kContentSettingsTypeGroupNames[i].name; 1399 } 1400 1401 NOTREACHED(); 1402 return std::string(); 1403 } 1404 1405 HostContentSettingsMap* ContentSettingsHandler::GetContentSettingsMap() { 1406 return Profile::FromWebUI(web_ui())->GetHostContentSettingsMap(); 1407 } 1408 1409 ProtocolHandlerRegistry* ContentSettingsHandler::GetProtocolHandlerRegistry() { 1410 return ProtocolHandlerRegistryFactory::GetForBrowserContext( 1411 GetBrowserContext(web_ui())); 1412 } 1413 1414 HostContentSettingsMap* 1415 ContentSettingsHandler::GetOTRContentSettingsMap() { 1416 Profile* profile = Profile::FromWebUI(web_ui()); 1417 if (profile->HasOffTheRecordProfile()) 1418 return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap(); 1419 return NULL; 1420 } 1421 1422 void ContentSettingsHandler::RefreshFlashMediaSettings() { 1423 media_settings_.flash_settings_initialized = false; 1424 1425 media_settings_.last_flash_refresh_request_id = 1426 flash_settings_manager_->GetPermissionSettings( 1427 PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC); 1428 } 1429 1430 void ContentSettingsHandler::OnPepperFlashPrefChanged() { 1431 ShowFlashMediaLink(DEFAULT_SETTING, false); 1432 ShowFlashMediaLink(EXCEPTIONS, false); 1433 1434 PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui())); 1435 if (prefs->GetBoolean(prefs::kPepperFlashSettingsEnabled)) 1436 RefreshFlashMediaSettings(); 1437 else 1438 media_settings_.flash_settings_initialized = false; 1439 } 1440 1441 void ContentSettingsHandler::OnZoomLevelChanged( 1442 const content::HostZoomMap::ZoomLevelChange& change) { 1443 UpdateZoomLevelsExceptionsView(); 1444 } 1445 1446 void ContentSettingsHandler::ShowFlashMediaLink(LinkType link_type, bool show) { 1447 bool& show_link = link_type == DEFAULT_SETTING ? 1448 media_settings_.show_flash_default_link : 1449 media_settings_.show_flash_exceptions_link; 1450 if (show_link != show) { 1451 web_ui()->CallJavascriptFunction( 1452 link_type == DEFAULT_SETTING ? 1453 "ContentSettings.showMediaPepperFlashDefaultLink" : 1454 "ContentSettings.showMediaPepperFlashExceptionsLink", 1455 base::FundamentalValue(show)); 1456 show_link = show; 1457 } 1458 } 1459 1460 void ContentSettingsHandler::UpdateFlashMediaLinksVisibility() { 1461 if (!media_settings_.flash_settings_initialized || 1462 !media_settings_.default_setting_initialized || 1463 !media_settings_.exceptions_initialized) { 1464 return; 1465 } 1466 1467 // Flash won't send us notifications when its settings get changed, which 1468 // means the Flash settings in |media_settings_| may be out-dated, especially 1469 // after we show links to change Flash settings. 1470 // In order to avoid confusion, we won't hide the links once they are showed. 1471 // One exception is that we will hide them when Pepper Flash is disabled 1472 // (handled in OnPepperFlashPrefChanged()). 1473 if (media_settings_.show_flash_default_link && 1474 media_settings_.show_flash_exceptions_link) { 1475 return; 1476 } 1477 1478 if (!media_settings_.show_flash_default_link) { 1479 // If both audio and video capture are disabled by policy, the link 1480 // shouldn't be showed. Flash conforms to the policy in this case because 1481 // it cannot open those devices. We don't have to look at the Flash 1482 // settings. 1483 if (!(media_settings_.policy_disable_audio && 1484 media_settings_.policy_disable_video) && 1485 media_settings_.flash_default_setting != 1486 media_settings_.default_setting) { 1487 ShowFlashMediaLink(DEFAULT_SETTING, true); 1488 } 1489 } 1490 if (!media_settings_.show_flash_exceptions_link) { 1491 // If audio or video capture is disabled by policy, we skip comparison of 1492 // exceptions for audio or video capture, respectively. 1493 if (!PepperFlashContentSettingsUtils::AreMediaExceptionsEqual( 1494 media_settings_.default_setting, 1495 media_settings_.exceptions, 1496 media_settings_.flash_default_setting, 1497 media_settings_.flash_exceptions, 1498 media_settings_.policy_disable_audio, 1499 media_settings_.policy_disable_video)) { 1500 ShowFlashMediaLink(EXCEPTIONS, true); 1501 } 1502 } 1503 } 1504 1505 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() { 1506 #if defined(OS_CHROMEOS) 1507 // Guests cannot modify exceptions. UIAccountTweaks will disabled the button. 1508 if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) 1509 return; 1510 #endif 1511 1512 // Exceptions apply only when the feature is enabled. 1513 PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui())); 1514 bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM); 1515 web_ui()->CallJavascriptFunction( 1516 "ContentSettings.enableProtectedContentExceptions", 1517 base::FundamentalValue(enable_exceptions)); 1518 } 1519 1520 } // namespace options 1521
