Display content settings for extensions with extension name.

chrome/browser/ui/webui/site_settings_helper.cc

 // Copyright 2016 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/site_settings_helper.h"
 
 #include <functional>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/prefs/pref_service.h"
+#include "extensions/browser/extension_registry.h"
 
 namespace site_settings {
 
 const char kAppName[] = "appName";
 const char kAppId[] = "appId";
 const char kSetting[] = "setting";
 const char kOrigin[] = "origin";
+const char kDisplayName[] = "displayName";
+const char kOriginForFavicon[] = "originForFavicon";
 const char kPolicyProviderId[] = "policy";
 const char kSource[] = "source";
 const char kIncognito[] = "incognito";
 const char kEmbeddingOrigin[] = "embeddingOrigin";
 const char kPreferencesSource[] = "preference";
 const char kObject[] = "object";
 const char kObjectName[] = "objectName";
 
 const char kGroupTypeUsb[] = "usb-devices";
 
@@ skipping 86 matching lines @@
   exception->SetString(kAppName, app.name());
   exception->SetString(kAppId, app.id());
   exceptions->Append(std::move(exception));
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies).
 std::unique_ptr<base::DictionaryValue> GetExceptionForPage(
     const ContentSettingsPattern& pattern,
     const ContentSettingsPattern& secondary_pattern,
+    const std::string& display_name,
     const ContentSetting& setting,
     const std::string& provider_name,
     bool incognito) {
   base::DictionaryValue* exception = new base::DictionaryValue();
   exception->SetString(kOrigin, pattern.ToString());
+  exception->SetString(kDisplayName, display_name);
   exception->SetString(kEmbeddingOrigin,
                        secondary_pattern == ContentSettingsPattern::Wildcard() ?
                            std::string() :
                            secondary_pattern.ToString());
 
   std::string setting_string =
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
 
   exception->SetString(kSetting, setting_string);
   exception->SetString(kSource, provider_name);
   exception->SetBoolean(kIncognito, incognito);
   return base::WrapUnique(exception);
 }
 
-void GetExceptionsFromHostContentSettingsMap(const HostContentSettingsMap* map,
-                                             ContentSettingsType type,
-                                             content::WebUI* web_ui,
-                                             bool incognito,
-                                             const std::string* filter,
-                                             base::ListValue* exceptions) {
+std::string GetDisplayName(
+    const ContentSettingsPattern& pattern,
+    const extensions::ExtensionRegistry* extension_registry) {
+  if (extension_registry &&
+      pattern.GetScheme() == ContentSettingsPattern::SCHEME_CHROMEEXTENSION) {
+    GURL url(pattern.ToString());
+    // For the extension scheme, the pattern must be a valid URL.
+    DCHECK(url.is_valid());
+    const extensions::Extension* extension =
+        extension_registry->GetExtensionById(
+            url.host(), extensions::ExtensionRegistry::EVERYTHING);
+    if (extension)
+      return extension->name();
+  }
+  return pattern.ToString();
+}
+
+void GetExceptionsFromHostContentSettingsMap(
+    const HostContentSettingsMap* map,
+    ContentSettingsType type,
+    const extensions::ExtensionRegistry* extension_registry,
+    content::WebUI* web_ui,
+    bool incognito,
+    const std::string* filter,
+    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) {
@@ skipping 20 matching lines @@
 
   // |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;
+    const std::string display_name =
+        GetDisplayName(primary_pattern, extension_registry);
 
     // 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;
     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.push_back(GetExceptionForPage(
-        primary_pattern, secondary_pattern, parent_setting, source, incognito));
+    this_provider_exceptions.push_back(
+        GetExceptionForPage(primary_pattern, secondary_pattern, display_name,
+                            parent_setting, source, incognito));
 
     // 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(
-          primary_pattern, j->first, content_setting, source, incognito));
+      this_provider_exceptions.push_back(
+          GetExceptionForPage(primary_pattern, j->first, display_name,
+                              content_setting, source, incognito));
     }
   }
 
   // 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) {
     auto& policy_exceptions = all_provider_exceptions
         [HostContentSettingsMap::GetProviderTypeFromSource(kPolicyProviderId)];
     DCHECK(policy_exceptions.empty());
-    GetPolicyAllowedUrls(type, &policy_exceptions, web_ui, incognito);
+    GetPolicyAllowedUrls(type, &policy_exceptions, extension_registry, web_ui,
+                         incognito);
   }
 
   for (auto& one_provider_exceptions : all_provider_exceptions) {
     for (auto& exception : one_provider_exceptions)
       exceptions->Append(std::move(exception));
   }
 }
 
 void GetPolicyAllowedUrls(
     ContentSettingsType type,
     std::vector<std::unique_ptr<base::DictionaryValue>>* exceptions,
+    const extensions::ExtensionRegistry* extension_registry,
     content::WebUI* web_ui,
     bool incognito) {
   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);
@@ skipping 12 matching lines @@
 
     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>());
 
   for (const ContentSettingsPattern& pattern : patterns) {
-    exceptions->push_back(GetExceptionForPage(pattern, ContentSettingsPattern(),
-                                              CONTENT_SETTING_ALLOW,
-                                              kPolicyProviderId, incognito));
+    std::string display_name = GetDisplayName(pattern, extension_registry);
+    exceptions->push_back(GetExceptionForPage(
+        pattern, ContentSettingsPattern(), display_name, CONTENT_SETTING_ALLOW,
+        kPolicyProviderId, incognito));
   }
 }
 
 const ChooserTypeNameEntry* ChooserTypeFromGroupName(const std::string& name) {
   for (const auto& chooser_type : kChooserTypeGroupNames) {
     if (chooser_type.name == name)
       return &chooser_type;
   }
   return nullptr;
 }
@@ skipping 112 matching lines @@
     }
   }
 
   for (auto& one_provider_exceptions : all_provider_exceptions) {
     for (auto& exception : one_provider_exceptions)
       exceptions->Append(std::move(exception));
   }
 }
 
 }  // namespace site_settings