| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/website_settings_handler.h" | |
| 6 | |
| 7 #include "base/metrics/histogram.h" | |
| 8 #include "chrome/browser/profiles/profile.h" | |
| 9 #include "chrome/browser/ui/browser.h" | |
| 10 #include "chrome/browser/ui/browser_iterator.h" | |
| 11 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 12 #include "chrome/grit/generated_resources.h" | |
| 13 #include "components/content_settings/core/browser/content_settings_utils.h" | |
| 14 #include "components/content_settings/core/browser/host_content_settings_map.h" | |
| 15 #include "components/power/origin_power_map.h" | |
| 16 #include "components/power/origin_power_map_factory.h" | |
| 17 #include "content/public/browser/dom_storage_context.h" | |
| 18 #include "content/public/browser/storage_partition.h" | |
| 19 #include "content/public/browser/user_metrics.h" | |
| 20 #include "content/public/browser/web_contents.h" | |
| 21 #include "content/public/browser/web_ui.h" | |
| 22 #include "extensions/browser/app_window/app_window_registry.h" | |
| 23 #include "extensions/browser/extension_registry.h" | |
| 24 #include "extensions/common/constants.h" | |
| 25 #include "extensions/common/extension.h" | |
| 26 #include "ui/base/l10n/l10n_util.h" | |
| 27 #include "ui/base/l10n/time_format.h" | |
| 28 #include "ui/base/text/bytes_formatting.h" | |
| 29 | |
| 30 #if defined(OS_CHROMEOS) | |
| 31 #include "components/user_manager/user_manager.h" | |
| 32 #endif | |
| 33 | |
| 34 using base::UserMetricsAction; | |
| 35 using power::OriginPowerMap; | |
| 36 using power::OriginPowerMapFactory; | |
| 37 | |
| 38 namespace { | |
| 39 | |
| 40 const char kBattery[] = "battery"; | |
| 41 const int kHttpPort = 80; | |
| 42 const int kHttpsPort = 443; | |
| 43 const char kPreferencesSource[] = "preference"; | |
| 44 const char kStorage[] = "storage"; | |
| 45 const ContentSettingsType kValidTypes[] = { | |
| 46 CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, | |
| 47 CONTENT_SETTINGS_TYPE_COOKIES, | |
| 48 CONTENT_SETTINGS_TYPE_GEOLOCATION, | |
| 49 CONTENT_SETTINGS_TYPE_IMAGES, | |
| 50 CONTENT_SETTINGS_TYPE_JAVASCRIPT, | |
| 51 CONTENT_SETTINGS_TYPE_NOTIFICATIONS, | |
| 52 CONTENT_SETTINGS_TYPE_MEDIASTREAM, | |
| 53 CONTENT_SETTINGS_TYPE_PLUGINS, | |
| 54 CONTENT_SETTINGS_TYPE_POPUPS}; | |
| 55 const size_t kValidTypesLength = arraysize(kValidTypes); | |
| 56 | |
| 57 // Enumeration used for UMA Histograms of parsing last_setting_. | |
| 58 // Do not insert, remove, or reorder. Add only to end. | |
| 59 // TODO: Remove histogram by 2015. crbug.com/433475 | |
| 60 enum LastSettingParsed { | |
| 61 UPDATE_EMPTY, | |
| 62 UPDATE_PARSED, | |
| 63 UPDATE_INVALID, | |
| 64 UPDATE_ORIGINS_EMPTY, | |
| 65 UPDATE_ORIGINS_PARSED, | |
| 66 UPDATE_ORIGINS_INVALID, | |
| 67 HANDLE_UPDATE_ORIGINS_EMPTY, | |
| 68 HANDLE_UPDATE_ORIGINS_PARSED, | |
| 69 HANDLE_UPDATE_ORIGINS_INVALID, | |
| 70 LAST_SETTING_MAX_ENUMERATION_VALUE | |
| 71 }; | |
| 72 | |
| 73 void RecordUmaHistogramOfLastSetting(LastSettingParsed parsed) { | |
| 74 UMA_HISTOGRAM_ENUMERATION("ContentSettings.LastSettingParsed", parsed, | |
| 75 LAST_SETTING_MAX_ENUMERATION_VALUE); | |
| 76 } | |
| 77 | |
| 78 } // namespace | |
| 79 | |
| 80 namespace options { | |
| 81 | |
| 82 WebsiteSettingsHandler::WebsiteSettingsHandler() | |
| 83 : observer_(this), | |
| 84 weak_ptr_factory_(this) { | |
| 85 } | |
| 86 | |
| 87 WebsiteSettingsHandler::~WebsiteSettingsHandler() { | |
| 88 } | |
| 89 | |
| 90 void WebsiteSettingsHandler::GetLocalizedValues( | |
| 91 base::DictionaryValue* localized_strings) { | |
| 92 DCHECK(localized_strings); | |
| 93 | |
| 94 static OptionsStringResource resources[] = { | |
| 95 {"websitesOptionsPageTabTitle", IDS_WEBSITE_SETTINGS_TITLE}, | |
| 96 {"websitesSettingsEditPage", IDS_WEBSITE_SETTINGS_EDIT_TITLE}, | |
| 97 {"websitesManage", IDS_WEBSITE_SETTINGS_MANAGE}, | |
| 98 {"websitesSearch", IDS_WEBSITE_SETTINGS_SEARCH_ORIGINS}, | |
| 99 {"websitesLabelLocation", IDS_WEBSITE_SETTINGS_TYPE_LOCATION}, | |
| 100 {"websitesLabelMediaStream", IDS_WEBSITE_SETTINGS_TYPE_MEDIASTREAM}, | |
| 101 {"websitesLabelNotifications", IDS_WEBSITE_SETTINGS_TYPE_NOTIFICATIONS}, | |
| 102 {"websitesLabelOn", IDS_WEBSITE_SETTINGS_CONTENT_SETTING_ENABLED}, | |
| 103 {"websitesLabelStorage", IDS_WEBSITE_SETTINGS_TYPE_STORAGE}, | |
| 104 {"websitesLabelBattery", IDS_WEBSITE_SETTINGS_TYPE_BATTERY}, | |
| 105 {"websitesCookiesDescription", IDS_WEBSITE_SETTINGS_COOKIES_DESCRIPTION}, | |
| 106 {"websitesLocationDescription", | |
| 107 IDS_WEBSITE_SETTINGS_LOCATION_DESCRIPTION}, | |
| 108 {"websitesMediaStreamDescription", | |
| 109 IDS_WEBSITE_SETTINGS_MEDIASTREAM_DESCRIPTION}, | |
| 110 {"websitesNotificationsDescription", | |
| 111 IDS_WEBSITE_SETTINGS_NOTIFICATIONS_DESCRIPTION}, | |
| 112 {"websitesDownloadsDescription", | |
| 113 IDS_WEBSITE_SETTINGS_DOWNLOAD_DESCRIPTION}, | |
| 114 {"websitesPluginsDescription", IDS_WEBSITE_SETTINGS_PLUGINS_DESCRIPTION}, | |
| 115 {"websitesPopupsDescription", IDS_WEBSITE_SETTINGS_POPUPS_DESCRIPTION}, | |
| 116 {"websitesJavascriptDescription", | |
| 117 IDS_WEBSITE_SETTINGS_JAVASCRIPT_DESCRIPTION}, | |
| 118 {"websitesImagesDescription", IDS_WEBSITE_SETTINGS_IMAGES_DESCRIPTION}, | |
| 119 {"websitesButtonClear", IDS_WEBSITE_SETTINGS_STORAGE_CLEAR_BUTTON}, | |
| 120 {"websitesButtonStop", IDS_WEBSITE_SETTINGS_BATTERY_STOP_BUTTON}, | |
| 121 {"websitesAllowedListTitle", IDS_WEBSITE_SETTINGS_ALLOWED_LIST_TITLE}, | |
| 122 {"websitesBlockedListTitle", IDS_WEBSITE_SETTINGS_BLOCKED_LIST_TITLE}, | |
| 123 {"storageTabLabel", IDS_WEBSITE_SETTINGS_TYPE_STORAGE}, | |
| 124 {"batteryTabLabel", IDS_WEBSITE_SETTINGS_TYPE_BATTERY}, | |
| 125 }; | |
| 126 | |
| 127 RegisterStrings(localized_strings, resources, arraysize(resources)); | |
| 128 RegisterTitle( | |
| 129 localized_strings, "websiteSettingsPage", IDS_WEBSITE_SETTINGS_TITLE); | |
| 130 } | |
| 131 | |
| 132 void WebsiteSettingsHandler::InitializeHandler() { | |
| 133 Profile* profile = GetProfile(); | |
| 134 HostContentSettingsMap* settings = profile->GetHostContentSettingsMap(); | |
| 135 observer_.Add(settings); | |
| 136 | |
| 137 power::OriginPowerMap* origin_power_map = | |
| 138 power::OriginPowerMapFactory::GetForBrowserContext(profile); | |
| 139 // OriginPowerMap may not be available in tests. | |
| 140 if (origin_power_map) { | |
| 141 subscription_ = origin_power_map->AddPowerConsumptionUpdatedCallback( | |
| 142 base::Bind(&WebsiteSettingsHandler::Update, base::Unretained(this))); | |
| 143 } | |
| 144 } | |
| 145 | |
| 146 void WebsiteSettingsHandler::RegisterMessages() { | |
| 147 web_ui()->RegisterMessageCallback( | |
| 148 "updateOrigins", | |
| 149 base::Bind(&WebsiteSettingsHandler::HandleUpdateOrigins, | |
| 150 base::Unretained(this))); | |
| 151 | |
| 152 web_ui()->RegisterMessageCallback( | |
| 153 "updateOriginsSearchResults", | |
| 154 base::Bind(&WebsiteSettingsHandler::HandleUpdateSearchResults, | |
| 155 base::Unretained(this))); | |
| 156 | |
| 157 web_ui()->RegisterMessageCallback( | |
| 158 "updateLocalStorage", | |
| 159 base::Bind(&WebsiteSettingsHandler::HandleUpdateLocalStorage, | |
| 160 base::Unretained(this))); | |
| 161 | |
| 162 web_ui()->RegisterMessageCallback( | |
| 163 "updateBatteryUsage", | |
| 164 base::Bind(&WebsiteSettingsHandler::HandleUpdateBatteryUsage, | |
| 165 base::Unretained(this))); | |
| 166 | |
| 167 web_ui()->RegisterMessageCallback( | |
| 168 "getOriginInfo", | |
| 169 base::Bind(&WebsiteSettingsHandler::HandleGetOriginInfo, | |
| 170 base::Unretained(this))); | |
| 171 | |
| 172 web_ui()->RegisterMessageCallback( | |
| 173 "setOriginPermission", | |
| 174 base::Bind(&WebsiteSettingsHandler::HandleSetOriginPermission, | |
| 175 base::Unretained(this))); | |
| 176 | |
| 177 web_ui()->RegisterMessageCallback( | |
| 178 "maybeShowEditPage", | |
| 179 base::Bind(&WebsiteSettingsHandler::HandleMaybeShowEditPage, | |
| 180 base::Unretained(this))); | |
| 181 | |
| 182 web_ui()->RegisterMessageCallback( | |
| 183 "deleteLocalStorage", | |
| 184 base::Bind(&WebsiteSettingsHandler::HandleDeleteLocalStorage, | |
| 185 base::Unretained(this))); | |
| 186 | |
| 187 web_ui()->RegisterMessageCallback( | |
| 188 "stopOrigin", | |
| 189 base::Bind(&WebsiteSettingsHandler::HandleStopOrigin, | |
| 190 base::Unretained(this))); | |
| 191 | |
| 192 web_ui()->RegisterMessageCallback( | |
| 193 "updateDefaultSetting", | |
| 194 base::Bind(&WebsiteSettingsHandler::HandleUpdateDefaultSetting, | |
| 195 base::Unretained(this))); | |
| 196 | |
| 197 web_ui()->RegisterMessageCallback( | |
| 198 "setDefaultContentSetting", | |
| 199 base::Bind(&WebsiteSettingsHandler::HandleSetDefaultSetting, | |
| 200 base::Unretained(this))); | |
| 201 | |
| 202 web_ui()->RegisterMessageCallback( | |
| 203 "setGlobalEnabled", | |
| 204 base::Bind(&WebsiteSettingsHandler::HandleSetGlobalToggle, | |
| 205 base::Unretained(this))); | |
| 206 } | |
| 207 | |
| 208 // content_settings::Observer implementation. | |
| 209 void WebsiteSettingsHandler::OnContentSettingChanged( | |
| 210 const ContentSettingsPattern& primary_pattern, | |
| 211 const ContentSettingsPattern& secondary_pattern, | |
| 212 ContentSettingsType content_type, | |
| 213 std::string resource_identifier) { | |
| 214 Update(); | |
| 215 } | |
| 216 | |
| 217 void WebsiteSettingsHandler::OnContentSettingUsed( | |
| 218 const ContentSettingsPattern& primary_pattern, | |
| 219 const ContentSettingsPattern& secondary_pattern, | |
| 220 ContentSettingsType content_type) { | |
| 221 Update(); | |
| 222 } | |
| 223 | |
| 224 void WebsiteSettingsHandler::HandleUpdateOrigins(const base::ListValue* args) { | |
| 225 std::string content_setting_name; | |
| 226 bool rv = args->GetString(0, &content_setting_name); | |
| 227 DCHECK(rv); | |
| 228 | |
| 229 ContentSettingsType content_type; | |
| 230 if (!content_settings::GetTypeFromName(content_setting_name, &content_type)) | |
| 231 return; | |
| 232 DCHECK_NE( | |
| 233 kValidTypes + kValidTypesLength, | |
| 234 std::find(kValidTypes, kValidTypes + kValidTypesLength, content_type)); | |
| 235 | |
| 236 last_setting_ = content_setting_name; | |
| 237 | |
| 238 // Histogram to understand the source of parsing errors. crbug.com/432600. | |
| 239 // TODO: Remove histogram by 2015. crbug.com/433475 | |
| 240 ContentSettingsType last_setting; | |
| 241 if (!content_settings::GetTypeFromName(last_setting_, &last_setting)) { | |
| 242 if (last_setting_.empty()) | |
| 243 RecordUmaHistogramOfLastSetting(HANDLE_UPDATE_ORIGINS_EMPTY); | |
| 244 else | |
| 245 RecordUmaHistogramOfLastSetting(HANDLE_UPDATE_ORIGINS_INVALID); | |
| 246 } else { | |
| 247 RecordUmaHistogramOfLastSetting(HANDLE_UPDATE_ORIGINS_PARSED); | |
| 248 } | |
| 249 | |
| 250 UpdateOrigins(); | |
| 251 } | |
| 252 | |
| 253 void WebsiteSettingsHandler::HandleUpdateSearchResults( | |
| 254 const base::ListValue* args) { | |
| 255 bool rv = args->GetString(0, &last_filter_); | |
| 256 DCHECK(rv); | |
| 257 | |
| 258 Update(); | |
| 259 } | |
| 260 | |
| 261 void WebsiteSettingsHandler::HandleUpdateLocalStorage( | |
| 262 const base::ListValue* args) { | |
| 263 if (!local_storage_.get()) { | |
| 264 Profile* profile = GetProfile(); | |
| 265 local_storage_ = new BrowsingDataLocalStorageHelper(profile); | |
| 266 } | |
| 267 | |
| 268 last_setting_ = kStorage; | |
| 269 | |
| 270 local_storage_->StartFetching( | |
| 271 base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched, | |
| 272 weak_ptr_factory_.GetWeakPtr())); | |
| 273 } | |
| 274 | |
| 275 void WebsiteSettingsHandler::HandleMaybeShowEditPage( | |
| 276 const base::ListValue* args) { | |
| 277 std::string site; | |
| 278 bool rv = args->GetString(0, &site); | |
| 279 DCHECK(rv); | |
| 280 | |
| 281 GURL last_site(site); | |
| 282 if (!last_site.is_valid()) | |
| 283 return; | |
| 284 | |
| 285 last_site_ = last_site; | |
| 286 base::StringValue site_value(site); | |
| 287 web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.showEditPage", | |
| 288 site_value); | |
| 289 } | |
| 290 | |
| 291 void WebsiteSettingsHandler::OnLocalStorageFetched(const std::list< | |
| 292 BrowsingDataLocalStorageHelper::LocalStorageInfo>& storage) { | |
| 293 local_storage_list_ = storage; | |
| 294 Update(); | |
| 295 GetInfoForOrigin(last_site_, false); | |
| 296 } | |
| 297 | |
| 298 void WebsiteSettingsHandler::Update() { | |
| 299 DCHECK(!last_setting_.empty()); | |
| 300 | |
| 301 // Histogram to understand the source of parsing errors. crbug.com/432600. | |
| 302 // TODO: Remove histogram by 2015. crbug.com/433475 | |
| 303 ContentSettingsType last_setting; | |
| 304 if (!content_settings::GetTypeFromName(last_setting_, &last_setting)) { | |
| 305 if (last_setting_.empty()) | |
| 306 RecordUmaHistogramOfLastSetting(UPDATE_EMPTY); | |
| 307 else | |
| 308 RecordUmaHistogramOfLastSetting(UPDATE_INVALID); | |
| 309 } else { | |
| 310 RecordUmaHistogramOfLastSetting(UPDATE_PARSED); | |
| 311 } | |
| 312 | |
| 313 if (last_setting_ == kStorage) | |
| 314 UpdateLocalStorage(); | |
| 315 else if (last_setting_ == kBattery) | |
| 316 UpdateBatteryUsage(); | |
| 317 else | |
| 318 UpdateOrigins(); | |
| 319 } | |
| 320 | |
| 321 void WebsiteSettingsHandler::UpdateOrigins() { | |
| 322 Profile* profile = GetProfile(); | |
| 323 HostContentSettingsMap* settings = profile->GetHostContentSettingsMap(); | |
| 324 | |
| 325 ContentSettingsForOneType all_settings; | |
| 326 ContentSettingsType last_setting; | |
| 327 if (!content_settings::GetTypeFromName(last_setting_, &last_setting)) { | |
| 328 // TODO: Remove histogram by 2015. crbug.com/433475 | |
| 329 if (last_setting_.empty()) | |
| 330 RecordUmaHistogramOfLastSetting(UPDATE_ORIGINS_EMPTY); | |
| 331 else | |
| 332 RecordUmaHistogramOfLastSetting(UPDATE_ORIGINS_INVALID); | |
| 333 | |
| 334 return; | |
| 335 } | |
| 336 RecordUmaHistogramOfLastSetting(UPDATE_ORIGINS_PARSED); | |
| 337 | |
| 338 if (last_setting == CONTENT_SETTINGS_TYPE_MEDIASTREAM) | |
| 339 last_setting = CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC; | |
| 340 | |
| 341 settings->GetSettingsForOneType(last_setting, std::string(), &all_settings); | |
| 342 | |
| 343 base::DictionaryValue allowed_origins; | |
| 344 base::DictionaryValue blocked_origins; | |
| 345 for (ContentSettingsForOneType::const_iterator it = all_settings.begin(); | |
| 346 it != all_settings.end(); | |
| 347 ++it) { | |
| 348 // Don't add default settings. | |
| 349 if (it->primary_pattern == ContentSettingsPattern::Wildcard() && | |
| 350 it->secondary_pattern == ContentSettingsPattern::Wildcard() && | |
| 351 it->source != kPreferencesSource) { | |
| 352 continue; | |
| 353 } | |
| 354 | |
| 355 GURL origin_url(it->primary_pattern.ToString()); | |
| 356 std::string origin = origin_url.spec(); | |
| 357 | |
| 358 // Hide the port if it is using a standard URL scheme. | |
| 359 if ((origin_url.SchemeIs(url::kHttpScheme) && | |
| 360 origin_url.IntPort() == kHttpPort) || | |
| 361 (origin_url.SchemeIs(url::kHttpsScheme) && | |
| 362 origin_url.IntPort() == kHttpsPort)) { | |
| 363 url::Replacements<char> replacements; | |
| 364 replacements.ClearPort(); | |
| 365 origin = origin_url.ReplaceComponents(replacements).spec(); | |
| 366 } | |
| 367 | |
| 368 // Mediastream isn't set unless both mic and camera are set to the same. | |
| 369 if (last_setting == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC) { | |
| 370 ContentSetting cam_setting = settings->GetContentSettingWithoutOverride( | |
| 371 origin_url, | |
| 372 origin_url, | |
| 373 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, | |
| 374 std::string()); | |
| 375 if (it->setting != cam_setting) | |
| 376 continue; | |
| 377 } | |
| 378 | |
| 379 if (origin.find(last_filter_) == base::string16::npos) | |
| 380 continue; | |
| 381 | |
| 382 base::Time last_usage = settings->GetLastUsageByPattern( | |
| 383 it->primary_pattern, it->secondary_pattern, last_setting); | |
| 384 | |
| 385 scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue()); | |
| 386 origin_entry->SetDoubleWithoutPathExpansion("usage", | |
| 387 last_usage.ToDoubleT()); | |
| 388 base::string16 usage_string; | |
| 389 if (last_usage.ToDoubleT()) { | |
| 390 usage_string = ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED, | |
| 391 ui::TimeFormat::LENGTH_SHORT, | |
| 392 base::Time::Now() - last_usage); | |
| 393 } | |
| 394 origin_entry->SetStringWithoutPathExpansion("usageString", usage_string); | |
| 395 origin_entry->SetStringWithoutPathExpansion("readableName", | |
| 396 GetReadableName(origin_url)); | |
| 397 | |
| 398 if (it->setting == CONTENT_SETTING_BLOCK) | |
| 399 blocked_origins.SetWithoutPathExpansion(origin, origin_entry.Pass()); | |
| 400 else | |
| 401 allowed_origins.SetWithoutPathExpansion(origin, origin_entry.Pass()); | |
| 402 } | |
| 403 | |
| 404 bool is_globally_allowed = settings->GetContentSettingOverride(last_setting); | |
| 405 web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins", | |
| 406 allowed_origins, | |
| 407 blocked_origins, | |
| 408 base::FundamentalValue(is_globally_allowed)); | |
| 409 } | |
| 410 | |
| 411 void WebsiteSettingsHandler::HandleGetOriginInfo(const base::ListValue* args) { | |
| 412 std::string url; | |
| 413 bool rv = args->GetString(0, &url); | |
| 414 DCHECK(rv); | |
| 415 GURL origin(url); | |
| 416 | |
| 417 if (!origin.is_valid()) | |
| 418 return; | |
| 419 | |
| 420 GetInfoForOrigin(origin, true); | |
| 421 } | |
| 422 | |
| 423 void WebsiteSettingsHandler::HandleSetOriginPermission( | |
| 424 const base::ListValue* args) { | |
| 425 std::string setting_name; | |
| 426 bool rv = args->GetString(0, &setting_name); | |
| 427 DCHECK(rv); | |
| 428 ContentSettingsType settings_type; | |
| 429 if (!content_settings::GetTypeFromName(setting_name, &settings_type)) | |
| 430 return; | |
| 431 | |
| 432 std::string value; | |
| 433 rv = args->GetString(1, &value); | |
| 434 DCHECK(rv); | |
| 435 | |
| 436 ContentSetting setting = content_settings::ContentSettingFromString(value); | |
| 437 Profile* profile = GetProfile(); | |
| 438 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); | |
| 439 ContentSetting default_value = | |
| 440 map->GetDefaultContentSetting(settings_type, NULL); | |
| 441 | |
| 442 // Users are not allowed to be the source of the "ask" setting. It is an | |
| 443 // ephemeral setting which is removed once the question is asked. | |
| 444 if (setting == CONTENT_SETTING_ASK && setting == default_value) | |
| 445 setting = CONTENT_SETTING_DEFAULT; | |
| 446 | |
| 447 ContentSettingsPattern primary_pattern; | |
| 448 ContentSettingsPattern secondary_pattern; | |
| 449 switch (settings_type) { | |
| 450 case CONTENT_SETTINGS_TYPE_NOTIFICATIONS: | |
| 451 primary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_); | |
| 452 secondary_pattern = ContentSettingsPattern::Wildcard(); | |
| 453 break; | |
| 454 case CONTENT_SETTINGS_TYPE_MEDIASTREAM: | |
| 455 primary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_); | |
| 456 secondary_pattern = ContentSettingsPattern::Wildcard(); | |
| 457 map->SetContentSetting(primary_pattern, | |
| 458 secondary_pattern, | |
| 459 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, | |
| 460 std::string(), | |
| 461 setting); | |
| 462 map->SetContentSetting(primary_pattern, | |
| 463 secondary_pattern, | |
| 464 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, | |
| 465 std::string(), | |
| 466 setting); | |
| 467 return; | |
| 468 case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS: | |
| 469 case CONTENT_SETTINGS_TYPE_COOKIES: | |
| 470 case CONTENT_SETTINGS_TYPE_GEOLOCATION: | |
| 471 case CONTENT_SETTINGS_TYPE_IMAGES: | |
| 472 case CONTENT_SETTINGS_TYPE_JAVASCRIPT: | |
| 473 case CONTENT_SETTINGS_TYPE_PLUGINS: | |
| 474 case CONTENT_SETTINGS_TYPE_POPUPS: | |
| 475 primary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_); | |
| 476 secondary_pattern = ContentSettingsPattern::FromURLNoWildcard(last_site_); | |
| 477 break; | |
| 478 default: | |
| 479 NOTREACHED() << "Content settings type not yet supported."; | |
| 480 return; | |
| 481 } | |
| 482 | |
| 483 content_settings::SettingInfo info; | |
| 484 scoped_ptr<base::Value> v(map->GetWebsiteSettingWithoutOverride( | |
| 485 last_site_, last_site_, settings_type, std::string(), &info)); | |
| 486 map->SetNarrowestWebsiteSetting(primary_pattern, | |
| 487 secondary_pattern, | |
| 488 settings_type, | |
| 489 std::string(), | |
| 490 setting, | |
| 491 info); | |
| 492 } | |
| 493 | |
| 494 void WebsiteSettingsHandler::HandleUpdateBatteryUsage( | |
| 495 const base::ListValue* args) { | |
| 496 last_setting_ = kBattery; | |
| 497 UpdateBatteryUsage(); | |
| 498 } | |
| 499 | |
| 500 void WebsiteSettingsHandler::HandleDeleteLocalStorage( | |
| 501 const base::ListValue* args) { | |
| 502 DCHECK(!last_site_.is_empty()); | |
| 503 DeleteLocalStorage(last_site_); | |
| 504 } | |
| 505 | |
| 506 void WebsiteSettingsHandler::HandleStopOrigin(const base::ListValue* args) { | |
| 507 DCHECK(!last_site_.is_empty()); | |
| 508 StopOrigin(last_site_); | |
| 509 } | |
| 510 | |
| 511 void WebsiteSettingsHandler::HandleUpdateDefaultSetting( | |
| 512 const base::ListValue* args) { | |
| 513 ContentSettingsType type; | |
| 514 if (!content_settings::GetTypeFromName(last_setting_, &type)) | |
| 515 return; | |
| 516 | |
| 517 Profile* profile = GetProfile(); | |
| 518 std::string provider_id; | |
| 519 ContentSetting default_setting = | |
| 520 profile->GetHostContentSettingsMap()->GetDefaultContentSetting( | |
| 521 type, &provider_id); | |
| 522 | |
| 523 base::DictionaryValue filter_settings; | |
| 524 filter_settings.SetString( | |
| 525 "value", content_settings::ContentSettingToString(default_setting)); | |
| 526 filter_settings.SetString("managedBy", provider_id); | |
| 527 | |
| 528 web_ui()->CallJavascriptFunction("WebsiteSettingsManager.updateDefault", | |
| 529 filter_settings); | |
| 530 } | |
| 531 | |
| 532 void WebsiteSettingsHandler::HandleSetDefaultSetting( | |
| 533 const base::ListValue* args) { | |
| 534 DCHECK_EQ(1U, args->GetSize()); | |
| 535 std::string setting; | |
| 536 if (!args->GetString(0, &setting)) { | |
| 537 NOTREACHED(); | |
| 538 return; | |
| 539 } | |
| 540 ContentSetting new_default = | |
| 541 content_settings::ContentSettingFromString(setting); | |
| 542 | |
| 543 ContentSettingsType last_setting; | |
| 544 if (!content_settings::GetTypeFromName(last_setting_, &last_setting)) | |
| 545 return; | |
| 546 Profile* profile = GetProfile(); | |
| 547 | |
| 548 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); | |
| 549 map->SetDefaultContentSetting(last_setting, new_default); | |
| 550 | |
| 551 switch (last_setting) { | |
| 552 case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS: | |
| 553 content::RecordAction( | |
| 554 UserMetricsAction("Options_DefaultMultipleAutomaticDLSettingChange")); | |
| 555 break; | |
| 556 case CONTENT_SETTINGS_TYPE_COOKIES: | |
| 557 content::RecordAction( | |
| 558 UserMetricsAction("Options_DefaultCookieSettingChanged")); | |
| 559 break; | |
| 560 case CONTENT_SETTINGS_TYPE_GEOLOCATION: | |
| 561 content::RecordAction( | |
| 562 UserMetricsAction("Options_DefaultGeolocationSettingChanged")); | |
| 563 break; | |
| 564 case CONTENT_SETTINGS_TYPE_IMAGES: | |
| 565 content::RecordAction( | |
| 566 UserMetricsAction("Options_DefaultImagesSettingChanged")); | |
| 567 break; | |
| 568 case CONTENT_SETTINGS_TYPE_JAVASCRIPT: | |
| 569 content::RecordAction( | |
| 570 UserMetricsAction("Options_DefaultJavaScriptSettingChanged")); | |
| 571 break; | |
| 572 case CONTENT_SETTINGS_TYPE_MEDIASTREAM: | |
| 573 content::RecordAction( | |
| 574 UserMetricsAction("Options_DefaultMediaStreamMicSettingChanged")); | |
| 575 break; | |
| 576 case CONTENT_SETTINGS_TYPE_NOTIFICATIONS: | |
| 577 content::RecordAction( | |
| 578 UserMetricsAction("Options_DefaultNotificationsSettingChanged")); | |
| 579 break; | |
| 580 case CONTENT_SETTINGS_TYPE_PLUGINS: | |
| 581 content::RecordAction( | |
| 582 UserMetricsAction("Options_DefaultPluginsSettingChanged")); | |
| 583 break; | |
| 584 case CONTENT_SETTINGS_TYPE_POPUPS: | |
| 585 content::RecordAction( | |
| 586 UserMetricsAction("Options_DefaultPopupsSettingChanged")); | |
| 587 break; | |
| 588 default: | |
| 589 NOTREACHED(); | |
| 590 return; | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 void WebsiteSettingsHandler::HandleSetGlobalToggle( | |
| 595 const base::ListValue* args) { | |
| 596 DCHECK_EQ(1U, args->GetSize()); | |
| 597 bool is_enabled; | |
| 598 bool rv = args->GetBoolean(0, &is_enabled); | |
| 599 DCHECK(rv); | |
| 600 | |
| 601 ContentSettingsType last_setting; | |
| 602 if (!content_settings::GetTypeFromName(last_setting_, &last_setting)) | |
| 603 return; | |
| 604 | |
| 605 Profile* profile = GetProfile(); | |
| 606 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); | |
| 607 map->SetContentSettingOverride(last_setting, is_enabled); | |
| 608 } | |
| 609 | |
| 610 void WebsiteSettingsHandler::GetInfoForOrigin(const GURL& site_url, | |
| 611 bool show_page) { | |
| 612 Profile* profile = GetProfile(); | |
| 613 HostContentSettingsMap* map = profile->GetHostContentSettingsMap(); | |
| 614 | |
| 615 double storage = 0.0; | |
| 616 for (LocalStorageList::const_iterator it = local_storage_list_.begin(); | |
| 617 it != local_storage_list_.end(); | |
| 618 it++) { | |
| 619 if (it->origin_url == site_url) { | |
| 620 storage = static_cast<double>(it->size); | |
| 621 break; | |
| 622 } | |
| 623 } | |
| 624 | |
| 625 int battery = 0; | |
| 626 battery = OriginPowerMapFactory::GetForBrowserContext( | |
| 627 GetProfile())->GetPowerForOrigin(site_url); | |
| 628 | |
| 629 base::DictionaryValue* permissions = new base::DictionaryValue; | |
| 630 for (size_t i = 0; i < arraysize(kValidTypes); ++i) { | |
| 631 ContentSettingsType permission_type = kValidTypes[i]; | |
| 632 | |
| 633 // Append the possible settings. | |
| 634 scoped_ptr<base::ListValue> options(new base::ListValue()); | |
| 635 ContentSetting default_value = | |
| 636 map->GetDefaultContentSetting(permission_type, NULL); | |
| 637 if (default_value != CONTENT_SETTING_ALLOW && | |
| 638 default_value != CONTENT_SETTING_BLOCK) { | |
| 639 options->AppendString( | |
| 640 content_settings::ContentSettingToString(default_value)); | |
| 641 } | |
| 642 options->AppendString( | |
| 643 content_settings::ContentSettingToString(CONTENT_SETTING_ALLOW)); | |
| 644 options->AppendString( | |
| 645 content_settings::ContentSettingToString(CONTENT_SETTING_BLOCK)); | |
| 646 if (permission_type == CONTENT_SETTINGS_TYPE_COOKIES) { | |
| 647 options->AppendString(content_settings::ContentSettingToString( | |
| 648 CONTENT_SETTING_SESSION_ONLY)); | |
| 649 } | |
| 650 | |
| 651 ContentSetting permission; | |
| 652 content_settings::SettingInfo info; | |
| 653 if (permission_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) { | |
| 654 scoped_ptr<base::Value> mic_value(map->GetWebsiteSettingWithoutOverride( | |
| 655 site_url, | |
| 656 site_url, | |
| 657 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, | |
| 658 std::string(), | |
| 659 &info)); | |
| 660 ContentSetting mic_setting = | |
| 661 content_settings::ValueToContentSetting(mic_value.get()); | |
| 662 ContentSetting cam_setting = map->GetContentSettingWithoutOverride( | |
| 663 site_url, | |
| 664 site_url, | |
| 665 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, | |
| 666 std::string()); | |
| 667 | |
| 668 if (mic_setting != cam_setting) | |
| 669 permission = CONTENT_SETTING_ASK; | |
| 670 else | |
| 671 permission = mic_setting; | |
| 672 } else { | |
| 673 scoped_ptr<base::Value> v(map->GetWebsiteSettingWithoutOverride( | |
| 674 site_url, site_url, permission_type, std::string(), &info)); | |
| 675 permission = content_settings::ValueToContentSetting(v.get()); | |
| 676 } | |
| 677 | |
| 678 scoped_ptr<base::DictionaryValue> | |
| 679 permission_info(new base::DictionaryValue()); | |
| 680 permission_info->SetStringWithoutPathExpansion( | |
| 681 "setting", content_settings::ContentSettingToString(permission)); | |
| 682 permission_info->SetWithoutPathExpansion("options", options.Pass()); | |
| 683 permission_info->SetBooleanWithoutPathExpansion( | |
| 684 "editable", info.source == content_settings::SETTING_SOURCE_USER); | |
| 685 permissions->SetWithoutPathExpansion( | |
| 686 content_settings::GetTypeName(permission_type), permission_info.Pass()); | |
| 687 } | |
| 688 | |
| 689 base::Value* storage_used = new base::StringValue(l10n_util::GetStringFUTF16( | |
| 690 IDS_WEBSITE_SETTINGS_STORAGE_USED, ui::FormatBytes(storage))); | |
| 691 base::Value* battery_used = | |
| 692 new base::StringValue(l10n_util::GetStringFUTF16Int( | |
| 693 IDS_WEBSITE_SETTINGS_BATTERY_USED, battery)); | |
| 694 | |
| 695 web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.populateOrigin", | |
| 696 *storage_used, | |
| 697 *battery_used, | |
| 698 *permissions, | |
| 699 base::FundamentalValue(show_page)); | |
| 700 } | |
| 701 | |
| 702 void WebsiteSettingsHandler::UpdateLocalStorage() { | |
| 703 base::DictionaryValue local_storage_map; | |
| 704 for (LocalStorageList::const_iterator it = local_storage_list_.begin(); | |
| 705 it != local_storage_list_.end(); | |
| 706 it++) { | |
| 707 std::string origin = it->origin_url.spec(); | |
| 708 | |
| 709 if (origin.find(last_filter_) == base::string16::npos) | |
| 710 continue; | |
| 711 | |
| 712 scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue()); | |
| 713 origin_entry->SetDoubleWithoutPathExpansion( | |
| 714 "usage", static_cast<double>(it->size)); | |
| 715 origin_entry->SetStringWithoutPathExpansion( | |
| 716 "usageString", ui::FormatBytes(it->size)); | |
| 717 origin_entry->SetStringWithoutPathExpansion( | |
| 718 "readableName", GetReadableName(it->origin_url)); | |
| 719 local_storage_map.SetWithoutPathExpansion(origin, origin_entry.Pass()); | |
| 720 } | |
| 721 web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins", | |
| 722 local_storage_map); | |
| 723 } | |
| 724 | |
| 725 void WebsiteSettingsHandler::UpdateBatteryUsage() { | |
| 726 base::DictionaryValue power_map; | |
| 727 OriginPowerMap* origins = | |
| 728 OriginPowerMapFactory::GetForBrowserContext(GetProfile()); | |
| 729 OriginPowerMap::PercentOriginMap percent_map = origins->GetPercentOriginMap(); | |
| 730 for (std::map<GURL, int>::iterator it = percent_map.begin(); | |
| 731 it != percent_map.end(); | |
| 732 ++it) { | |
| 733 std::string origin = it->first.spec(); | |
| 734 | |
| 735 if (origin.find(last_filter_) == base::string16::npos) | |
| 736 continue; | |
| 737 | |
| 738 scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue()); | |
| 739 origin_entry->SetInteger("usage", it->second); | |
| 740 if (it->second == 0) { | |
| 741 origin_entry->SetString( | |
| 742 "usageString", | |
| 743 l10n_util::GetStringUTF16(IDS_WEBSITE_SETTINGS_BATTERY_ZERO_PERCENT)); | |
| 744 } else { | |
| 745 origin_entry->SetString( | |
| 746 "usageString", | |
| 747 l10n_util::GetStringFUTF16Int(IDS_WEBSITE_SETTINGS_BATTERY_PERCENT, | |
| 748 it->second)); | |
| 749 } | |
| 750 origin_entry->SetStringWithoutPathExpansion("readableName", | |
| 751 GetReadableName(it->first)); | |
| 752 power_map.SetWithoutPathExpansion(origin, origin_entry.Pass()); | |
| 753 } | |
| 754 web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins", | |
| 755 power_map); | |
| 756 } | |
| 757 | |
| 758 void WebsiteSettingsHandler::StopOrigin(const GURL& site_url) { | |
| 759 Profile* profile = GetProfile(); | |
| 760 if (site_url.SchemeIs(extensions::kExtensionScheme)) { | |
| 761 const extensions::Extension* extension = | |
| 762 extensions::ExtensionRegistry::Get(profile) | |
| 763 ->enabled_extensions() | |
| 764 .GetHostedAppByURL(site_url); | |
| 765 if (extension) { | |
| 766 extensions::AppWindowRegistry::Get(profile) | |
| 767 ->CloseAllAppWindowsForApp(extension->id()); | |
| 768 } | |
| 769 } | |
| 770 | |
| 771 for (chrome::BrowserIterator it; !it.done(); it.Next()) { | |
| 772 Browser* browser = *it; | |
| 773 TabStripModel* model = browser->tab_strip_model(); | |
| 774 for (int idx = 0; idx < model->count(); idx++) { | |
| 775 content::WebContents* web_contents = model->GetWebContentsAt(idx); | |
| 776 // Can't discard tabs that are already discarded or active. | |
| 777 if (model->IsTabDiscarded(idx) || (model->active_index() == idx)) | |
| 778 continue; | |
| 779 | |
| 780 // Don't discard tabs that belong to other profiles or other origins. | |
| 781 if (web_contents->GetLastCommittedURL().GetOrigin() != site_url || | |
| 782 profile != | |
| 783 Profile::FromBrowserContext(web_contents->GetBrowserContext())) { | |
| 784 continue; | |
| 785 } | |
| 786 model->DiscardWebContentsAt(idx); | |
| 787 } | |
| 788 } | |
| 789 } | |
| 790 | |
| 791 void WebsiteSettingsHandler::DeleteLocalStorage(const GURL& site_url) { | |
| 792 Profile* profile = GetProfile(); | |
| 793 content::DOMStorageContext* dom_storage_context_ = | |
| 794 content::BrowserContext::GetDefaultStoragePartition(profile) | |
| 795 ->GetDOMStorageContext(); | |
| 796 dom_storage_context_->DeleteLocalStorage(site_url); | |
| 797 | |
| 798 // Load a new BrowsingDataLocalStorageHelper to update. | |
| 799 local_storage_ = new BrowsingDataLocalStorageHelper(profile); | |
| 800 | |
| 801 local_storage_->StartFetching( | |
| 802 base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched, | |
| 803 weak_ptr_factory_.GetWeakPtr())); | |
| 804 } | |
| 805 | |
| 806 const std::string& WebsiteSettingsHandler::GetReadableName( | |
| 807 const GURL& site_url) { | |
| 808 if (site_url.SchemeIs(extensions::kExtensionScheme)) { | |
| 809 const extensions::ExtensionRegistry* registry = | |
| 810 extensions::ExtensionRegistry::Get(GetProfile()); | |
| 811 const extensions::Extension* extension = | |
| 812 registry->enabled_extensions().GetByID(site_url.host()); | |
| 813 // If extension is NULL, it was removed and we cannot look up its name. | |
| 814 if (!extension) | |
| 815 return site_url.spec(); | |
| 816 | |
| 817 return extension->name(); | |
| 818 } | |
| 819 return site_url.spec(); | |
| 820 } | |
| 821 | |
| 822 Profile* WebsiteSettingsHandler::GetProfile() { | |
| 823 Profile* profile = Profile::FromWebUI(web_ui()); | |
| 824 #if defined(OS_CHROMEOS) | |
| 825 // Chrome OS special case: in Guest mode settings are opened in Incognito | |
| 826 // mode, so we need original profile to actually modify settings. | |
| 827 if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) | |
| 828 profile = profile->GetOriginalProfile(); | |
| 829 #endif | |
| 830 return profile; | |
| 831 } | |
| 832 | |
| 833 } // namespace options | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1156983002:
Remove unused "Website Settings" view of content settings (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master