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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 321 matching lines @@
   {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_MIXEDSCRIPT, "mixed-script"},
   {EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC, "pepper-flash-cameramic"},
+  {CONTENT_SETTINGS_TYPE_MEDIASTREAM, "media-stream"},
 };
 
 ContentSettingsHandler::ContentSettingsHandler() {
 }
 
 ContentSettingsHandler::~ContentSettingsHandler() {
 }
 
 void ContentSettingsHandler::GetLocalizedValues(
     DictionaryValue* localized_strings) {
@@ skipping 74 matching lines @@
     // The header has to be named as <content_type_name>_header.
     { "pepper-flash-cameramic_header", IDS_PEPPER_FLASH_CAMERAMIC_HEADER },
     { "pepperFlashCameramicAsk", IDS_PEPPER_FLASH_CAMERAMIC_ASK_RADIO },
     { "pepperFlashCameramicBlock", IDS_PEPPER_FLASH_CAMERAMIC_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.
+    { "mediaStreamTabLabel", IDS_MEDIA_STREAM_TAB_LABEL },
+    { "media-stream_header", IDS_MEDIA_STREAM_HEADER },
+    { "mediaStreamAsk", IDS_MEDIA_STREAM_ASK_RADIO },
+    { "mediaStreamBlock", 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, "pepper-flash-cameramic",
                 IDS_PEPPER_FLASH_CAMERAMIC_TAB_LABEL);
+  RegisterTitle(localized_strings, "media-stream",
+                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 385 matching lines @@
         entries[i].source != "preference") {
       continue;
     }
     // The content settings UI does not support secondary content settings
     // pattern yet. For content settings set through the content settings UI the
     // secondary pattern is by default a wildcard pattern. Hence users are not
     // able to modify content settings with a secondary pattern other than the
     // wildcard pattern. So only show settings that the user is able to modify.
     // TODO(bauerb): Support a read-only view for those patterns.
     if (entries[i].secondary_pattern == ContentSettingsPattern::Wildcard()) {
-      exceptions.Append(
-          GetExceptionForPage(entries[i].primary_pattern, entries[i].setting,
-                              entries[i].source));
+      // Media Stream is using compound values for exceptions, which are
+      // granted as |CONTENT_SETTING_ALLOW|.
+      ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+      if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM)
+        content_setting = CONTENT_SETTING_ALLOW;
+      else
+        content_setting = entries[i].setting;
+
+      exceptions.Append(GetExceptionForPage(entries[i].primary_pattern,
+                                            content_setting,
+                                            entries[i].source));
     } else {
       LOG(ERROR) << "Secondary content settings patterns are not "
                  << "supported by the content settings UI";
     }
   }
 
   StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
                                    exceptions);
 
@@ skipping 26 matching lines @@
     if (!otr_entries[i].incognito)
       continue;
     // The content settings UI does not support secondary content settings
     // pattern yet. For content settings set through the content settings UI the
     // secondary pattern is by default a wildcard pattern. Hence users are not
     // able to modify content settings with a secondary pattern other than the
     // wildcard pattern. So only show settings that the user is able to modify.
     // TODO(bauerb): Support a read-only view for those patterns.
     if (otr_entries[i].secondary_pattern ==
         ContentSettingsPattern::Wildcard()) {
-      otr_exceptions.Append(
-          GetExceptionForPage(otr_entries[i].primary_pattern,
-                              otr_entries[i].setting,
-                              otr_entries[i].source));
+      ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+      // Media Stream is using compound values for its exceptions and arbitrary
+      // values for its default setting. And all the exceptions are granted as
+      // |CONTENT_SETTING_ALLOW|.
+      if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM &&
+          otr_entries[i].primary_pattern != ContentSettingsPattern::Wildcard())
+        content_setting = CONTENT_SETTING_ALLOW;
+      else
+        content_setting = otr_entries[i].setting;
+
+      otr_exceptions.Append(GetExceptionForPage(otr_entries[i].primary_pattern,
+                                                content_setting,
+                                                otr_entries[i].source));
     } else {
       LOG(ERROR) << "Secondary content settings patterns are not "
                  << "supported by the content settings UI";
     }
   }
 
   StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions",
                                    type_string, otr_exceptions);
 }
 
+void ContentSettingsHandler::RemoveGeolocationException(
+    const ListValue* args, size_t arg_index) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  std::string origin;
+  std::string embedding_origin;
+  bool rv = args->GetString(arg_index++, &origin);
+  DCHECK(rv);
+  rv = args->GetString(arg_index++, &embedding_origin);
+  DCHECK(rv);
+
+  profile->GetHostContentSettingsMap()->
+      SetContentSetting(ContentSettingsPattern::FromString(origin),
+                        ContentSettingsPattern::FromString(embedding_origin),
+                        CONTENT_SETTINGS_TYPE_GEOLOCATION,
+                        std::string(),
+                        CONTENT_SETTING_DEFAULT);
+}
+
+void ContentSettingsHandler::RemoveNotificationException(
+    const ListValue* args, size_t arg_index) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  std::string origin;
+  std::string setting;
+  bool rv = args->GetString(arg_index++, &origin);
+  DCHECK(rv);
+  rv = args->GetString(arg_index++, &setting);
+  DCHECK(rv);
+  ContentSetting content_setting = ContentSettingFromString(setting);
+
+  DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
+         content_setting == CONTENT_SETTING_BLOCK);
+  DesktopNotificationServiceFactory::GetForProfile(profile)->
+      ClearSetting(ContentSettingsPattern::FromString(origin));
+}
+
+void ContentSettingsHandler::RemoveFlashCameraMicException(
+    const ListValue* args, size_t arg_index) {
+  std::string mode;
+  bool rv = args->GetString(arg_index++, &mode);
+  DCHECK(rv);
+  DCHECK_EQ(mode, "normal");
+
+  std::string pattern;
+  rv = args->GetString(arg_index++, &pattern);
+  DCHECK(rv);
+
+  CachedPepperFlashSettings::SiteMap::iterator iter =
+      flash_cameramic_settings_.sites.find(pattern);
+  if (iter != flash_cameramic_settings_.sites.end()) {
+    flash_cameramic_settings_.sites.erase(iter);
+    ppapi::FlashSiteSettings site_settings(
+        1,
+        ppapi::FlashSiteSetting(pattern,
+                                PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT));
+    flash_settings_manager_->SetSitePermission(
+        PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC,
+        site_settings);
+  } else {
+    NOTREACHED();
+  }
+
+  UpdateFlashCameraMicExceptionsView();
+}
+
+void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
+    const ListValue* args, size_t arg_index,
+    const ExContentSettingsType& type) {
+  std::string mode;
+  bool rv = args->GetString(arg_index++, &mode);
+  DCHECK(rv);
+
+  std::string pattern;
+  rv = args->GetString(arg_index++, &pattern);
+  DCHECK(rv);
+
+  HostContentSettingsMap* settings_map =
+      mode == "normal" ? GetContentSettingsMap() :
+                         GetOTRContentSettingsMap();
+  if (settings_map) {
+    settings_map->SetWebsiteSetting(
+        ContentSettingsPattern::FromString(pattern),
+        ContentSettingsPattern::Wildcard(),
+        type.ToContentSettingsType(),
+        "",
+        NULL);
+  }
+}
+
 void ContentSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("setContentFilter",
       base::Bind(&ContentSettingsHandler::SetContentFilter,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("removeException",
       base::Bind(&ContentSettingsHandler::RemoveException,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("setException",
       base::Bind(&ContentSettingsHandler::SetException,
                  base::Unretained(this)));
@@ skipping 102 matching lines @@
           UserMetricsAction("Options_DefaultHandlersSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_MOUSELOCK:
       content::RecordAction(
           UserMetricsAction("Options_DefaultMouseLockSettingChanged"));
       break;
     case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
       content::RecordAction(
           UserMetricsAction("Options_DefaultFlashCameraMicSettingChanged"));
       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));
 
-  Profile* profile = Profile::FromWebUI(web_ui());
-  ExContentSettingsType type = ExContentSettingsTypeFromGroupName(
-      type_string);
-  if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
-    std::string origin;
-    std::string embedding_origin;
-    bool rv = args->GetString(arg_i++, &origin);
-    DCHECK(rv);
-    rv = args->GetString(arg_i++, &embedding_origin);
-    DCHECK(rv);
-
-    profile->GetHostContentSettingsMap()->
-        SetContentSetting(ContentSettingsPattern::FromString(origin),
-                          ContentSettingsPattern::FromString(embedding_origin),
-                          CONTENT_SETTINGS_TYPE_GEOLOCATION,
-                          std::string(),
-                          CONTENT_SETTING_DEFAULT);
-  } else if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
-    std::string origin;
-    std::string setting;
-    bool rv = args->GetString(arg_i++, &origin);
-    DCHECK(rv);
-    rv = args->GetString(arg_i++, &setting);
-    DCHECK(rv);
-    ContentSetting content_setting = ContentSettingFromString(setting);
-
-    DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
-           content_setting == CONTENT_SETTING_BLOCK);
-    DesktopNotificationServiceFactory::GetForProfile(profile)->
-        ClearSetting(ContentSettingsPattern::FromString(origin));
-  } else {
-    std::string mode;
-    bool rv = args->GetString(arg_i++, &mode);
-    DCHECK(rv);
-
-    std::string pattern;
-    rv = args->GetString(arg_i++, &pattern);
-    DCHECK(rv);
-
-    if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-      DCHECK_EQ(mode, "normal");
-
-      CachedPepperFlashSettings::SiteMap::iterator iter =
-          flash_cameramic_settings_.sites.find(pattern);
-      if (iter != flash_cameramic_settings_.sites.end()) {
-        flash_cameramic_settings_.sites.erase(iter);
-        ppapi::FlashSiteSettings site_settings(1,
-            ppapi::FlashSiteSetting(
-                pattern, PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT));
-        flash_settings_manager_->SetSitePermission(
-            PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC,
-            site_settings);
-      } else {
-        NOTREACHED();
-      }
-      UpdateFlashCameraMicExceptionsView();
-    } else {
-      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(),
-            type.ToContentSettingsType(),
-            "",
-            CONTENT_SETTING_DEFAULT);
-      }
-    }
+  ExContentSettingsType type = ExContentSettingsTypeFromGroupName(type_string);
+  switch (type) {
+    case CONTENT_SETTINGS_TYPE_GEOLOCATION:
+      RemoveGeolocationException(args, arg_i);
+      break;
+    case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
+      RemoveNotificationException(args, arg_i);
+      break;
+    case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
+      RemoveFlashCameraMicException(args, arg_i);
+      break;
+    default:
+      RemoveExceptionFromHostContentSettingsMap(args, arg_i, type);
+      break;
   }
 }
 
 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));
 
   ExContentSettingsType type = ExContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
-      type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
+      type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
+      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
     NOTREACHED();
   } else if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
     DCHECK(IsValidHost(pattern));
 
     if (flash_cameramic_settings_.sites.find(pattern) ==
         flash_cameramic_settings_.sites.end()) {
       pattern = CanonicalizeHost(pattern);
     }
     PP_Flash_BrowserOperations_Permission permission =
         FlashPermissionFromContentSetting(ContentSettingFromString(setting));
@@ skipping 107 matching lines @@
   for (size_t i = 0; i < arraysize(kExContentSettingsTypeGroupNames); ++i) {
     if (type == kExContentSettingsTypeGroupNames[i].type)
       return kExContentSettingsTypeGroupNames[i].name;
   }
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace options2