chrome/browser/content_settings/host_content_settings_map.cc

   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/content_settings/host_content_settings_map.h"
   6
   7 #include <utility>
   8
   9 #include "base/basictypes.h"
  10 #include "base/command_line.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "chrome/browser/chrome_notification_types.h"
  16 #include "chrome/browser/content_settings/content_settings_custom_extension_provider.h"
  17 #include "chrome/browser/content_settings/content_settings_default_provider.h"
  18 #include "chrome/browser/content_settings/content_settings_details.h"
  19 #include "chrome/browser/content_settings/content_settings_internal_extension_provider.h"
  20 #include "chrome/browser/content_settings/content_settings_observable_provider.h"
  21 #include "chrome/browser/content_settings/content_settings_policy_provider.h"
  22 #include "chrome/browser/content_settings/content_settings_pref_provider.h"
  23 #include "chrome/browser/content_settings/content_settings_provider.h"
  24 #include "chrome/browser/content_settings/content_settings_rule.h"
  25 #include "chrome/browser/content_settings/content_settings_utils.h"
  26 #include "chrome/browser/extensions/extension_service.h"
  27 #include "chrome/common/chrome_switches.h"
  28 #include "chrome/common/content_settings_pattern.h"
  29 #include "chrome/common/pref_names.h"
  30 #include "chrome/common/url_constants.h"
  31 #include "components/user_prefs/pref_registry_syncable.h"
  32 #include "content/public/browser/browser_thread.h"
  33 #include "content/public/browser/notification_service.h"
  34 #include "content/public/browser/notification_source.h"
  35 #include "content/public/browser/user_metrics.h"
  36 #include "content/public/common/content_switches.h"
  37 #include "extensions/common/constants.h"
  38 #include "net/base/net_errors.h"
  39 #include "net/base/static_cookie_policy.h"
  40 #include "url/gurl.h"
  41
  42 using base::UserMetricsAction;
  43 using content::BrowserThread;
  44
  45 namespace {
  46
  47 typedef std::vector<content_settings::Rule> Rules;
  48
  49 typedef std::pair<std::string, std::string> StringPair;
  50
  51 const char* kProviderNames[] = {
  52   "platform_app",
  53   "policy",
  54   "extension",
  55   "preference",
  56   "default"
  57 };
  58
  59 content_settings::SettingSource kProviderSourceMap[] = {
  60   content_settings::SETTING_SOURCE_EXTENSION,
  61   content_settings::SETTING_SOURCE_POLICY,
  62   content_settings::SETTING_SOURCE_EXTENSION,
  63   content_settings::SETTING_SOURCE_USER,
  64   content_settings::SETTING_SOURCE_USER,
  65 };
  66 COMPILE_ASSERT(arraysize(kProviderSourceMap) ==
  67                    HostContentSettingsMap::NUM_PROVIDER_TYPES,
  68                kProviderSourceMap_has_incorrect_size);
  69
  70 // Returns true if the |content_type| supports a resource identifier.
  71 // Resource identifiers are supported (but not required) for plug-ins.
  72 bool SupportsResourceIdentifier(ContentSettingsType content_type) {
  73   return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
  74 }
  75
  76 }  // namespace
  77
  78 HostContentSettingsMap::HostContentSettingsMap(
  79     PrefService* prefs,
  80     bool incognito) :
  81 #ifndef NDEBUG
  82       used_from_thread_id_(base::PlatformThread::CurrentId()),
  83 #endif
  84       prefs_(prefs),
  85       is_off_the_record_(incognito) {
  86   content_settings::ObservableProvider* policy_provider =
  87       new content_settings::PolicyProvider(prefs_);
  88   policy_provider->AddObserver(this);
  89   content_settings_providers_[POLICY_PROVIDER] = policy_provider;
  90
  91   content_settings::ObservableProvider* pref_provider =
  92       new content_settings::PrefProvider(prefs_, is_off_the_record_);
  93   pref_provider->AddObserver(this);
  94   content_settings_providers_[PREF_PROVIDER] = pref_provider;
  95
  96   content_settings::ObservableProvider* default_provider =
  97       new content_settings::DefaultProvider(prefs_, is_off_the_record_);
  98   default_provider->AddObserver(this);
  99   content_settings_providers_[DEFAULT_PROVIDER] = default_provider;
 100
 101   if (!is_off_the_record_) {
 102     // Migrate obsolete preferences.
 103     MigrateObsoleteClearOnExitPref();
 104   }
 105 }
 106
 107 #if defined(ENABLE_EXTENSIONS)
 108 void HostContentSettingsMap::RegisterExtensionService(
 109     ExtensionService* extension_service) {
 110   DCHECK(extension_service);
 111   DCHECK(!content_settings_providers_[INTERNAL_EXTENSION_PROVIDER]);
 112   DCHECK(!content_settings_providers_[CUSTOM_EXTENSION_PROVIDER]);
 113
 114   content_settings::InternalExtensionProvider* internal_extension_provider =
 115       new content_settings::InternalExtensionProvider(extension_service);
 116   internal_extension_provider->AddObserver(this);
 117   content_settings_providers_[INTERNAL_EXTENSION_PROVIDER] =
 118       internal_extension_provider;
 119
 120   content_settings::ObservableProvider* custom_extension_provider =
 121       new content_settings::CustomExtensionProvider(
 122           extension_service->GetContentSettingsStore(),
 123           is_off_the_record_);
 124   custom_extension_provider->AddObserver(this);
 125   content_settings_providers_[CUSTOM_EXTENSION_PROVIDER] =
 126       custom_extension_provider;
 127
 128 #ifndef NDEBUG
 129   DCHECK(used_from_thread_id_ != base::kInvalidThreadId)
 130       << "Used from multiple threads before initialization complete.";
 131 #endif
 132
 133   OnContentSettingChanged(ContentSettingsPattern(),
 134                           ContentSettingsPattern(),
 135                           CONTENT_SETTINGS_TYPE_DEFAULT,
 136                           std::string());
 137 }
 138 #endif
 139
 140 // static
 141 void HostContentSettingsMap::RegisterProfilePrefs(
 142     user_prefs::PrefRegistrySyncable* registry) {
 143   registry->RegisterIntegerPref(
 144       prefs::kContentSettingsWindowLastTabIndex,
 145       0,
 146       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 147   registry->RegisterIntegerPref(
 148       prefs::kContentSettingsDefaultWhitelistVersion,
 149       0,
 150       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 151   registry->RegisterBooleanPref(
 152       prefs::kContentSettingsClearOnExitMigrated,
 153       false,
 154       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 155
 156   // Register the prefs for the content settings providers.
 157   content_settings::DefaultProvider::RegisterProfilePrefs(registry);
 158   content_settings::PrefProvider::RegisterProfilePrefs(registry);
 159   content_settings::PolicyProvider::RegisterProfilePrefs(registry);
 160 }
 161
 162 ContentSetting HostContentSettingsMap::GetDefaultContentSettingFromProvider(
 163     ContentSettingsType content_type,
 164     content_settings::ProviderInterface* provider) const {
 165   scoped_ptr<content_settings::RuleIterator> rule_iterator(
 166       provider->GetRuleIterator(content_type, std::string(), false));
 167
 168   ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
 169   while (rule_iterator->HasNext()) {
 170     content_settings::Rule rule = rule_iterator->Next();
 171     if (rule.primary_pattern == wildcard &&
 172         rule.secondary_pattern == wildcard) {
 173       return content_settings::ValueToContentSetting(rule.value.get());
 174     }
 175   }
 176   return CONTENT_SETTING_DEFAULT;
 177 }
 178
 179 ContentSetting HostContentSettingsMap::GetDefaultContentSetting(
 180     ContentSettingsType content_type,
 181     std::string* provider_id) const {
 182   UsedContentSettingsProviders();
 183
 184   // Iterate through the list of providers and return the first non-NULL value
 185   // that matches |primary_url| and |secondary_url|.
 186   for (ConstProviderIterator provider = content_settings_providers_.begin();
 187        provider != content_settings_providers_.end();
 188        ++provider) {
 189     if (provider->first == PREF_PROVIDER)
 190       continue;
 191     ContentSetting default_setting =
 192         GetDefaultContentSettingFromProvider(content_type, provider->second);
 193     if (default_setting != CONTENT_SETTING_DEFAULT) {
 194       if (provider_id)
 195         *provider_id = kProviderNames[provider->first];
 196       return default_setting;
 197     }
 198   }
 199
 200   // The method GetDefaultContentSetting always has to return an explicit
 201   // value that is to be used as default. We here rely on the
 202   // DefaultProvider to always provide a value.
 203   NOTREACHED();
 204   return CONTENT_SETTING_DEFAULT;
 205 }
 206
 207 ContentSetting HostContentSettingsMap::GetContentSetting(
 208     const GURL& primary_url,
 209     const GURL& secondary_url,
 210     ContentSettingsType content_type,
 211     const std::string& resource_identifier) const {
 212   DCHECK(!ContentTypeHasCompoundValue(content_type));
 213   scoped_ptr<base::Value> value(GetWebsiteSetting(
 214       primary_url, secondary_url, content_type, resource_identifier, NULL));
 215   return content_settings::ValueToContentSetting(value.get());
 216 }
 217
 218 void HostContentSettingsMap::GetSettingsForOneType(
 219     ContentSettingsType content_type,
 220     const std::string& resource_identifier,
 221     ContentSettingsForOneType* settings) const {
 222   DCHECK(SupportsResourceIdentifier(content_type) ||
 223          resource_identifier.empty());
 224   DCHECK(settings);
 225   UsedContentSettingsProviders();
 226
 227   settings->clear();
 228   for (ConstProviderIterator provider = content_settings_providers_.begin();
 229        provider != content_settings_providers_.end();
 230        ++provider) {
 231     // For each provider, iterate first the incognito-specific rules, then the
 232     // normal rules.
 233     if (is_off_the_record_) {
 234       AddSettingsForOneType(provider->second,
 235                             provider->first,
 236                             content_type,
 237                             resource_identifier,
 238                             settings,
 239                             true);
 240     }
 241     AddSettingsForOneType(provider->second,
 242                           provider->first,
 243                           content_type,
 244                           resource_identifier,
 245                           settings,
 246                           false);
 247   }
 248 }
 249
 250 void HostContentSettingsMap::SetDefaultContentSetting(
 251     ContentSettingsType content_type,
 252     ContentSetting setting) {
 253   DCHECK(IsSettingAllowedForType(prefs_, setting, content_type));
 254
 255   base::Value* value = NULL;
 256   if (setting != CONTENT_SETTING_DEFAULT)
 257     value = base::Value::CreateIntegerValue(setting);
 258   SetWebsiteSetting(
 259       ContentSettingsPattern::Wildcard(),
 260       ContentSettingsPattern::Wildcard(),
 261       content_type,
 262       std::string(),
 263       value);
 264 }
 265
 266 void HostContentSettingsMap::SetWebsiteSetting(
 267     const ContentSettingsPattern& primary_pattern,
 268     const ContentSettingsPattern& secondary_pattern,
 269     ContentSettingsType content_type,
 270     const std::string& resource_identifier,
 271     base::Value* value) {
 272   DCHECK(IsValueAllowedForType(prefs_, value, content_type));
 273   DCHECK(SupportsResourceIdentifier(content_type) ||
 274          resource_identifier.empty());
 275   UsedContentSettingsProviders();
 276
 277   for (ProviderIterator provider = content_settings_providers_.begin();
 278        provider != content_settings_providers_.end();
 279        ++provider) {
 280     if (provider->second->SetWebsiteSetting(primary_pattern,
 281                                             secondary_pattern,
 282                                             content_type,
 283                                             resource_identifier,
 284                                             value)) {
 285       return;
 286     }
 287   }
 288   NOTREACHED();
 289 }
 290
 291 void HostContentSettingsMap::SetContentSetting(
 292     const ContentSettingsPattern& primary_pattern,
 293     const ContentSettingsPattern& secondary_pattern,
 294     ContentSettingsType content_type,
 295     const std::string& resource_identifier,
 296     ContentSetting setting) {
 297   DCHECK(!ContentTypeHasCompoundValue(content_type));
 298   base::Value* value = NULL;
 299   if (setting != CONTENT_SETTING_DEFAULT)
 300     value = base::Value::CreateIntegerValue(setting);
 301   SetWebsiteSetting(primary_pattern,
 302                     secondary_pattern,
 303                     content_type,
 304                     resource_identifier,
 305                     value);
 306 }
 307
 308 void HostContentSettingsMap::AddExceptionForURL(
 309     const GURL& primary_url,
 310     const GURL& secondary_url,
 311     ContentSettingsType content_type,
 312     ContentSetting setting) {
 313   // TODO(markusheintz): Until the UI supports pattern pairs, both urls must
 314   // match.
 315   DCHECK(primary_url == secondary_url);
 316   DCHECK(!ContentTypeHasCompoundValue(content_type));
 317
 318   // Make sure there is no entry that would override the pattern we are about
 319   // to insert for exactly this URL.
 320   SetContentSetting(ContentSettingsPattern::FromURLNoWildcard(primary_url),
 321                     ContentSettingsPattern::Wildcard(),
 322                     content_type,
 323                     std::string(),
 324                     CONTENT_SETTING_DEFAULT);
 325
 326   SetContentSetting(ContentSettingsPattern::FromURL(primary_url),
 327                     ContentSettingsPattern::Wildcard(),
 328                     content_type,
 329                     std::string(),
 330                     setting);
 331 }
 332
 333 void HostContentSettingsMap::ClearSettingsForOneType(
 334     ContentSettingsType content_type) {
 335   UsedContentSettingsProviders();
 336   for (ProviderIterator provider = content_settings_providers_.begin();
 337        provider != content_settings_providers_.end();
 338        ++provider) {
 339     provider->second->ClearAllContentSettingsRules(content_type);
 340   }
 341 }
 342
 343 bool HostContentSettingsMap::IsValueAllowedForType(
 344     PrefService* prefs, const base::Value* value, ContentSettingsType type) {
 345   return ContentTypeHasCompoundValue(type) || IsSettingAllowedForType(
 346       prefs, content_settings::ValueToContentSetting(value), type);
 347 }
 348
 349 // static
 350 bool HostContentSettingsMap::IsSettingAllowedForType(
 351     PrefService* prefs,
 352     ContentSetting setting,
 353     ContentSettingsType content_type) {
 354   // We don't yet support stored content settings for mixed scripting.
 355   if (content_type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT)
 356     return false;
 357
 358   // BLOCK semantics are not implemented for fullscreen.
 359   if (content_type == CONTENT_SETTINGS_TYPE_FULLSCREEN &&
 360       setting == CONTENT_SETTING_BLOCK) {
 361     return false;
 362   }
 363
 364   // We don't support ALLOW for media default setting.
 365   if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM &&
 366       setting == CONTENT_SETTING_ALLOW) {
 367     return false;
 368   }
 369
 370   // DEFAULT, ALLOW and BLOCK are always allowed.
 371   if (setting == CONTENT_SETTING_DEFAULT ||
 372       setting == CONTENT_SETTING_ALLOW ||
 373       setting == CONTENT_SETTING_BLOCK) {
 374     return true;
 375   }
 376   switch (content_type) {
 377     case CONTENT_SETTINGS_TYPE_COOKIES:
 378       return setting == CONTENT_SETTING_SESSION_ONLY;
 379     case CONTENT_SETTINGS_TYPE_PLUGINS:
 380     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
 381     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
 382     case CONTENT_SETTINGS_TYPE_MOUSELOCK:
 383     case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
 384     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
 385     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
 386     case CONTENT_SETTINGS_TYPE_PPAPI_BROKER:
 387     case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS:
 388     case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
 389       return setting == CONTENT_SETTING_ASK;
 390     default:
 391       return false;
 392   }
 393 }
 394
 395 // static
 396 bool HostContentSettingsMap::ContentTypeHasCompoundValue(
 397     ContentSettingsType type) {
 398   // Values for content type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE and
 399   // CONTENT_SETTINGS_TYPE_MEDIASTREAM are of type dictionary/map. Compound
 400   // types like dictionaries can't be mapped to the type |ContentSetting|.
 401   return (type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE ||
 402           type == CONTENT_SETTINGS_TYPE_MEDIASTREAM);
 403 }
 404
 405 void HostContentSettingsMap::OnContentSettingChanged(
 406     const ContentSettingsPattern& primary_pattern,
 407     const ContentSettingsPattern& secondary_pattern,
 408     ContentSettingsType content_type,
 409     std::string resource_identifier) {
 410   const ContentSettingsDetails details(primary_pattern,
 411                                        secondary_pattern,
 412                                        content_type,
 413                                        resource_identifier);
 414   content::NotificationService::current()->Notify(
 415       chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
 416       content::Source<HostContentSettingsMap>(this),
 417       content::Details<const ContentSettingsDetails>(&details));
 418 }
 419
 420 HostContentSettingsMap::~HostContentSettingsMap() {
 421   DCHECK(!prefs_);
 422   STLDeleteValues(&content_settings_providers_);
 423 }
 424
 425 void HostContentSettingsMap::ShutdownOnUIThread() {
 426   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 427   DCHECK(prefs_);
 428   prefs_ = NULL;
 429   for (ProviderIterator it = content_settings_providers_.begin();
 430        it != content_settings_providers_.end();
 431        ++it) {
 432     it->second->ShutdownOnUIThread();
 433   }
 434 }
 435
 436 void HostContentSettingsMap::MigrateObsoleteClearOnExitPref() {
 437   // Don't migrate more than once.
 438   if (prefs_->HasPrefPath(prefs::kContentSettingsClearOnExitMigrated) &&
 439       prefs_->GetBoolean(prefs::kContentSettingsClearOnExitMigrated)) {
 440     return;
 441   }
 442
 443   if (!prefs_->GetBoolean(prefs::kClearSiteDataOnExit)) {
 444     // Nothing to be done
 445     prefs_->SetBoolean(prefs::kContentSettingsClearOnExitMigrated, true);
 446     return;
 447   }
 448
 449   // Change the default cookie settings:
 450   //  old              new
 451   //  ---------------- ----------------
 452   //  ALLOW            SESSION_ONLY
 453   //  SESSION_ONLY     SESSION_ONLY
 454   //  BLOCK            BLOCK
 455   ContentSetting default_setting = GetDefaultContentSettingFromProvider(
 456       CONTENT_SETTINGS_TYPE_COOKIES,
 457       content_settings_providers_[DEFAULT_PROVIDER]);
 458   if (default_setting == CONTENT_SETTING_ALLOW) {
 459     SetDefaultContentSetting(
 460         CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_SESSION_ONLY);
 461   }
 462
 463   // Change the exceptions using the same rules.
 464   ContentSettingsForOneType exceptions;
 465   AddSettingsForOneType(content_settings_providers_[PREF_PROVIDER],
 466                         PREF_PROVIDER,
 467                         CONTENT_SETTINGS_TYPE_COOKIES,
 468                         std::string(),
 469                         &exceptions,
 470                         false);
 471   for (ContentSettingsForOneType::iterator it = exceptions.begin();
 472        it != exceptions.end(); ++it) {
 473     if (it->setting != CONTENT_SETTING_ALLOW)
 474       continue;
 475     SetWebsiteSetting(it->primary_pattern,
 476                       it->secondary_pattern,
 477                       CONTENT_SETTINGS_TYPE_COOKIES,
 478                       std::string(),
 479                       base::Value::CreateIntegerValue(
 480                           CONTENT_SETTING_SESSION_ONLY));
 481   }
 482
 483   prefs_->SetBoolean(prefs::kContentSettingsClearOnExitMigrated, true);
 484 }
 485
 486 void HostContentSettingsMap::AddSettingsForOneType(
 487     const content_settings::ProviderInterface* provider,
 488     ProviderType provider_type,
 489     ContentSettingsType content_type,
 490     const std::string& resource_identifier,
 491     ContentSettingsForOneType* settings,
 492     bool incognito) const {
 493   scoped_ptr<content_settings::RuleIterator> rule_iterator(
 494       provider->GetRuleIterator(content_type,
 495                                 resource_identifier,
 496                                 incognito));
 497   while (rule_iterator->HasNext()) {
 498     const content_settings::Rule& rule = rule_iterator->Next();
 499     ContentSetting setting_value = CONTENT_SETTING_DEFAULT;
 500     // TODO(bauerb): Return rules as a list of values, not content settings.
 501     // Handle the case using compound values for its exceptions and arbitrary
 502     // values for its default setting. Here we assume all the exceptions
 503     // are granted as |CONTENT_SETTING_ALLOW|.
 504     if (ContentTypeHasCompoundValue(content_type) &&
 505         rule.value.get() &&
 506         rule.primary_pattern != ContentSettingsPattern::Wildcard()) {
 507       setting_value = CONTENT_SETTING_ALLOW;
 508     } else {
 509       setting_value = content_settings::ValueToContentSetting(rule.value.get());
 510     }
 511     settings->push_back(ContentSettingPatternSource(
 512         rule.primary_pattern, rule.secondary_pattern,
 513         setting_value,
 514         kProviderNames[provider_type],
 515         incognito));
 516   }
 517 }
 518
 519 void HostContentSettingsMap::UsedContentSettingsProviders() const {
 520 #ifndef NDEBUG
 521   if (used_from_thread_id_ == base::kInvalidThreadId)
 522     return;
 523
 524   if (base::PlatformThread::CurrentId() != used_from_thread_id_)
 525     used_from_thread_id_ = base::kInvalidThreadId;
 526 #endif
 527 }
 528
 529 bool HostContentSettingsMap::ShouldAllowAllContent(
 530     const GURL& primary_url,
 531     const GURL& secondary_url,
 532     ContentSettingsType content_type) {
 533   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
 534       content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
 535       content_type == CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
 536     return false;
 537   }
 538   if (secondary_url.SchemeIs(chrome::kChromeUIScheme) &&
 539       content_type == CONTENT_SETTINGS_TYPE_COOKIES &&
 540       primary_url.SchemeIsSecure()) {
 541     return true;
 542   }
 543   if (primary_url.SchemeIs(extensions::kExtensionScheme)) {
 544     switch (content_type) {
 545       case CONTENT_SETTINGS_TYPE_PLUGINS:
 546       case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
 547       case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
 548       case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
 549         return false;
 550       case CONTENT_SETTINGS_TYPE_COOKIES:
 551         return secondary_url.SchemeIs(extensions::kExtensionScheme);
 552       default:
 553         return true;
 554     }
 555   }
 556   return primary_url.SchemeIs(chrome::kChromeDevToolsScheme) ||
 557          primary_url.SchemeIs(chrome::kChromeUIScheme);
 558 }
 559
 560 base::Value* HostContentSettingsMap::GetWebsiteSetting(
 561     const GURL& primary_url,
 562     const GURL& secondary_url,
 563     ContentSettingsType content_type,
 564     const std::string& resource_identifier,
 565     content_settings::SettingInfo* info) const {
 566   DCHECK(SupportsResourceIdentifier(content_type) ||
 567          resource_identifier.empty());
 568
 569   // Check if the scheme of the requesting url is whitelisted.
 570   if (ShouldAllowAllContent(primary_url, secondary_url, content_type)) {
 571     if (info) {
 572       info->source = content_settings::SETTING_SOURCE_WHITELIST;
 573       info->primary_pattern = ContentSettingsPattern::Wildcard();
 574       info->secondary_pattern = ContentSettingsPattern::Wildcard();
 575     }
 576     return base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW);
 577   }
 578
 579   ContentSettingsPattern* primary_pattern = NULL;
 580   ContentSettingsPattern* secondary_pattern = NULL;
 581   if (info) {
 582     primary_pattern = &info->primary_pattern;
 583     secondary_pattern = &info->secondary_pattern;
 584   }
 585
 586   // The list of |content_settings_providers_| is ordered according to their
 587   // precedence.
 588   for (ConstProviderIterator provider = content_settings_providers_.begin();
 589        provider != content_settings_providers_.end();
 590        ++provider) {
 591     base::Value* value = content_settings::GetContentSettingValueAndPatterns(
 592         provider->second, primary_url, secondary_url, content_type,
 593         resource_identifier, is_off_the_record_,
 594         primary_pattern, secondary_pattern);
 595     if (value) {
 596       if (info)
 597         info->source = kProviderSourceMap[provider->first];
 598       return value;
 599     }
 600   }
 601
 602   if (info) {
 603     info->source = content_settings::SETTING_SOURCE_NONE;
 604     info->primary_pattern = ContentSettingsPattern();
 605     info->secondary_pattern = ContentSettingsPattern();
 606   }
 607   return NULL;
 608 }
 609
 610 // static
 611 HostContentSettingsMap::ProviderType
 612     HostContentSettingsMap::GetProviderTypeFromSource(
 613         const std::string& source) {
 614   for (size_t i = 0; i < arraysize(kProviderNames); ++i) {
 615     if (source == kProviderNames[i])
 616       return static_cast<ProviderType>(i);
 617   }
 618
 619   NOTREACHED();
 620   return DEFAULT_PROVIDER;
 621 }