Remove unused lock, add debug-only verification of intended usage.

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"
@@ skipping 60 matching lines @@
 // 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)
-    : prefs_(prefs),
+    bool incognito) :
+#ifndef NDEBUG
+      used_content_settings_providers_(false),
+#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::ObservableProvider* pref_provider =
       new content_settings::PrefProvider(prefs_, is_off_the_record_);
   pref_provider->AddObserver(this);
   content_settings_providers_[PREF_PROVIDER] = pref_provider;
 
   content_settings::ObservableProvider* default_provider =
       new content_settings::DefaultProvider(prefs_, is_off_the_record_);
   default_provider->AddObserver(this);
   content_settings_providers_[DEFAULT_PROVIDER] = default_provider;
 
   if (!is_off_the_record_) {
     // Migrate obsolete preferences.
     MigrateObsoleteClearOnExitPref();
   }
 }
 
 #if defined(ENABLE_EXTENSIONS)
 void HostContentSettingsMap::RegisterExtensionService(
     ExtensionService* extension_service) {
   DCHECK(extension_service);
+#ifndef NDEBUG
+  DCHECK(!used_content_settings_providers_);
+#endif
   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 =
@@ skipping 42 matching lines @@
         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)
       continue;
     ContentSetting default_setting =
         GetDefaultContentSettingFromProvider(content_type, provider->second);
     if (default_setting != CONTENT_SETTING_DEFAULT) {
@@ skipping 21 matching lines @@
   return content_settings::ValueToContentSetting(value.get());
 }
 
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSettingsForOneType* settings) const {
   DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
   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,
@@ skipping 29 matching lines @@
 
 void HostContentSettingsMap::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     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)) {
       return;
     }
@@ skipping 39 matching lines @@
 
   SetContentSetting(ContentSettingsPattern::FromURL(primary_url),
                     ContentSettingsPattern::Wildcard(),
                     content_type,
                     resource_identifier,
                     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);
   }
 }
 
 bool HostContentSettingsMap::IsValueAllowedForType(
     PrefService* prefs, const base::Value* value, ContentSettingsType type) {
   return ContentTypeHasCompoundValue(type) || IsSettingAllowedForType(
@@ skipping 168 matching lines @@
       setting_value = content_settings::ValueToContentSetting(rule.value.get());
     }
     settings->push_back(ContentSettingPatternSource(
         rule.primary_pattern, rule.secondary_pattern,
         setting_value,
         kProviderNames[provider_type],
         incognito));
   }
 }
 
+void HostContentSettingsMap::UsedContentSettingsProviders() const {
+#ifndef NDEBUG
+  used_content_settings_providers_ = true;
+#endif
+}
+
 bool HostContentSettingsMap::ShouldAllowAllContent(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
       content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     return false;
   }
   if (secondary_url.SchemeIs(chrome::kChromeUIScheme) &&
       content_type == CONTENT_SETTINGS_TYPE_COOKIES &&
@@ skipping 65 matching lines @@
     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;
 }