Add USB devices to the content settings page.

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/stl_util.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/host_content_settings_map_factory.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/permissions/chooser_context_base.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/usb/usb_chooser_context.h"
+#include "chrome/browser/usb/usb_chooser_context_factory.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"
@@ skipping 22 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "components/user_manager/user_manager.h"
 #endif
 
 using base::UserMetricsAction;
 using content_settings::ContentSettingToString;
 using content_settings::ContentSettingFromString;
 using extensions::APIPermission;
 
+struct ChooserTypeNameEntry {
+  ContentSettingsType type;
+  ChooserContextBase* (*get_context)(Profile*);
+  const char* name;
+  const char* ui_name_key;
+};
+
 namespace {
 
 struct ContentSettingWithExceptions {
   ContentSettingWithExceptions(bool otr, UserMetricsAction action)
       : has_otr_exceptions(otr), uma(action) {}
   bool has_otr_exceptions;
   UserMetricsAction uma;
 };
 
 struct ContentSettingsTypeNameEntry {
   ContentSettingsType type;
   const char* name;
 };
 
 // Maps from a secondary pattern to a setting.
 typedef std::map<ContentSettingsPattern, ContentSetting>
     OnePatternSettings;
 // Maps from a primary pattern/source pair to a OnePatternSettings. All the
 // mappings in OnePatternSettings share the given primary pattern and source.
 typedef std::map<std::pair<ContentSettingsPattern, std::string>,
                  OnePatternSettings>
     AllPatternsSettings;
 
+// Maps from the UI string to the object it represents (for sorting purposes).
+typedef std::multimap<std::string, const base::DictionaryValue*> SortedObjects;
+// Maps from a secondary URL to the set of objects it has permission to access.
+typedef std::map<GURL, SortedObjects> OneOriginObjects;
+// Maps from a primary URL/source pair to a OneOriginObjects. All the mappings
+// in OneOriginObjects share the given primary URL and source.
+typedef std::map<std::pair<GURL, std::string>, OneOriginObjects>
+    AllOriginObjects;
+
 // The AppFilter is used in AddExceptionsGrantedByHostedApps() to choose
 // extensions which should have their extent displayed.
 typedef bool (*AppFilter)(const extensions::Extension& app,
                           content::BrowserContext* profile);
 
 const char kExceptionsLearnMoreUrl[] =
     "https://support.google.com/chrome/?p=settings_manage_exceptions";
 
 const char kSetting[] = "setting";
 const char kOrigin[] = "origin";
 const char kPolicyProviderId[] = "policy";
 const char kSource[] = "source";
 const char kAppName[] = "appName";
 const char kAppId[] = "appId";
 const char kEmbeddingOrigin[] = "embeddingOrigin";
 const char kPreferencesSource[] = "preference";
 const char kZoom[] = "zoom";
+const char kObject[] = "object";
+const char kObjectName[] = "objectName";
 
 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
   {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
   {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_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
   {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
   {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
   {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, "register-protocol-handler"},
   {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream-mic"},
   {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"},
   {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, "ppapi-broker"},
   {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, "multiple-automatic-downloads"},
   {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, "midi-sysex"},
   {CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, "push-messaging"},
   {CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS, "ssl-cert-decisions"},
 #if defined(OS_CHROMEOS)
   {CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, "protectedContent"},
 #endif
 };
 
+ChooserContextBase* GetUsbChooserContext(Profile* profile) {
+  return UsbChooserContextFactory::GetForProfile(profile);
+}
+
+const ChooserTypeNameEntry kChooserTypeGroupNames[] = {
+    {CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA, &GetUsbChooserContext,
+     "usb-devices", "name"},
+};
+
 // A pseudo content type. We use it to display data like a content setting even
 // though it is not a real content setting.
 const char kZoomContentType[] = "zoomlevels";
 
 // Maps from a content settings type to a content setting with exceptions
 // struct.
 typedef std::map<ContentSettingsType, ContentSettingWithExceptions>
     ExceptionsInfoMap;
 
 const ExceptionsInfoMap& GetExceptionsInfoMap() {
@@ skipping 93 matching lines @@
 ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (name == kContentSettingsTypeGroupNames[i].name)
       return kContentSettingsTypeGroupNames[i].type;
   }
 
   NOTREACHED() << name << " is not a recognized content settings type.";
   return CONTENT_SETTINGS_TYPE_DEFAULT;
 }
 
+const ChooserTypeNameEntry* ChooserTypeFromGroupName(const std::string& name) {
+  for (const ChooserTypeNameEntry& chooser_type : kChooserTypeGroupNames) {
+    if (chooser_type.name == name)
+      return &chooser_type;
+  }
+  return nullptr;
+}
+
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies).
 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,
@@ skipping 45 matching lines @@
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
 
   exception->SetString(kSetting, setting_string);
   exception->SetString(kOrigin, primary_pattern.ToString());
   exception->SetString(kEmbeddingOrigin, embedding_origin);
   exception->SetString(kSource, provider_name);
   return make_scoped_ptr(exception);
 }
 
+// Create a DictionaryValue* that will act as a data source for a single row
+// in a chooser permission exceptions table.
+scoped_ptr<base::DictionaryValue> GetChooserExceptionForPage(
+    const GURL& requesting_origin,
+    const GURL& embedding_origin,
+    const std::string& provider_name,
+    const std::string& name,
+    const base::DictionaryValue* object) {
+  scoped_ptr<base::DictionaryValue> exception(new base::DictionaryValue());
+
+  std::string setting_string =
+      content_settings::ContentSettingToString(CONTENT_SETTING_DEFAULT);
+  DCHECK(!setting_string.empty());
+
+  exception->SetString(kSetting, setting_string);
+  exception->SetString(kOrigin, requesting_origin.spec());
+  exception->SetString(kEmbeddingOrigin, embedding_origin.spec());
+  exception->SetString(kSource, provider_name);
+  if (object) {
+    exception->SetString(kObjectName, name);
+    exception->Set(kObject, object->CreateDeepCopy());
+  }
+  return exception.Pass();
+}
+
 // 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);
 }
 
 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from
@@ skipping 107 matching lines @@
     {"blockException", IDS_EXCEPTIONS_BLOCK_BUTTON},
     {"sessionException", IDS_EXCEPTIONS_SESSION_ONLY_BUTTON},
     {"detectException", IDS_EXCEPTIONS_DETECT_IMPORTANT_CONTENT_BUTTON},
     {"askException", IDS_EXCEPTIONS_ASK_BUTTON},
     {"otrExceptionsExplanation", IDS_EXCEPTIONS_OTR_LABEL},
     {"addNewExceptionInstructions", IDS_EXCEPTIONS_ADD_NEW_INSTRUCTIONS},
     {"manageExceptions", IDS_EXCEPTIONS_MANAGE},
     {"manageHandlers", IDS_HANDLERS_MANAGE},
     {"exceptionPatternHeader", IDS_EXCEPTIONS_PATTERN_HEADER},
     {"exceptionBehaviorHeader", IDS_EXCEPTIONS_ACTION_HEADER},
+    {"exceptionUsbDeviceHeader", IDS_EXCEPTIONS_USB_DEVICE_HEADER},
     {"exceptionZoomHeader", IDS_EXCEPTIONS_ZOOM_HEADER},
     {"embeddedOnHost", IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ON_HOST},
     // Cookies filter.
     {"cookiesTabLabel", IDS_COOKIES_TAB_LABEL},
     {"cookiesHeader", IDS_COOKIES_HEADER},
     {"cookiesAllow", IDS_COOKIES_ALLOW_RADIO},
     {"cookiesBlock", IDS_COOKIES_BLOCK_RADIO},
     {"cookiesSessionOnly", IDS_COOKIES_SESSION_ONLY_RADIO},
     {"cookiesBlock3rdParty", IDS_COOKIES_BLOCK_3RDPARTY_CHKBOX},
     {"cookiesShowCookies", IDS_COOKIES_SHOW_COOKIES_BUTTON},
@@ skipping 91 matching lines @@
     // MIDI system exclusive messages
     {"midiSysexHeader", IDS_MIDI_SYSEX_TAB_LABEL},
     {"midiSysExAllow", IDS_MIDI_SYSEX_ALLOW_RADIO},
     {"midiSysExAsk", IDS_MIDI_SYSEX_ASK_RADIO},
     {"midiSysExBlock", IDS_MIDI_SYSEX_BLOCK_RADIO},
     // Push messaging strings
     {"pushMessagingHeader", IDS_PUSH_MESSAGES_TAB_LABEL},
     {"pushMessagingAllow", IDS_PUSH_MESSSAGING_ALLOW_RADIO},
     {"pushMessagingAsk", IDS_PUSH_MESSSAGING_ASK_RADIO},
     {"pushMessagingBlock", IDS_PUSH_MESSSAGING_BLOCK_RADIO},
+    {"usbDevicesHeader", IDS_USB_DEVICES_HEADER_AND_TAB_LABEL},
+    {"usbDevicesManage", IDS_USB_DEVICES_MANAGE_BUTTON},
     {"zoomlevelsHeader", IDS_ZOOMLEVELS_HEADER_AND_TAB_LABEL},
     {"zoomLevelsManage", IDS_ZOOMLEVELS_MANAGE_BUTTON},
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
 
   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
   const base::Value* default_pref = prefs->GetDefaultPrefValue(
       content_settings::WebsiteSettingsRegistry::GetInstance()
           ->Get(CONTENT_SETTINGS_TYPE_PLUGINS)
@@ skipping 34 matching lines @@
   RegisterTitle(localized_strings, "media-stream-mic",
                 IDS_MEDIA_STREAM_MIC_TAB_LABEL);
   RegisterTitle(localized_strings, "media-stream-camera",
                 IDS_MEDIA_STREAM_CAMERA_TAB_LABEL);
   RegisterTitle(localized_strings, "ppapi-broker",
                 IDS_PPAPI_BROKER_TAB_LABEL);
   RegisterTitle(localized_strings, "multiple-automatic-downloads",
                 IDS_AUTOMATIC_DOWNLOADS_TAB_LABEL);
   RegisterTitle(localized_strings, "midi-sysex",
                 IDS_MIDI_SYSEX_TAB_LABEL);
+  RegisterTitle(localized_strings, "usb-devices",
+                IDS_USB_DEVICES_HEADER_AND_TAB_LABEL);
   RegisterTitle(localized_strings, "zoomlevels",
                 IDS_ZOOMLEVELS_HEADER_AND_TAB_LABEL);
 
   localized_strings->SetString("exceptionsLearnMoreUrl",
                                kExceptionsLearnMoreUrl);
 }
 
 void ContentSettingsHandler::InitializeHandler() {
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROFILE_CREATED,
@@ skipping 75 matching lines @@
       observer_.Add(map);
   }
 }
 
 void ContentSettingsHandler::InitializePage() {
   media_settings_.reset(new MediaSettingsInfo());
   RefreshFlashMediaSettings();
 
   UpdateHandlersEnabledRadios();
   UpdateAllExceptionsViewsFromModel();
+  UpdateAllChooserExceptionsViewsFromModel();
   UpdateProtectedContentExceptionsButton();
 }
 
 void ContentSettingsHandler::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   const ContentSettingsDetails details(
       primary_pattern, secondary_pattern, content_type, resource_identifier);
   // TODO(estade): we pretend update_all() is always true.
   if (details.update_all_types()) {
     UpdateAllExceptionsViewsFromModel();
+    UpdateAllChooserExceptionsViewsFromModel();
   } else {
     if (ContainsKey(GetExceptionsInfoMap(), details.type()))
       UpdateExceptionsViewFromModel(details.type());
+    for (const ChooserTypeNameEntry& chooser_type : kChooserTypeGroupNames) {
+      if (chooser_type.type == details.type()) {
+        UpdateChooserExceptionsViewFromModel(chooser_type);
+        break;
+      }
+    }
   }
 }
 
 void ContentSettingsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       Profile* profile = content::Source<Profile>(source).ptr();
@@ skipping 297 matching lines @@
   settings.exceptions_initialized = true;
   UpdateFlashMediaLinksVisibility(type);
 }
 
 void ContentSettingsHandler::UpdateMIDISysExExceptionsView() {
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
   UpdateExceptionsViewFromHostContentSettingsMap(
       CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
+void ContentSettingsHandler::UpdateAllChooserExceptionsViewsFromModel() {
+  for (const ChooserTypeNameEntry& chooser_type : kChooserTypeGroupNames)
+    UpdateChooserExceptionsViewFromModel(chooser_type);
+}
+
+void ContentSettingsHandler::UpdateChooserExceptionsViewFromModel(
+    const ChooserTypeNameEntry& chooser_type) {
+  ChooserContextBase* chooser_context =
+      chooser_type.get_context(Profile::FromWebUI(web_ui()));
+  std::vector<scoped_ptr<ChosenObjectPattern>> objects =
+      chooser_context->GetAllGrantedObjects();
+  AllOriginObjects all_origin_objects;
+  for (const scoped_ptr<ChosenObjectPattern>& object : objects) {
+    std::string name;
+    bool found = object->object.GetString(chooser_type.ui_name_key, &name);
+    DCHECK(found);
+    // It is safe for this structure to hold references into |objects| because
+    // they are both destroyed at the end of this function.
+    all_origin_objects[make_pair(object->requesting_origin,
+                                 object->source)][object->embedding_origin]
+        .insert(make_pair(name, &object->object));
+  }
+
+  // Keep the exceptions sorted by provider so they will be displayed in
+  // precedence order.
+  std::vector<scoped_ptr<base::DictionaryValue>>
+      all_provider_exceptions[HostContentSettingsMap::NUM_PROVIDER_TYPES];
+
+  for (const auto& all_origin_objects_entry : all_origin_objects) {
+    const GURL& requesting_origin = all_origin_objects_entry.first.first;
+    const std::string& source = all_origin_objects_entry.first.second;
+    const OneOriginObjects& one_origin_objects =
+        all_origin_objects_entry.second;
+
+    auto& this_provider_exceptions = all_provider_exceptions
+        [HostContentSettingsMap::GetProviderTypeFromSource(source)];
+
+    // Add entries for any non-embedded origins.
+    bool has_embedded_entries = false;
+    for (const auto& one_origin_objects_entry : one_origin_objects) {
+      const GURL& embedding_origin = one_origin_objects_entry.first;
+      const SortedObjects& sorted_objects = one_origin_objects_entry.second;
+
+      // Skip the embedded settings which will be added below.
+      if (requesting_origin != embedding_origin) {
+        has_embedded_entries = true;
+        continue;
+      }
+
+      for (const auto& sorted_objects_entry : sorted_objects) {
+        this_provider_exceptions.push_back(GetChooserExceptionForPage(
+            requesting_origin, embedding_origin, source,
+            sorted_objects_entry.first, sorted_objects_entry.second));
+      }
+    }
+
+    if (has_embedded_entries) {
+      // Add a "parent" entry that simply acts as a heading for all entries
+      // where
+      // |requesting_origin| has been embedded.

[Bernhard Bauer, 2015/11/17 13:36:53]

Nit: Move this to the previous line.

[Reilly Grant (use Gerrit), 2015/11/18 00:30:09]

Done.

+      this_provider_exceptions.push_back(GetChooserExceptionForPage(
+          requesting_origin, requesting_origin, source, "", nullptr));

[Bernhard Bauer, 2015/11/17 13:36:53]

Use the empty std::string() constructor to save some instructions.

[Reilly Grant (use Gerrit), 2015/11/18 00:30:09]

Done.

+
+      // Add the "children" for any embedded settings.
+      for (const auto& one_origin_objects_entry : one_origin_objects) {
+        const GURL& embedding_origin = one_origin_objects_entry.first;
+        const SortedObjects& sorted_objects = one_origin_objects_entry.second;
+
+        // Skip the non-embedded setting which we already added above.
+        if (requesting_origin == embedding_origin)
+          continue;
+
+        for (const auto& sorted_objects_entry : sorted_objects) {
+          this_provider_exceptions.push_back(GetChooserExceptionForPage(
+              requesting_origin, embedding_origin, source,
+              sorted_objects_entry.first, sorted_objects_entry.second));
+        }
+      }
+    }
+  }
+
+  base::ListValue exceptions;
+  for (auto& one_provider_exceptions : all_provider_exceptions) {
+    for (auto& exception : one_provider_exceptions)
+      exceptions.Append(exception.Pass());
+  }
+
+  base::StringValue type_string(chooser_type.name);
+  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
+                                   exceptions);
+}
+
 void ContentSettingsHandler::AdjustZoomLevelsListForSigninPageIfNecessary(
     content::HostZoomMap::ZoomLevelVector* zoom_levels) {
   if (switches::IsEnableWebviewBasedSignin())
     return;
 
   GURL signin_url(chrome::kChromeUIChromeSigninURL);
   content::HostZoomMap* signin_host_zoom_map =
       content::BrowserContext::GetStoragePartitionForSite(
           GetBrowserContext(web_ui()), signin_url)->GetHostZoomMap();
 
@@ skipping 124 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) {
+void ContentSettingsHandler::GetPolicyAllowedUrls(
+    ContentSettingsType type,
+    std::vector<scoped_ptr<base::DictionaryValue>>* exceptions) {
   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));
+    exceptions->push_back(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;
@@ skipping 11 matching lines @@
     // 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.
-  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();
+  std::vector<scoped_ptr<base::DictionaryValue>>
+      all_provider_exceptions[HostContentSettingsMap::NUM_PROVIDER_TYPES];
 
   // |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;
-    base::ListValue* this_provider_exceptions =
-        all_provider_exceptions[
-            HostContentSettingsMap::GetProviderTypeFromSource(source)];
+    auto& this_provider_exceptions = all_provider_exceptions
+        [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->Append(GetExceptionForPage(primary_pattern,
-                                                         secondary_pattern,
-                                                         parent_setting,
-                                                         source));
+    this_provider_exceptions.push_back(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->Append(GetExceptionForPage(
-          primary_pattern,
-          j->first,
-          content_setting,
-          source));
+      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) {
-    base::ListValue* policy_exceptions = all_provider_exceptions[
-         HostContentSettingsMap::GetProviderTypeFromSource(kPolicyProviderId)];
-    DCHECK(policy_exceptions->empty());
-    policy_exceptions->Swap(GetPolicyAllowedUrls(type).get());
+    auto& policy_exceptions = all_provider_exceptions
+        [HostContentSettingsMap::GetProviderTypeFromSource(kPolicyProviderId)];
+    DCHECK(policy_exceptions.empty());
+    GetPolicyAllowedUrls(type, &policy_exceptions);
   }
 
-  for (const auto& one_provider_exceptions : all_provider_exceptions) {
-    // Append |one_provider_exceptions| at the end of |exceptions|. ListValue
-    // does not support concatenation, so we must append one item at a time.
-    // Furthermore, ListValue::Remove is O(size) if we remove an item from the
-    // beginning, so we need to remove them in the reverse order.
-    ScopedVector<base::Value> reverse_helper;
-    while (!one_provider_exceptions->empty()) {
-      scoped_ptr<base::Value> exception;
-      one_provider_exceptions->Remove(
-          one_provider_exceptions->GetSize() - 1, &exception);
-      reverse_helper.push_back(exception.Pass());
-    }
-    while (!reverse_helper.empty()) {
-      ScopedVector<base::Value>::iterator back = reverse_helper.end() - 1;
-      exceptions->Append(make_scoped_ptr(*back));
-      reverse_helper.weak_erase(back);
-    }
+  for (auto& one_provider_exceptions : all_provider_exceptions) {
+    for (auto& exception : one_provider_exceptions)
+      exceptions->Append(exception.Pass());
   }
 }
 
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
@@ skipping 47 matching lines @@
   } else {
     host_zoom_map =
         content::BrowserContext::GetStoragePartitionForSite(
             GetBrowserContext(web_ui()), GURL(chrome::kChromeUIChromeSigninURL))
             ->GetHostZoomMap();
   }
   double default_level = host_zoom_map->GetDefaultZoomLevel();
   host_zoom_map->SetZoomLevelForHost(pattern, default_level);
 }
 
+void ContentSettingsHandler::RemoveChooserException(
+    const ChooserTypeNameEntry* chooser_type,
+    const base::ListValue* args) {
+  std::string mode;
+  bool rv = args->GetString(1, &mode);
+  DCHECK(rv);
+
+  std::string requesting_origin_string;
+  rv = args->GetString(2, &requesting_origin_string);
+  DCHECK(rv);
+  GURL requesting_origin(requesting_origin_string);
+  DCHECK(requesting_origin.is_valid());
+
+  std::string embedding_origin_string;
+  rv = args->GetString(3, &embedding_origin_string);
+  DCHECK(rv);
+  GURL embedding_origin(embedding_origin_string);
+  DCHECK(embedding_origin.is_valid());
+
+  const base::DictionaryValue* object = nullptr;
+  rv = args->GetDictionary(4, &object);
+  DCHECK(rv);
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+  if (mode != "normal")
+    profile = profile->GetOffTheRecordProfile();
+
+  ChooserContextBase* chooser_context = chooser_type->get_context(profile);
+  chooser_context->RevokeObjectPermission(requesting_origin, embedding_origin,
+                                          *object);
+  // TODO(reillyg): Record this in UMA or something.
+}
+
 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 44 matching lines @@
   CHECK(args->GetString(0, &type_string));
 
   // Zoom levels are no actual content type so we need to handle them
   // separately. They would not be recognized by
   // ContentSettingsTypeFromGroupName.
   if (type_string == kZoomContentType) {
     RemoveZoomLevelException(args);
     return;
   }
 
+  const ChooserTypeNameEntry* chooser_type =
+      ChooserTypeFromGroupName(type_string);
+  if (chooser_type) {
+    RemoveChooserException(chooser_type, args);
+    return;
+  }
+
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   RemoveExceptionFromHostContentSettingsMap(args, type);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(
       type, ContentSetting::CONTENT_SETTING_DEFAULT);
 }
 
 void ContentSettingsHandler::SetException(const base::ListValue* args) {
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
@@ skipping 206 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