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 48 matching lines @@
   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);
 
-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;
-}
-
 // 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,
@@ skipping 74 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));
-
   // 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));
   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;
   }
 }
 
+// static
+bool HostContentSettingsMap::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 ||
+          type == CONTENT_SETTINGS_TYPE_MEDIASTREAM);
+}
+
 void HostContentSettingsMap::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   const ContentSettingsDetails details(primary_pattern,
                                        secondary_pattern,
                                        content_type,
                                        resource_identifier);
   content::NotificationService::current()->Notify(
@@ skipping 75 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;
+    // 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,
-        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;
 }