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

chrome/browser/ui/webui/options2/content_settings_handler2.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/ui/webui/options2/content_settings_handler2.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 62 matching lines @@
   {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
   {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
   {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
   {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
   {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
   {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
   {CONTENT_SETTINGS_TYPE_INTENTS, "intents"},
   {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
   {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
   {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM, "mediastream"},
 };
 COMPILE_ASSERT(arraysize(kContentSettingsTypeGroupNames) ==
                    CONTENT_SETTINGS_NUM_TYPES,
                MISSING_CONTENT_SETTINGS_TYPE);
 
 ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (name == kContentSettingsTypeGroupNames[i].name)
       return kContentSettingsTypeGroupNames[i].type;
   }
@@ skipping 97 matching lines @@
     ContentSetting setting,
     const std::string& provider_name) {
   DictionaryValue* exception = new DictionaryValue();
   exception->SetString(kDisplayPattern, pattern.ToString());
   exception->SetString(kSetting, ContentSettingToString(setting));
   exception->SetString(kOrigin, pattern.ToString());
   exception->SetString(kSource, provider_name);
   return exception;
 }
 
+// Create a DictionaryValue* that will act as a data source for a single row
+// in the mediastream exceptions table. Ownership of the pointer is
+// passed to the caller.
+DictionaryValue* GetMediaStreamExceptionForPage(
+    const ContentSettingsPattern& pattern) {
+  DictionaryValue* exception = new DictionaryValue();
+  exception->SetString(kDisplayPattern, pattern.ToString());
+  exception->SetString(kSetting, ContentSettingToString(CONTENT_SETTING_ALLOW));
+  exception->SetString(kOrigin, pattern.ToString());
+  exception->SetString(kSource, std::string());
+  return exception;
+}
+
 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from
 // the web extent of a hosted |app|.
 void AddExceptionForHostedApp(const std::string& url_pattern,
     const extensions::Extension& app, ListValue* exceptions) {
   DictionaryValue* exception = new DictionaryValue();
   exception->SetString(kDisplayPattern, url_pattern);
   exception->SetString(kSetting, ContentSettingToString(CONTENT_SETTING_ALLOW));
   exception->SetString(kOrigin, url_pattern);
   exception->SetString(kEmbeddingOrigin, url_pattern);
   exception->SetString(kSource, "HostedApp");
@@ skipping 117 matching lines @@
     { "mouselock_header", IDS_MOUSE_LOCK_HEADER },
     { "mouselock_allow", IDS_MOUSE_LOCK_ALLOW_RADIO },
     { "mouselock_ask", IDS_MOUSE_LOCK_ASK_RADIO },
     { "mouselock_block", IDS_MOUSE_LOCK_BLOCK_RADIO },
 #if defined(OS_CHROMEOS)
     // Protected Content filter
     { "protectedContentTabLabel", IDS_PROTECTED_CONTENT_TAB_LABEL },
     { "protectedContentInfo", IDS_PROTECTED_CONTENT_INFO },
     { "protectedContentEnable", IDS_PROTECTED_CONTENT_ENABLE},
 #endif  // defined(OS_CHROMEOS)
+    // Media stream capture device filter.
+    { "mediastream_tab_label", IDS_MEDIA_STREAM_TAB_LABEL },
+    { "mediastream_header", IDS_MEDIA_STREAM_HEADER },
+    { "mediastream_ask", IDS_MEDIA_STREAM_ASK_RADIO },
+    { "mediastream_block", IDS_MEDIA_STREAM_BLOCK_RADIO },
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(localized_strings, "contentSettingsPage",
                 IDS_CONTENT_SETTINGS_TITLE);
 
   // Register titles for each of the individual settings whose exception
   // dialogs will be processed by |ContentSettingsHandler|.
   RegisterTitle(localized_strings, "cookies",
                 IDS_COOKIES_TAB_LABEL);
   RegisterTitle(localized_strings, "images",
                 IDS_IMAGES_TAB_LABEL);
   RegisterTitle(localized_strings, "javascript",
                 IDS_JAVASCRIPT_TAB_LABEL);
   RegisterTitle(localized_strings, "plugins",
                 IDS_PLUGIN_TAB_LABEL);
   RegisterTitle(localized_strings, "popups",
                 IDS_POPUP_TAB_LABEL);
   RegisterTitle(localized_strings, "location",
                 IDS_GEOLOCATION_TAB_LABEL);
   RegisterTitle(localized_strings, "notifications",
                 IDS_NOTIFICATIONS_TAB_LABEL);
   RegisterTitle(localized_strings, "fullscreen",
                 IDS_FULLSCREEN_TAB_LABEL);
   RegisterTitle(localized_strings, "mouselock",
                 IDS_MOUSE_LOCK_TAB_LABEL);
+  RegisterTitle(localized_strings, "mediastream",
+                IDS_MEDIA_STREAM_TAB_LABEL);
 
   Profile* profile = Profile::FromWebUI(web_ui());
   localized_strings->SetBoolean(
       "enable_web_intents",
       web_intents::IsWebIntentsEnabledForProfile(profile));
   // TODO(marja): clean up the options UI after the decision on the session
   // restore changes has stabilized.
   localized_strings->SetBoolean(
       "enable_restore_session_state", false);
 }
@@ skipping 156 matching lines @@
   if (type == CONTENT_SETTINGS_TYPE_INTENTS)
     return;
 
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UpdateGeolocationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      UpdateMediaStreamExceptionsView();
+      break;
     default:
       UpdateExceptionsViewFromHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateOTRExceptionsViewFromModel(
     ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
     case CONTENT_SETTINGS_TYPE_INTENTS:
     case CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      // TODO(xians): Add MediaStream support to OTRExceptionsView.
       break;
     default:
       UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
@@ skipping 94 matching lines @@
   StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
+void ContentSettingsHandler::UpdateMediaStreamExceptionsView() {
+  ContentSettingsForOneType entries;
+  GetContentSettingsMap()->GetSettingsForOneType(
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM, "", &entries);
+
+  ListValue exceptions;
+  for (size_t i = 0; i < entries.size(); ++i) {
+    // Don't add default settings.
+    if (entries[i].primary_pattern == ContentSettingsPattern::Wildcard() &&
+        entries[i].secondary_pattern == ContentSettingsPattern::Wildcard() &&
+        entries[i].source != "preference") {
+      continue;
+    }
+
+    exceptions.Append(
+        GetMediaStreamExceptionForPage(entries[i].primary_pattern));
+  }
+
+  StringValue type_string(ContentSettingsTypeToGroupName(
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM));
+  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
+                                   exceptions);
+
+  // This is mainly here to keep this function ideologically parallel to
+  // UpdateExceptionsViewFromHostContentSettingsMap().
+  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MEDIASTREAM);
+}
+
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   ContentSettingsForOneType entries;
   GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
 
   ListValue exceptions;
   for (size_t i = 0; i < entries.size(); ++i) {
     // Skip default settings from extensions and policy, and the default content
     // settings; all of them will affect the default setting UI.
     if (entries[i].primary_pattern == ContentSettingsPattern::Wildcard() &&
@@ skipping 174 matching lines @@
           UserMetricsAction("Options_DefaultGeolocationSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_INTENTS:
       content::RecordAction(
           UserMetricsAction("Options_DefaultHandlersSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_MOUSELOCK:
       content::RecordAction(
           UserMetricsAction("Options_DefaultMouseLockSettingChanged"));
       break;
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      content::RecordAction(
+          UserMetricsAction("Options_DefaultMediaStreamSettingChanged"));
+      break;
     default:
       break;
   }
 }
 
 void ContentSettingsHandler::RemoveException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
 
@@ skipping 34 matching lines @@
     std::string pattern;
     rv = args->GetString(arg_i++, &pattern);
     DCHECK(rv);
 
     HostContentSettingsMap* settings_map =
         mode == "normal" ? GetContentSettingsMap() :
                            GetOTRContentSettingsMap();
     // The settings map could be null if the mode was OTR but the OTR profile
     // got destroyed before we received this message.
     if (settings_map) {
-      settings_map->SetContentSetting(
-          ContentSettingsPattern::FromString(pattern),
-          ContentSettingsPattern::Wildcard(),
-          ContentSettingsTypeFromGroupName(type_string),
-          "",
-          CONTENT_SETTING_DEFAULT);
+      // MediaStream is using compound value, so we need to use
+      // SetWebsiteSetting instead of SetContentSetting.
+      if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
+        settings_map->SetWebsiteSetting(
+            ContentSettingsPattern::FromString(pattern),
+            ContentSettingsPattern::Wildcard(),
+            ContentSettingsTypeFromGroupName(type_string),
+            "",
+            NULL);
+      } else {
+        settings_map->SetContentSetting(
+            ContentSettingsPattern::FromString(pattern),
+            ContentSettingsPattern::Wildcard(),
+            ContentSettingsTypeFromGroupName(type_string),
+            "",
+            CONTENT_SETTING_DEFAULT);
+      }
     }
   }
 }
 
 void ContentSettingsHandler::SetException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
   std::string mode;
   CHECK(args->GetString(arg_i++, &mode));
   std::string pattern;
   CHECK(args->GetString(arg_i++, &pattern));
   std::string setting;
   CHECK(args->GetString(arg_i++, &setting));
 
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
-      type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
+      type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
+      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
     NOTREACHED();
     return;
   }
 
   HostContentSettingsMap* settings_map =
       mode == "normal" ? GetContentSettingsMap() :
                          GetOTRContentSettingsMap();
 
   // The settings map could be null if the mode was OTR but the OTR profile
   // got destroyed before we received this message.
@@ skipping 53 matching lines @@
 
 HostContentSettingsMap*
     ContentSettingsHandler::GetOTRContentSettingsMap() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (profile->HasOffTheRecordProfile())
     return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap();
   return NULL;
 }
 
 }  // namespace options2