add "always allow" option to the mediastream infobar and allow user to allow/not allow acces to devi

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 52 matching lines @@
   content_settings::SETTING_SOURCE_USER,
 };
 COMPILE_ASSERT(arraysize(kProviderSourceMap) ==
                    HostContentSettingsMap::NUM_PROVIDER_TYPES,
                kProviderSourceMap_has_incorrect_size);
 
 bool ContentTypeHasCompoundValue(ContentSettingsType type) {
   // Values for content type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE are
   // of type dictionary/map. Compound types like dictionaries can't be mapped to
   // the type |ContentSetting|.
-  return type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE;
+  return (type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE ||
+          type == CONTENT_SETTINGS_TYPE_MEDIASTREAM);
 }
 
 // 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
 
@@ skipping 94 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 {
-  DCHECK(!ContentTypeHasCompoundValue(content_type));

[Bernhard Bauer, 2012/06/18 17:38:14]

Are you sure about this? This method is supposed to return a ContentSetting, so
it can't be called for a content type where the value can't be coerced to a
content setting. We might need to add a GetDefaultWebsiteSetting method that
doesn't do the coercion.

[no longer working on chromium, 2012/06/19 12:23:16]

I assume the default values are only "ask/allow/block" for all the content
types, regardless if they are using compound value or not.
Take MediaStream as example, it uses a dictionary value {audio: name, video:
name}, but for its default value, it only has "ask/block".

I think we should allow a type using compound value and also contentsetting
value for its default setting.

Furthermore, I don't think this DCHECK adds much here since
content_settings::ValueToContentSetting() will hit a DCHECK anyway.

[Bernhard Bauer, 2012/06/19 14:33:34]

Hm, ok. I guess it's fair to say that a content type using compound values can
have arbitrary values.

-
   // 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 48 matching lines @@
                           content_type,
                           resource_identifier,
                           settings,
                           false);
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
-  DCHECK(!ContentTypeHasCompoundValue(content_type));

[Bernhard Bauer, 2012/06/18 17:38:14]

In this case it's easier; we can replace calls to SetDefaultContentSetting()
with SetWebsiteSetting(ContentSettingsPattern::Wildcard(), ...).

[no longer working on chromium, 2012/06/19 12:23:16]

See reply above.

   DCHECK(IsSettingAllowedForType(prefs_, setting, content_type));
 
   base::Value* value = NULL;
   if (setting != CONTENT_SETTING_DEFAULT)
     value = Value::CreateIntegerValue(setting);
   SetWebsiteSetting(
       ContentSettingsPattern::Wildcard(),
       ContentSettingsPattern::Wildcard(),
       content_type,
       std::string(),
@@ skipping 70 matching lines @@
     ContentSettingsType content_type) {
   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 IsSettingAllowedForType(
+  return ContentTypeHasCompoundValue(type) || IsSettingAllowedForType(
       prefs, content_settings::ValueToContentSetting(value), type);
 }
 
 // static
 bool HostContentSettingsMap::IsSettingAllowedForType(
     PrefService* prefs,
     ContentSetting setting,
     ContentSettingsType content_type) {
   // Intents content settings are hidden behind a switch for now.
   if (content_type == CONTENT_SETTINGS_TYPE_INTENTS) {
@@ skipping 14 matching lines @@
     return true;
   }
   switch (content_type) {
     case CONTENT_SETTINGS_TYPE_COOKIES:
       return setting == CONTENT_SETTING_SESSION_ONLY;
     case CONTENT_SETTINGS_TYPE_PLUGINS:
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
     case CONTENT_SETTINGS_TYPE_INTENTS:
     case CONTENT_SETTINGS_TYPE_MOUSELOCK:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
       return setting == CONTENT_SETTING_ASK;
     default:
       return false;
   }
 }
 
 void HostContentSettingsMap::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
@@ skipping 81 matching lines @@
     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;

[Bernhard Bauer, 2012/06/18 17:38:14]

Can you add a TODO(bauerb) that we should return rules as a list of values, not
content settings?

[no longer working on chromium, 2012/06/19 12:23:16]

Done.

+    // For the cases using compound value, we assume it is valid as long as
+    // the value is not NULL.
+    if (ContentTypeHasCompoundValue(content_type) && rule.value.get()) {
+      setting_value = CONTENT_SETTING_ALLOW;
+    } else {
+      setting_value = content_settings::ValueToContentSetting(rule.value.get());
+    }
     settings->push_back(ContentSettingPatternSource(
         rule.primary_pattern, rule.secondary_pattern,
-        content_settings::ValueToContentSetting(rule.value.get()),
+        setting_value,
         kProviderNames[provider_type],
         incognito));
   }
 }
 
 bool HostContentSettingsMap::ShouldAllowAllContent(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
@@ skipping 52 matching lines @@
     }
   }
 
   if (info) {
     info->source = content_settings::SETTING_SOURCE_NONE;
     info->primary_pattern = ContentSettingsPattern();
     info->secondary_pattern = ContentSettingsPattern();
   }
   return NULL;
 }