Site Settings Desktop: Implement USB devices section.

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 <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 66 matching lines @@
 #include "components/user_manager/user_manager.h"
 #endif
 
 using base::UserMetricsAction;
 using content_settings::ContentSettingToString;
 using content_settings::ContentSettingFromString;
 using extensions::APIPermission;
 
 namespace options {
 
-// This struct is declared early so that it can used by functions below.
-struct ContentSettingsHandler::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;
 };
 
-// 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 kAppName[] = "appName";
 const char kAppId[] = "appId";
 const char kZoom[] = "zoom";
-const char kObject[] = "object";
-const char kObjectName[] = "objectName";
-
-ChooserContextBase* GetUsbChooserContext(Profile* profile) {
-  return UsbChooserContextFactory::GetForProfile(profile);
-}
-
-const ContentSettingsHandler::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;
 
@@ skipping 88 matching lines @@
             UserMetricsAction("Options_DefaultBackgroundSyncSettingChanged"))));
   }
 
   return exceptions_info_map;
 }
 
 content::BrowserContext* GetBrowserContext(content::WebUI* web_ui) {
   return web_ui->GetWebContents()->GetBrowserContext();
 }
 
-const ContentSettingsHandler::ChooserTypeNameEntry* ChooserTypeFromGroupName(
-    const std::string& name) {
-  for (const auto& 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 the Geolocation exceptions table.
 std::unique_ptr<base::DictionaryValue> GetGeolocationExceptionForPage(
     const ContentSettingsPattern& origin,
     const ContentSettingsPattern& embedding_origin,
     ContentSetting setting) {
   base::DictionaryValue* exception = new base::DictionaryValue();
 
   std::string setting_string =
       content_settings::ContentSettingToString(setting);
@@ skipping 23 matching lines @@
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
 
   exception->SetString(site_settings::kSetting, setting_string);
   exception->SetString(site_settings::kOrigin, primary_pattern.ToString());
   exception->SetString(site_settings::kEmbeddingOrigin, embedding_origin);
   exception->SetString(site_settings::kSource, provider_name);
   return base::WrapUnique(exception);
 }
 
-// Create a DictionaryValue* that will act as a data source for a single row
-// in a chooser permission exceptions table.
-std::unique_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) {
-  std::unique_ptr<base::DictionaryValue> exception(new base::DictionaryValue());
-
-  std::string setting_string =
-      content_settings::ContentSettingToString(CONTENT_SETTING_DEFAULT);
-  DCHECK(!setting_string.empty());
-
-  exception->SetString(site_settings::kSetting, setting_string);
-  exception->SetString(site_settings::kOrigin, requesting_origin.spec());
-  exception->SetString(
-      site_settings::kEmbeddingOrigin, embedding_origin.spec());
-  exception->SetString(site_settings::kSource, provider_name);
-  if (object) {
-    exception->SetString(kObjectName, name);
-    exception->Set(kObject, object->CreateDeepCopy());
-  }
-  return 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);
 }
 
 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from
@@ skipping 712 matching lines @@
   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)
+  for (const site_settings::ChooserTypeNameEntry& chooser_type :
+      site_settings::kChooserTypeGroupNames)
     UpdateChooserExceptionsViewFromModel(chooser_type);
 }
 
 void ContentSettingsHandler::UpdateAllOTRChooserExceptionsViewsFromModel() {
-  for (const ChooserTypeNameEntry& chooser_type : kChooserTypeGroupNames)
+  for (const site_settings::ChooserTypeNameEntry& chooser_type :
+      site_settings::kChooserTypeGroupNames)
     UpdateOTRChooserExceptionsViewFromModel(chooser_type);
 }
 
 void ContentSettingsHandler::UpdateChooserExceptionsViewFromModel(
-    const ChooserTypeNameEntry& chooser_type) {
+    const site_settings::ChooserTypeNameEntry& chooser_type) {
   base::ListValue exceptions;
-  GetChooserExceptionsFromProfile(false, chooser_type, &exceptions);
+  site_settings::GetChooserExceptionsFromProfile(
+      Profile::FromWebUI(web_ui()), false, chooser_type, &exceptions);
   base::StringValue type_string(chooser_type.name);
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
                                          type_string, exceptions);
 
   UpdateOTRChooserExceptionsViewFromModel(chooser_type);
 }
 
 void ContentSettingsHandler::UpdateOTRChooserExceptionsViewFromModel(
-    const ChooserTypeNameEntry& chooser_type) {
+    const site_settings::ChooserTypeNameEntry& chooser_type) {
   if (!Profile::FromWebUI(web_ui())->HasOffTheRecordProfile())
     return;
 
   base::ListValue exceptions;
-  GetChooserExceptionsFromProfile(true, chooser_type, &exceptions);
+  site_settings::GetChooserExceptionsFromProfile(
+      Profile::FromWebUI(web_ui()), true, chooser_type, &exceptions);
   base::StringValue type_string(chooser_type.name);
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setOTRExceptions",
                                          type_string, exceptions);
 }
 
 void ContentSettingsHandler::UpdateZoomLevelsExceptionsView() {
   base::ListValue zoom_levels_exceptions;
 
   content::HostZoomMap* host_zoom_map =
       content::HostZoomMap::GetDefaultForBrowserContext(
@@ skipping 99 matching lines @@
     return;
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       otr_settings_map, type, web_ui(), &exceptions);
   base::StringValue type_string(
       site_settings::ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setOTRExceptions",
                                          type_string, exceptions);
 }
 
-void ContentSettingsHandler::GetChooserExceptionsFromProfile(
-    bool incognito,
-    const ChooserTypeNameEntry& chooser_type,
-    base::ListValue* exceptions) {
-  Profile* profile = Profile::FromWebUI(web_ui());
-  if (incognito) {
-    if (profile->HasOffTheRecordProfile())
-      profile = profile->GetOffTheRecordProfile();
-    else
-      return;
-  }
-
-  ChooserContextBase* chooser_context = chooser_type.get_context(profile);
-  std::vector<std::unique_ptr<ChooserContextBase::Object>> objects =
-      chooser_context->GetAllGrantedObjects();
-  AllOriginObjects all_origin_objects;
-  for (const auto& 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<std::unique_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.
-      this_provider_exceptions.push_back(
-          GetChooserExceptionForPage(requesting_origin, requesting_origin,
-                                     source, std::string(), nullptr));
-
-      // 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));
-        }
-      }
-    }
-  }
-
-  for (auto& one_provider_exceptions : all_provider_exceptions) {
-    for (auto& exception : one_provider_exceptions)
-      exceptions->Append(std::move(exception));
-  }
-}
-
 void ContentSettingsHandler::RemoveExceptionFromHostContentSettingsMap(
     const base::ListValue* args,
     ContentSettingsType type) {
   std::string mode;
   bool rv = args->GetString(1, &mode);
   DCHECK(rv);
 
   std::string pattern;
   rv = args->GetString(2, &pattern);
   DCHECK(rv);
@@ skipping 43 matching lines @@
 
   content::HostZoomMap* host_zoom_map;
   host_zoom_map =
     content::HostZoomMap::GetDefaultForBrowserContext(
         GetBrowserContext(web_ui()));
   double default_level = host_zoom_map->GetDefaultZoomLevel();
   host_zoom_map->SetZoomLevelForHost(pattern, default_level);
 }
 
 void ContentSettingsHandler::RemoveChooserException(
-    const ChooserTypeNameEntry* chooser_type,
+    const site_settings::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());
@@ skipping 74 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);
+  const site_settings::ChooserTypeNameEntry* chooser_type =
+      site_settings::ChooserTypeFromGroupName(type_string);
   if (chooser_type) {
     RemoveChooserException(chooser_type, args);
     return;
   }
 
   ContentSettingsType type =
       site_settings::ContentSettingsTypeFromGroupName(type_string);
   RemoveExceptionFromHostContentSettingsMap(args, type);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(
@@ skipping 195 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()->CallJavascriptFunctionUnsafe(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options