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 176 matching lines @@
 }
 
 // Returns true whenever the |extension| is hosted and has |permission|.
 // Must have the AppFilter signature.
 template <ExtensionAPIPermission::ID permission>
 bool HostedAppHasPermission(
     const extensions::Extension& extension, Profile* /*profile*/) {
     return extension.is_hosted_app() && extension.HasAPIPermission(permission);
 }
 
+// Create a DictionaryValue* that will act as a data source for a single row
+// in the Media Stream 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 123 matching lines @@
   {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"},
   {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, "medias-tream",
+                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 199 matching lines @@
 
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UpdateGeolocationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
     case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
       UpdateFlashCameraMicExceptionsView();
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      UpdateMediaStreamExceptionsView();
       break;
     default:
       UpdateExceptionsViewFromHostContentSettingsMap(
           type.ToContentSettingsType());
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateOTRExceptionsViewFromModel(
     const ExContentSettingsType& 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 EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
       break;
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
+      // TODO(xians): Add MediaStream support to OTRExceptionsView.
+      break;
     default:
       UpdateExceptionsViewFromOTRHostContentSettingsMap(
           type.ToContentSettingsType());
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
@@ skipping 122 matching lines @@
 
   StringValue type_string(ExContentSettingsTypeToGroupName(
       ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC)));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   UpdateSettingDefaultFromModel(
       ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC));
 }
 
+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(
+      ExContentSettingsType(CONTENT_SETTINGS_TYPE_MEDIASTREAM));
+}
+
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   ContentSettingsForOneType entries;
   GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
 
   ListValue exceptions;
   if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
     Profile* profile = Profile::FromWebUI(web_ui());
     AddExceptionsGrantedByHostedApps(profile, HasProtectedStorage, &exceptions);
   }
@@ skipping 190 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));
 
@@ skipping 46 matching lines @@
         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 {

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

Would you mind doing a small bit of cleanup here? All these if-clauses could
return afterwards instead of having else's, so we could get rid off all the
indentation.

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

Sure, no problem at all.
I found the function gets long anyway, so I break it down into some
sub-functions instead, hope it is fine.

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

Nice, thanks!

       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);
+        // MediaStream is using compound value, so we need to use
+        // SetWebsiteSetting instead of SetContentSetting.

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

I think you *can* use SetWebsiteSetting for simple content types as well, so you
could just always call SetWebsiteSetting here (NULL is converted to
CONTENT_SETTING_DEFAULT).

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

Done.

+        if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
+          settings_map->SetWebsiteSetting(
+              ContentSettingsPattern::FromString(pattern),
+              ContentSettingsPattern::Wildcard(),
+              type.ToContentSettingsType(),
+              "",
+              NULL);
+        } else {
+          settings_map->SetContentSetting(
+              ContentSettingsPattern::FromString(pattern),
+              ContentSettingsPattern::Wildcard(),
+              type.ToContentSettingsType(),
+              "",
+              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));
 
   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 99 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