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

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings_pref_provider.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 343 matching lines @@
                 resource_identifier, &setting);
             DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
             value_map_.SetValue(pattern_pair.first,
                                 pattern_pair.second,
                                 content_type,
                                 resource_identifier,
                                 Value::CreateIntegerValue(setting));
           }
         }
       }
-      int setting = CONTENT_SETTING_DEFAULT;
-      if (settings_dictionary->GetIntegerWithoutPathExpansion(
-              GetTypeName(ContentSettingsType(i)), &setting)) {
-        DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
-        setting = FixObsoleteCookiePromptMode(content_type,
-                                              ContentSetting(setting));
-        value_map_.SetValue(pattern_pair.first,
-                            pattern_pair.second,
-                            content_type,
-                            ResourceIdentifier(""),
-                            Value::CreateIntegerValue(setting));
+      if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {

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

Hm. I think we should make the ContentTypeHasCompoundValue() method from
host_content_settings_map.cc publicly accessible and use it here, to make it
easier to add other compound content types.

I'm also not sure whether the PrefProvider needs to verify that the value is a
non-empty dictionary; it seems the client of the HostContentSettingsMap could do
that as well (I try to keep the content_settings/ code as agnostic as possible
of the actual content settings).

Then, if we don't have any special treatment for
CONTENT_SETTINGS_TYPE_MEDIASTREAM anymore, it might be a bit nicer if you pull
out the call to value_map_.SetValue() and just pass in a different Value based
on whether the content type is compound.

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

I make the ContentTypeHasCompoundValue() a static function to be easily publicly
accessed by other classes.

I think it is fine to add a DCHECK() since the empty dictionary is an unexpected
value, and if it does happens, a DCHECK will help detecting it.

Done with moving the SetValue outside.

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

Right, but it's only unexpected to a client that uses the MEDIASTREAM content
type. Other content types might presumably allow empty dictionaries. If you want
to verify the value we're reading from prefs, you could call
HostContentSettingsMap::IsValueAllowedForType() and do the check for a non-empty
dictionary there. That would also verify the value if we're changing a setting.

+        // MediaStream is using compound type as value.
+        Value* value;
+        if (settings_dictionary->GetWithoutPathExpansion(
+            GetTypeName(ContentSettingsType(i)), &value)) {
+          if (value->IsType(Value::TYPE_DICTIONARY)) {
+            DictionaryValue* setting = NULL;
+            if (settings_dictionary->GetDictionaryWithoutPathExpansion(
+                GetTypeName(ContentSettingsType(i)), &setting)) {
+              DCHECK(!setting->empty());
+              value_map_.SetValue(pattern_pair.first,
+                                  pattern_pair.second,
+                                  content_type,
+                                  ResourceIdentifier(""),
+                                  setting->DeepCopy());
+            } else {
+              NOTREACHED();
+            }
+          }
+        }
+      } else {
+        int setting = CONTENT_SETTING_DEFAULT;
+        if (settings_dictionary->GetIntegerWithoutPathExpansion(
+                GetTypeName(ContentSettingsType(i)), &setting)) {
+          DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
+          setting = FixObsoleteCookiePromptMode(content_type,
+                                                ContentSetting(setting));
+          value_map_.SetValue(pattern_pair.first,
+                              pattern_pair.second,
+                              content_type,
+                              ResourceIdentifier(""),
+                              Value::CreateIntegerValue(setting));
+        }
       }
     }
   }
 }
 
 void PrefProvider::UpdatePatternPairsSettings(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
@@ skipping 298 matching lines @@
 
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings