Adds a context message of the security origin for web notifications.

chrome/browser/notifications/desktop_notification_service.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/notifications/desktop_notification_service.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_object_proxy.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/common/permission_request_id.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/common/show_desktop_notification_params.h"
+#include "net/base/net_util.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/message_center/notifier_settings.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/notifications/notifications_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
@@ skipping 136 matching lines @@
 
 void DesktopNotificationService::ShowDesktopNotification(
     const content::ShowDesktopNotificationHostMsgParams& params,
     int render_process_id,
     scoped_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const GURL& origin = params.origin;
   NotificationObjectProxy* proxy = new NotificationObjectProxy(delegate.Pass());
 
+  // TODO(dewittj): The origin of file:// URLs always appears to be the empty
+  // URL.  We need a better way to display this than returning an empty string.

[felt, 2014/11/04 00:50:16]

Could you have content/renderer/notification_provider.cc send over a full URL
instead of a SecurityOrigin if the SecurityOrigin is the empty string?

[dewittj, 2015/01/09 21:59:40]

This appears to be a broader issue than just notifications.  As such we'd rather
fix this for everything; see peter's recent mail to security-dev.

In the interim, can we ignore file:// urls entirely?(especially since it's
currently impossible to gain permission on file:// urls anyway)

[felt, 2015/01/17 01:40:15]

Can you write a test to verify that it's impossible to gain the notification
permission on file:// urls, and put a comment on that test pointing here (& vice
versa)? That way if the logic is changed before this is fixed, we will get a
test failure.

   base::string16 display_source = DisplayNameForOriginInProcessId(
       origin, render_process_id);
 
   // TODO(peter): Icons for Web Notifications are currently always requested for
   // 1x scale, whereas the displays on which they can be displayed can have a
   // different pixel density. Be smarter about this when the API gets updated
   // with a way for developers to specify images of different resolutions.
   Notification notification(origin, params.title, params.body,
       gfx::Image::CreateFrom1xBitmap(params.icon),
       display_source, params.replace_id, proxy);
 
+  // Web notifications should display their origin
+  notification.set_context_message(display_source);
+
   // The webkit notification doesn't timeout.
   notification.set_never_timeout(true);
 
   g_browser_process->notification_ui_manager()->Add(notification, profile_);
   if (cancel_callback)
     *cancel_callback =
         base::Bind(&CancelNotification,
                    proxy->id(),
                    NotificationUIManager::GetProfileID(profile_));
 
   DesktopNotificationProfileUtil::UsePermission(profile_, origin);
 }
 
 base::string16 DesktopNotificationService::DisplayNameForOriginInProcessId(
-    const GURL& origin, int process_id) {
+    const GURL& origin,
+    int process_id) const {
 #if defined(ENABLE_EXTENSIONS)
   // If the source is an extension, lookup the display name.
   if (origin.SchemeIs(extensions::kExtensionScheme)) {
-    extensions::InfoMap* extension_info_map =
-        extensions::ExtensionSystem::Get(profile_)->info_map();
-    if (extension_info_map) {
-      extensions::ExtensionSet extensions;
-      extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
-          origin,
-          process_id,
-          extensions::APIPermission::kNotifications,
-          &extensions);
-      for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
-           iter != extensions.end(); ++iter) {
-        NotifierId notifier_id(NotifierId::APPLICATION, (*iter)->id());
-        if (IsNotifierEnabled(notifier_id))
-          return base::UTF8ToUTF16((*iter)->name());
-      }
+    base::string16 extension_display_name;
+    if (ExtensionDisplayName(origin, process_id, &extension_display_name)) {
+      return extension_display_name;
     }
   }
 #endif
 
-  return base::UTF8ToUTF16(origin.host());
+  std::string languages =
+      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
+
+  return OriginDisplayName(origin, languages);
+}
+
+#if defined(ENABLE_EXTENSIONS)
+bool DesktopNotificationService::ExtensionDisplayName(
+    const GURL& origin,
+    int process_id,
+    base::string16* out) const {
+  DCHECK(origin.SchemeIs(extensions::kExtensionScheme));
+  DCHECK(out);
+
+  extensions::InfoMap* extension_info_map =
+      extensions::ExtensionSystem::Get(profile_)->info_map();
+  if (extension_info_map) {
+    extensions::ExtensionSet extensions;
+    extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
+        origin,
+        process_id,
+        extensions::APIPermission::kNotifications,
+        &extensions);
+    for (auto& extension : extensions) {
+      NotifierId notifier_id(NotifierId::APPLICATION, extension->id());
+      if (IsNotifierEnabled(notifier_id)) {
+        *out = base::UTF8ToUTF16(extension->name());
+        return true;
+      }
+    }
+  }
+  return false;
+}
+#endif  // defined(ENABLE_EXTENSIONS)
+
+// static
+base::string16 DesktopNotificationService::OriginDisplayName(
+    const GURL& origin,
+    const std::string& languages) {
+  if (origin.SchemeIsHTTPOrHTTPS()) {
+    base::string16 formatted_origin =
+        net::IDNToUnicode(origin.host(), languages);
+    if (origin.has_port()) {
+      formatted_origin.push_back(':');
+      formatted_origin.append(base::UTF8ToUTF16(origin.port()));
+    }
+    return formatted_origin;
+  }
+
+  // TODO(dewittj): Once file:// URLs are passed in to the origin
+  // GURL here, begin returning the path as the display name.
+  return net::FormatUrl(origin, languages);
 }
 
 bool DesktopNotificationService::IsNotifierEnabled(
-    const NotifierId& notifier_id) {
+    const NotifierId& notifier_id) const {
   switch (notifier_id.type) {
     case NotifierId::APPLICATION:
       return disabled_extension_ids_.find(notifier_id.id) ==
           disabled_extension_ids_.end();
     case NotifierId::WEB_PAGE:
       return DesktopNotificationProfileUtil::GetContentSetting(
           profile_, notifier_id.url) == CONTENT_SETTING_ALLOW;
     case NotifierId::SYSTEM_COMPONENT:
 #if defined(OS_CHROMEOS)
       return disabled_system_component_ids_.find(notifier_id.id) ==
@@ skipping 117 matching lines @@
   // Tell the IO thread that this extension's permission for notifications
   // has changed.
   extensions::InfoMap* extension_info_map =
       extensions::ExtensionSystem::Get(profile_)->info_map();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&extensions::InfoMap::SetNotificationsDisabled,
                  extension_info_map, notifier_id.id, !enabled));
 #endif
 }