Detach the dependency from host_content_settings_map to extension.

chrome/browser/content_settings/host_content_settings_map.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/clock.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/content_settings/content_settings_custom_extension_provider.h"
 #include "chrome/browser/content_settings/content_settings_default_provider.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
-#include "chrome/browser/content_settings/content_settings_internal_extension_provider.h"
 #include "chrome/browser/content_settings/content_settings_observable_provider.h"
 #include "chrome/browser/content_settings/content_settings_policy_provider.h"
 #include "chrome/browser/content_settings/content_settings_pref_provider.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/content_settings_rule.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
-#include "chrome/browser/extensions/api/content_settings/content_settings_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "net/base/net_errors.h"
 #include "net/base/static_cookie_policy.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_EXTENSIONS)
-#include "chrome/browser/extensions/extension_service.h"
-#include "extensions/browser/extension_prefs.h"
 #include "extensions/common/constants.h"
 #endif
 
-using base::UserMetricsAction;
 using content::BrowserThread;
 
 namespace {
 
-typedef std::vector<content_settings::Rule> Rules;
-
-typedef std::pair<std::string, std::string> StringPair;
-
-// TODO(bauerb): Expose constants.
-const char* kProviderNames[] = {
-  "platform_app",
-  "policy",
-  "extension",
-  "preference",
-  "default"
-};
-
-content_settings::SettingSource kProviderSourceMap[] = {
-  content_settings::SETTING_SOURCE_EXTENSION,
-  content_settings::SETTING_SOURCE_POLICY,
-  content_settings::SETTING_SOURCE_EXTENSION,
-  content_settings::SETTING_SOURCE_USER,
-  content_settings::SETTING_SOURCE_USER,
-};
-COMPILE_ASSERT(arraysize(kProviderSourceMap) ==
-                   HostContentSettingsMap::NUM_PROVIDER_TYPES,
-               kProviderSourceMap_has_incorrect_size);
-
 // Returns true if the |content_type| supports a resource identifier.
 // Resource identifiers are supported (but not required) for plug-ins.
 bool SupportsResourceIdentifier(ContentSettingsType content_type) {
   return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
 }
 
 }  // namespace
 
 HostContentSettingsMap::HostContentSettingsMap(
     PrefService* prefs,
     bool incognito) :
 #ifndef NDEBUG
       used_from_thread_id_(base::PlatformThread::CurrentId()),
 #endif
       prefs_(prefs),
       is_off_the_record_(incognito) {
   content_settings::ObservableProvider* policy_provider =
       new content_settings::PolicyProvider(prefs_);
   policy_provider->AddObserver(this);
-  content_settings_providers_[POLICY_PROVIDER] = policy_provider;
+  content_settings_providers_.push_back(policy_provider);
 
-  content_settings::ObservableProvider* pref_provider =
+  pref_provider_ =
       new content_settings::PrefProvider(prefs_, is_off_the_record_);
-  pref_provider->AddObserver(this);
-  content_settings_providers_[PREF_PROVIDER] = pref_provider;
+  pref_provider_->AddObserver(this);
+  content_settings_providers_.push_back(pref_provider_);
 
-  content_settings::ObservableProvider* default_provider =
+  default_provider_ =
       new content_settings::DefaultProvider(prefs_, is_off_the_record_);
-  default_provider->AddObserver(this);
-  content_settings_providers_[DEFAULT_PROVIDER] = default_provider;
+  default_provider_->AddObserver(this);
+  content_settings_providers_.push_back(default_provider_);
 
   if (!is_off_the_record_) {
     // Migrate obsolete preferences.
     MigrateObsoleteClearOnExitPref();
   }
 }
 
-#if defined(ENABLE_EXTENSIONS)
-void HostContentSettingsMap::RegisterExtensionService(
-    ExtensionService* extension_service) {
-  DCHECK(extension_service);
-  DCHECK(!content_settings_providers_[INTERNAL_EXTENSION_PROVIDER]);
-  DCHECK(!content_settings_providers_[CUSTOM_EXTENSION_PROVIDER]);
-
-  content_settings::InternalExtensionProvider* internal_extension_provider =
-      new content_settings::InternalExtensionProvider(extension_service);
-  internal_extension_provider->AddObserver(this);
-  content_settings_providers_[INTERNAL_EXTENSION_PROVIDER] =
-      internal_extension_provider;
-
-  content_settings::ObservableProvider* custom_extension_provider =
-      new content_settings::CustomExtensionProvider(
-          extensions::ContentSettingsService::Get(
-              extension_service->GetBrowserContext())->content_settings_store(),
-          is_off_the_record_);
-  custom_extension_provider->AddObserver(this);
-  content_settings_providers_[CUSTOM_EXTENSION_PROVIDER] =
-      custom_extension_provider;
-
-#ifndef NDEBUG
-  DCHECK(used_from_thread_id_ != base::kInvalidThreadId)
-      << "Used from multiple threads before initialization complete.";
-#endif
-
-  OnContentSettingChanged(ContentSettingsPattern(),
-                          ContentSettingsPattern(),
-                          CONTENT_SETTINGS_TYPE_DEFAULT,
-                          std::string());
-}
-#endif
-
 // static
 void HostContentSettingsMap::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       prefs::kContentSettingsWindowLastTabIndex,
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
       prefs::kContentSettingsClearOnExitMigrated,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
   // Register the prefs for the content settings providers.
   content_settings::DefaultProvider::RegisterProfilePrefs(registry);
   content_settings::PrefProvider::RegisterProfilePrefs(registry);
   content_settings::PolicyProvider::RegisterProfilePrefs(registry);
 }
 
+void HostContentSettingsMap::RegisterProvider(
+    scoped_ptr<content_settings::ObservableProvider> provider) {
+  provider->AddObserver(this);
+  content_settings_providers_.push_back(provider.release());
+
+#ifndef NDEBUG
+  DCHECK_NE(used_from_thread_id_, base::kInvalidThreadId)
+      << "Used from multiple threads before initialization complete.";
+#endif
+
+  OnContentSettingChanged(ContentSettingsPattern(),
+                          ContentSettingsPattern(),
+                          CONTENT_SETTINGS_TYPE_DEFAULT,
+                          std::string());
+}
+
+size_t HostContentSettingsMap::GetNumProviders() const {
+  return content_settings_providers_.size();
+}
+
+const content_settings::ProviderInterface*
+HostContentSettingsMap::GetProviderAt(

[Bernhard Bauer, 2014/09/12 09:07:25]

The parameter should fit on this line, no?

+    size_t i) const {
+  return content_settings_providers_[i];
+}
+
 ContentSetting HostContentSettingsMap::GetDefaultContentSettingFromProvider(
     ContentSettingsType content_type,
     content_settings::ProviderInterface* provider) const {
   scoped_ptr<content_settings::RuleIterator> rule_iterator(
       provider->GetRuleIterator(content_type, std::string(), false));
 
   ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
   while (rule_iterator->HasNext()) {
     content_settings::Rule rule = rule_iterator->Next();
     if (rule.primary_pattern == wildcard &&
         rule.secondary_pattern == wildcard) {
       return content_settings::ValueToContentSetting(rule.value.get());
     }
   }
   return CONTENT_SETTING_DEFAULT;
 }
 
 ContentSetting HostContentSettingsMap::GetDefaultContentSetting(
     ContentSettingsType content_type,
     std::string* provider_id) const {
   UsedContentSettingsProviders();
 
   // Iterate through the list of providers and return the first non-NULL value
   // that matches |primary_url| and |secondary_url|.
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
-    if (provider->first == PREF_PROVIDER)
+    if (*provider == pref_provider_)
       continue;
     ContentSetting default_setting =
-        GetDefaultContentSettingFromProvider(content_type, provider->second);
+        GetDefaultContentSettingFromProvider(content_type, *provider);
     if (default_setting != CONTENT_SETTING_DEFAULT) {
       if (provider_id)
-        *provider_id = kProviderNames[provider->first];
+        *provider_id = (*provider)->GetProviderName();
       return default_setting;
     }
   }
 
   // The method GetDefaultContentSetting always has to return an explicit
   // value that is to be used as default. We here rely on the
   // DefaultProvider to always provide a value.
   NOTREACHED();
   return CONTENT_SETTING_DEFAULT;
 }
@@ skipping 18 matching lines @@
   DCHECK(settings);
   UsedContentSettingsProviders();
 
   settings->clear();
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     // For each provider, iterate first the incognito-specific rules, then the
     // normal rules.
     if (is_off_the_record_) {
-      AddSettingsForOneType(provider->second,
-                            provider->first,
+      AddSettingsForOneType(*provider,
                             content_type,
                             resource_identifier,
                             settings,
                             true);
     }
-    AddSettingsForOneType(provider->second,
-                          provider->first,
+    AddSettingsForOneType(*provider,
                           content_type,
                           resource_identifier,
                           settings,
                           false);
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
@@ skipping 17 matching lines @@
     const std::string& resource_identifier,
     base::Value* value) {
   DCHECK(IsValueAllowedForType(prefs_, value, content_type));
   DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
   UsedContentSettingsProviders();
 
   for (ProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
-    if (provider->second->SetWebsiteSetting(primary_pattern,
-                                            secondary_pattern,
-                                            content_type,
-                                            resource_identifier,
-                                            value)) {
+    if ((*provider)->SetWebsiteSetting(primary_pattern,
+                                       secondary_pattern,
+                                       content_type,
+                                       resource_identifier,
+                                       value)) {
       return;
     }
   }
   NOTREACHED();
 }
 
 void HostContentSettingsMap::SetNarrowestWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
@@ skipping 71 matching lines @@
       ContentSettingsPattern::FromURLNoWildcard(secondary_url),
       content_type);
 }
 
 void HostContentSettingsMap::UpdateLastUsageByPattern(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type) {
   UsedContentSettingsProviders();
 
-  GetPrefProvider()->UpdateLastUsage(
+  pref_provider_->UpdateLastUsage(
       primary_pattern, secondary_pattern, content_type);
 
   FOR_EACH_OBSERVER(
       content_settings::Observer,
       observers_,
       OnContentSettingUsed(primary_pattern, secondary_pattern, content_type));
 }
 
 base::Time HostContentSettingsMap::GetLastUsage(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type) {
   return GetLastUsageByPattern(
       ContentSettingsPattern::FromURLNoWildcard(primary_url),
       ContentSettingsPattern::FromURLNoWildcard(secondary_url),
       content_type);
 }
 
 base::Time HostContentSettingsMap::GetLastUsageByPattern(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type) {
   UsedContentSettingsProviders();
 
-  return GetPrefProvider()->GetLastUsage(
+  return pref_provider_->GetLastUsage(
       primary_pattern, secondary_pattern, content_type);
 }
 
 void HostContentSettingsMap::AddObserver(content_settings::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void HostContentSettingsMap::RemoveObserver(
     content_settings::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void HostContentSettingsMap::SetPrefClockForTesting(
     scoped_ptr<base::Clock> clock) {
   UsedContentSettingsProviders();
 
-  GetPrefProvider()->SetClockForTesting(clock.Pass());
+  pref_provider_->SetClockForTesting(clock.Pass());
 }
 
 void HostContentSettingsMap::AddExceptionForURL(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     ContentSetting setting) {
   // TODO(markusheintz): Until the UI supports pattern pairs, both urls must
   // match.
   DCHECK(primary_url == secondary_url);
@@ skipping 13 matching lines @@
                     std::string(),
                     setting);
 }
 
 void HostContentSettingsMap::ClearSettingsForOneType(
     ContentSettingsType content_type) {
   UsedContentSettingsProviders();
   for (ProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
-    provider->second->ClearAllContentSettingsRules(content_type);
+    (*provider)->ClearAllContentSettingsRules(content_type);
   }
 }
 
 bool HostContentSettingsMap::IsValueAllowedForType(
     PrefService* prefs, const base::Value* value, ContentSettingsType type) {
   return ContentTypeHasCompoundValue(type) || IsSettingAllowedForType(
       prefs, content_settings::ValueToContentSetting(value), type);
 }
 
 // static
@@ skipping 74 matching lines @@
   FOR_EACH_OBSERVER(content_settings::Observer,
                     observers_,
                     OnContentSettingChanged(primary_pattern,
                                             secondary_pattern,
                                             content_type,
                                             resource_identifier));
 }
 
 HostContentSettingsMap::~HostContentSettingsMap() {
   DCHECK(!prefs_);
-  STLDeleteValues(&content_settings_providers_);
 }
 
 void HostContentSettingsMap::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
   prefs_ = NULL;
   for (ProviderIterator it = content_settings_providers_.begin();
        it != content_settings_providers_.end();
        ++it) {
-    it->second->ShutdownOnUIThread();
+    (*it)->ShutdownOnUIThread();
   }
 }
 
 void HostContentSettingsMap::MigrateObsoleteClearOnExitPref() {
   // Don't migrate more than once.
   if (prefs_->HasPrefPath(prefs::kContentSettingsClearOnExitMigrated) &&
       prefs_->GetBoolean(prefs::kContentSettingsClearOnExitMigrated)) {
     return;
   }
 
   if (!prefs_->GetBoolean(prefs::kClearSiteDataOnExit)) {
     // Nothing to be done
     prefs_->SetBoolean(prefs::kContentSettingsClearOnExitMigrated, true);
     return;
   }
 
   // Change the default cookie settings:
   //  old              new
   //  ---------------- ----------------
   //  ALLOW            SESSION_ONLY
   //  SESSION_ONLY     SESSION_ONLY
   //  BLOCK            BLOCK
   ContentSetting default_setting = GetDefaultContentSettingFromProvider(
       CONTENT_SETTINGS_TYPE_COOKIES,
-      content_settings_providers_[DEFAULT_PROVIDER]);
+      default_provider_);
   if (default_setting == CONTENT_SETTING_ALLOW) {
     SetDefaultContentSetting(
         CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_SESSION_ONLY);
   }
 
   // Change the exceptions using the same rules.
   ContentSettingsForOneType exceptions;
-  AddSettingsForOneType(content_settings_providers_[PREF_PROVIDER],
-                        PREF_PROVIDER,
+  AddSettingsForOneType(pref_provider_,
                         CONTENT_SETTINGS_TYPE_COOKIES,
                         std::string(),
                         &exceptions,
                         false);
   for (ContentSettingsForOneType::iterator it = exceptions.begin();
        it != exceptions.end(); ++it) {
     if (it->setting != CONTENT_SETTING_ALLOW)
       continue;
     SetWebsiteSetting(it->primary_pattern,
                       it->secondary_pattern,
                       CONTENT_SETTINGS_TYPE_COOKIES,
                       std::string(),
                       new base::FundamentalValue(CONTENT_SETTING_SESSION_ONLY));
   }
 
   prefs_->SetBoolean(prefs::kContentSettingsClearOnExitMigrated, true);
 }
 
 void HostContentSettingsMap::AddSettingsForOneType(
     const content_settings::ProviderInterface* provider,
-    ProviderType provider_type,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSettingsForOneType* settings,
     bool incognito) const {
   scoped_ptr<content_settings::RuleIterator> rule_iterator(
       provider->GetRuleIterator(content_type,
                                 resource_identifier,
                                 incognito));
   while (rule_iterator->HasNext()) {
     const content_settings::Rule& rule = rule_iterator->Next();
     ContentSetting setting_value = CONTENT_SETTING_DEFAULT;
     // TODO(bauerb): Return rules as a list of values, not content settings.
     // Handle the case using compound values for its exceptions and arbitrary
     // values for its default setting. Here we assume all the exceptions
     // are granted as |CONTENT_SETTING_ALLOW|.
     if (ContentTypeHasCompoundValue(content_type) &&
         rule.value.get() &&
         rule.primary_pattern != ContentSettingsPattern::Wildcard()) {
       setting_value = CONTENT_SETTING_ALLOW;
     } else {
       setting_value = content_settings::ValueToContentSetting(rule.value.get());
     }
     settings->push_back(ContentSettingPatternSource(
         rule.primary_pattern, rule.secondary_pattern,
         setting_value,
-        kProviderNames[provider_type],
+        provider->GetProviderName(),
         incognito));
   }
 }
 
 void HostContentSettingsMap::UsedContentSettingsProviders() const {
 #ifndef NDEBUG
   if (used_from_thread_id_ == base::kInvalidThreadId)
     return;
 
   if (base::PlatformThread::CurrentId() != used_from_thread_id_)
@@ skipping 64 matching lines @@
     primary_pattern = &info->primary_pattern;
     secondary_pattern = &info->secondary_pattern;
   }
 
   // The list of |content_settings_providers_| is ordered according to their
   // precedence.
   for (ConstProviderIterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end();
        ++provider) {
     base::Value* value = content_settings::GetContentSettingValueAndPatterns(
-        provider->second, primary_url, secondary_url, content_type,
+        *provider, primary_url, secondary_url, content_type,
         resource_identifier, is_off_the_record_,
         primary_pattern, secondary_pattern);
     if (value) {
       if (info)
-        info->source = kProviderSourceMap[provider->first];
+        info->source = (*provider)->GetSettingSource();
       return value;
     }
   }
 
   if (info) {
     info->source = content_settings::SETTING_SOURCE_NONE;
     info->primary_pattern = ContentSettingsPattern();
     info->secondary_pattern = ContentSettingsPattern();
   }
   return NULL;
 }
-
-// static
-HostContentSettingsMap::ProviderType
-    HostContentSettingsMap::GetProviderTypeFromSource(
-        const std::string& source) {
-  for (size_t i = 0; i < arraysize(kProviderNames); ++i) {
-    if (source == kProviderNames[i])
-      return static_cast<ProviderType>(i);
-  }
-
-  NOTREACHED();
-  return DEFAULT_PROVIDER;
-}
-
-content_settings::PrefProvider* HostContentSettingsMap::GetPrefProvider() {
-  return static_cast<content_settings::PrefProvider*>(
-      content_settings_providers_[PREF_PROVIDER]);
-}