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 474 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);
 }
 
+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>());
+
+  base::ListValue* exceptions = new base::ListValue();
+  for (const ContentSettingsPattern& pattern : patterns) {
+    exceptions->Append(GetExceptionForPage(
+        pattern,
+        ContentSettingsPattern(),
+        CONTENT_SETTING_ALLOW,
+        kPolicyProviderId));
+  }
+
+  return exceptions;
+}
+
 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) {
@@ skipping 61 matching lines @@
 
       ContentSetting content_setting = j->second;
       this_provider_exceptions->push_back(GetExceptionForPage(
           primary_pattern,
           j->first,
           content_setting,
           source));
     }
   }
 
+  // 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) {
+    scoped_ptr<base::ListValue> exceptions_list(GetPolicyAllowedUrls(type));
+    std::vector<base::Value*>& policy_exceptions = all_provider_exceptions.at(
+        HostContentSettingsMap::GetProviderTypeFromSource(kPolicyProviderId));
+
+    for (const base::Value* exception : *exceptions_list)
+      policy_exceptions.push_back(exception->DeepCopy());
+  }
+
   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]);
     }
   }
 }
 
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
@@ skipping 373 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