Show policy allowed URLs as policy exceptions in the media settings.

chrome/browser/ui/webui/options/content_settings_handler.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/options/content_settings_handler.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/web_site_settings_uma_util.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "components/content_settings/core/browser/content_settings_details.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/browser/plugins_field_trial.h"
 #include "components/content_settings/core/common/content_settings.h"
@@ skipping 97 matching lines @@
     if (name == kContentSettingsTypeGroupNames[i].name)
       return kContentSettingsTypeGroupNames[i].type;
   }
 
   NOTREACHED() << name << " is not a recognized content settings type.";
   return CONTENT_SETTINGS_TYPE_DEFAULT;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies).
-// Ownership of the pointer is passed to the caller.
-base::DictionaryValue* GetExceptionForPage(
+scoped_ptr<base::DictionaryValue> GetExceptionForPage(
     const ContentSettingsPattern& pattern,
     const ContentSettingsPattern& secondary_pattern,
     const ContentSetting& setting,
     const std::string& provider_name) {
   base::DictionaryValue* exception = new base::DictionaryValue();
   exception->SetString(kOrigin, pattern.ToString());
   exception->SetString(kEmbeddingOrigin,
                        secondary_pattern == ContentSettingsPattern::Wildcard() ?
                            std::string() :
                            secondary_pattern.ToString());
   exception->SetString(kSetting, ContentSettingToString(setting));
   exception->SetString(kSource, provider_name);
-  return exception;
+  return make_scoped_ptr(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
-// in the Geolocation exceptions table. Ownership of the pointer is passed to
-// the caller.
-base::DictionaryValue* GetGeolocationExceptionForPage(
+// in the Geolocation exceptions table.
+scoped_ptr<base::DictionaryValue> GetGeolocationExceptionForPage(
     const ContentSettingsPattern& origin,
     const ContentSettingsPattern& embedding_origin,
     ContentSetting setting) {
   base::DictionaryValue* exception = new base::DictionaryValue();
   exception->SetString(kSetting, ContentSettingToString(setting));
   exception->SetString(kOrigin, origin.ToString());
   exception->SetString(kEmbeddingOrigin, embedding_origin.ToString());
-  return exception;
+  return make_scoped_ptr(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
-// in the desktop notifications exceptions table. Ownership of the pointer is
-// passed to the caller.
-base::DictionaryValue* GetNotificationExceptionForPage(
+// in the desktop notifications exceptions table.
+scoped_ptr<base::DictionaryValue> GetNotificationExceptionForPage(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSetting setting,
     const std::string& provider_name) {
   std::string embedding_origin;
   if (secondary_pattern != ContentSettingsPattern::Wildcard())
     embedding_origin = secondary_pattern.ToString();
 
   base::DictionaryValue* exception = new base::DictionaryValue();
   exception->SetString(kSetting, ContentSettingToString(setting));
   exception->SetString(kOrigin, primary_pattern.ToString());
   exception->SetString(kEmbeddingOrigin, embedding_origin);
   exception->SetString(kSource, provider_name);
-  return exception;
+  return make_scoped_ptr(exception);
 }
 
 // Returns true whenever the |extension| is hosted and has |permission|.
 // Must have the AppFilter signature.
 template <APIPermission::ID permission>
 bool HostedAppHasPermission(const extensions::Extension& extension,
                             content::BrowserContext* /* context */) {
   return extension.is_hosted_app() &&
          extension.permissions_data()->HasAPIPermission(permission);
 }
@@ skipping 308 matching lines @@
   pref_change_registrar_.Add(
       prefs::kPepperFlashSettingsEnabled,
       base::Bind(&ContentSettingsHandler::OnPepperFlashPrefChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kAudioCaptureAllowed,
       base::Bind(&ContentSettingsHandler::UpdateSettingDefaultFromModel,
                  base::Unretained(this),
                  CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   pref_change_registrar_.Add(
+      prefs::kAudioCaptureAllowedUrls,
+      base::Bind(&ContentSettingsHandler::UpdateExceptionsViewFromModel,
+                 base::Unretained(this),
+                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
+  pref_change_registrar_.Add(
       prefs::kVideoCaptureAllowed,
       base::Bind(&ContentSettingsHandler::UpdateSettingDefaultFromModel,
                  base::Unretained(this),
                  CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   pref_change_registrar_.Add(
+      prefs::kVideoCaptureAllowedUrls,
+      base::Bind(&ContentSettingsHandler::UpdateExceptionsViewFromModel,
+                 base::Unretained(this),
+                 CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
+  pref_change_registrar_.Add(
       prefs::kEnableDRM,
       base::Bind(
           &ContentSettingsHandler::UpdateProtectedContentExceptionsButton,
           base::Unretained(this)));
 
   // Here we only subscribe to the HostZoomMap for the default storage partition
   // since we don't allow the user to manage the zoom levels for apps.
   // We're only interested in zoom-levels that are persisted, since the user
   // is given the opportunity to view/delete these in the content-settings page.
   host_zoom_map_subscription_ =
@@ skipping 556 matching lines @@
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
   base::ListValue exceptions;
   GetExceptionsFromHostContentSettingsMap(otr_settings_map, type, &exceptions);
   base::StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions",
                                    type_string, exceptions);
 }
 
+scoped_ptr<base::ListValue> ContentSettingsHandler::GetPolicyAllowedUrls(
+    ContentSettingsType type) {
+  DCHECK(type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
+         type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
+
+  PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
+  const base::ListValue* policy_urls = prefs->GetList(
+      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
+          ? prefs::kAudioCaptureAllowedUrls
+          : prefs::kVideoCaptureAllowedUrls);
+
+  // Convert the URLs to |ContentSettingsPattern|s. Ignore any invalid ones.
+  std::vector<ContentSettingsPattern> patterns;
+  for (const base::Value* entry : *policy_urls) {
+    std::string url;
+    bool valid_string = entry->GetAsString(&url);
+    if (!valid_string)
+      continue;
+
+    ContentSettingsPattern pattern = ContentSettingsPattern::FromString(url);
+    if (!pattern.IsValid())
+      continue;
+
+    patterns.push_back(pattern);
+  }
+
+  // The patterns are shown in the UI in a reverse order defined by
+  // |ContentSettingsPattern::operator<|.
+  std::sort(
+      patterns.begin(), patterns.end(), std::greater<ContentSettingsPattern>());
+
+  scoped_ptr<base::ListValue> exceptions(new base::ListValue());
+  for (const ContentSettingsPattern& pattern : patterns) {
+    exceptions->Append(GetExceptionForPage(
+        pattern,
+        ContentSettingsPattern(),
+        CONTENT_SETTING_ALLOW,
+        kPolicyProviderId));
+  }
+
+  return exceptions.Pass();
+}
+
 void ContentSettingsHandler::GetExceptionsFromHostContentSettingsMap(
     const HostContentSettingsMap* map,
     ContentSettingsType type,
     base::ListValue* exceptions) {
   ContentSettingsForOneType entries;
   map->GetSettingsForOneType(type, std::string(), &entries);
   // Group settings by primary_pattern.
   AllPatternsSettings all_patterns_settings;
   for (ContentSettingsForOneType::iterator i = entries.begin();
        i != entries.end(); ++i) {
     // Don't add default settings.
     if (i->primary_pattern == ContentSettingsPattern::Wildcard() &&
         i->secondary_pattern == ContentSettingsPattern::Wildcard() &&
         i->source != kPreferencesSource) {
       continue;
     }
 
     // Off-the-record HostContentSettingsMap contains incognito content settings
     // as well as normal content settings. Here, we use the incongnito settings
     // only.
     if (map->is_off_the_record() && !i->incognito)
       continue;
 
     all_patterns_settings[std::make_pair(i->primary_pattern, i->source)]
         [i->secondary_pattern] = i->setting;
   }
 
   // Keep the exceptions sorted by provider so they will be displayed in
   // precedence order.
-  std::vector<std::vector<base::Value*> > all_provider_exceptions;
+  ScopedVector<base::ListValue> all_provider_exceptions;
   all_provider_exceptions.resize(HostContentSettingsMap::NUM_PROVIDER_TYPES);
+  for (auto& one_provider_exceptions : all_provider_exceptions)
+    one_provider_exceptions = new base::ListValue();
 
   // The all_patterns_settings is sorted from the lowest precedence pattern to
   // the highest (see operator< in ContentSettingsPattern), so traverse it in
   // reverse to show the patterns with the highest precedence (the more specific
   // ones) on the top.
   for (AllPatternsSettings::reverse_iterator i = all_patterns_settings.rbegin();
        i != all_patterns_settings.rend();
        ++i) {
     const ContentSettingsPattern& primary_pattern = i->first.first;
     const OnePatternSettings& one_settings = i->second;
 
     // The "parent" entry either has an identical primary and secondary pattern,
     // or has a wildcard secondary. The two cases are indistinguishable in the
     // UI.
     OnePatternSettings::const_iterator parent =
         one_settings.find(primary_pattern);
     if (parent == one_settings.end())
       parent = one_settings.find(ContentSettingsPattern::Wildcard());
 
     const std::string& source = i->first.second;
-    std::vector<base::Value*>* this_provider_exceptions =
-        &all_provider_exceptions.at(
+    base::ListValue* this_provider_exceptions =
+        all_provider_exceptions.get().at(

[Bernhard Bauer, 2015/07/28 15:35:31]

Could you just use the [] operator? The bounds checking that at() does might be
disabled in our builds anyway (because we don't support exceptions), and you
could in any case do it yourself.

[msramek, 2015/07/29 13:07:09]

Done. Since GetProviderTypeFromSource returns ProviderType and we allocate
NUM_PROVIDER_TYPES, the only thing to check is an invalid source argument, and
that will be handled by the NOTREACHED in GetProviderTypeFromSource.

             HostContentSettingsMap::GetProviderTypeFromSource(source));
 
     // Add the "parent" entry for the non-embedded setting.
     ContentSetting parent_setting =
         parent == one_settings.end() ? CONTENT_SETTING_DEFAULT : parent->second;
     const ContentSettingsPattern& secondary_pattern =
         parent == one_settings.end() ? primary_pattern : parent->first;
-    this_provider_exceptions->push_back(GetExceptionForPage(primary_pattern,
-                                                            secondary_pattern,
-                                                            parent_setting,
-                                                            source));
+    this_provider_exceptions->Append(GetExceptionForPage(primary_pattern,
+                                                         secondary_pattern,
+                                                         parent_setting,
+                                                         source));
 
     // Add the "children" for any embedded settings.
     for (OnePatternSettings::const_iterator j = one_settings.begin();
          j != one_settings.end(); ++j) {
       // Skip the non-embedded setting which we already added above.
       if (j == parent)
         continue;
 
       ContentSetting content_setting = j->second;
-      this_provider_exceptions->push_back(GetExceptionForPage(
+      this_provider_exceptions->Append(GetExceptionForPage(
           primary_pattern,
           j->first,
           content_setting,
           source));
     }
   }
 
-  for (size_t i = 0; i < all_provider_exceptions.size(); ++i) {
-    for (size_t j = 0; j < all_provider_exceptions[i].size(); ++j) {
-      exceptions->Append(all_provider_exceptions[i][j]);
+  // For camera and microphone, we do not have policy exceptions, but we do have
+  // the policy-set allowed URLs, which should be displayed in the same manner.
+  if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
+      type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
+    base::ListValue* policy_exceptions = all_provider_exceptions.get().at(
+         HostContentSettingsMap::GetProviderTypeFromSource(kPolicyProviderId));
+    DCHECK(policy_exceptions->empty());
+    policy_exceptions->Swap(GetPolicyAllowedUrls(type).release());

[Bernhard Bauer, 2015/07/28 15:35:31]

Doesn't this leak the ListValue object that is returned by GetPolicyAllowedUrls
(which is now empty, but still a heap-allocated object)?

[msramek, 2015/07/29 13:07:09]

Good catch!

+  }
+
+  for (auto& one_provider_exceptions : all_provider_exceptions) {

[Bernhard Bauer, 2015/07/28 15:35:31]

Can you use const auto& here?

[msramek, 2015/07/29 13:07:09]

Done.

+    for (auto& exception : *one_provider_exceptions) {
+      exceptions->Append(exception->DeepCopy());

[Bernhard Bauer, 2015/07/28 15:35:31]

Hm... it's a pity that ListValue doesn't support releasing its contents. What
you could do to avoid the DeepCopy is call Remove() with index 0 repeatedly.

[msramek, 2015/07/29 13:07:09]

But ListValue uses std::vector (not std::list) under the hood, so that would be
quadratic.

Alternatively, we can Remove objects from the back, which will be linear, but
then we'll have to push them to a vector or stack to reverse them, and push them
back to |exceptions|. But that seems to me like a lot of boilerplate code for a
small performance gain.

So a third idea - don't reverse the exceptions while processing them, then
explain the reversion when appending (implemented in the last patchset).

[Bernhard Bauer, 2015/07/29 13:19:24]

Heh. I like that ☺

     }
   }
 }
 
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
@@ skipping 370 matching lines @@
 
   // Exceptions apply only when the feature is enabled.
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options