Remove the strict dependency on WebContents 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"
@@ skipping 12 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.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/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/show_desktop_notification_params.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"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
+#include "extensions/common/permissions/permissions_data.h"
 #endif
 
 using blink::WebTextDirection;
 using content::BrowserThread;
-using content::RenderViewHost;
 using content::WebContents;
 using message_center::NotifierId;
 
 namespace {
 
 const char kChromeNowExtensionID[] = "pafkbggdmjlpgkdkcbjmhmfcdpncadgh";
 
 void CancelNotification(const std::string& id) {
   g_browser_process->notification_ui_manager()->CancelById(id);
 }
@@ skipping 75 matching lines @@
       request_id,
       requesting_frame,
       user_gesture,
       base::Bind(&DesktopNotificationService::OnNotificationPermissionRequested,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void DesktopNotificationService::ShowDesktopNotification(
     const content::ShowDesktopNotificationHostMsgParams& params,
-    content::RenderFrameHost* render_frame_host,
     scoped_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const GURL& origin = params.origin;
-  NotificationObjectProxy* proxy =
-      new NotificationObjectProxy(render_frame_host, delegate.Pass());
 
-  base::string16 display_source = DisplayNameForOriginInProcessId(
-      origin, render_frame_host->GetProcess()->GetID());
-  Notification notification(origin, params.icon_url, params.title,
+  NotificationObjectProxy* proxy = new NotificationObjectProxy(delegate.Pass());
+
+  base::string16 display_source = DisplayNameForOrigin(params.origin);
+  Notification notification(params.origin, params.icon_url, params.title,
       params.body, params.direction, display_source, params.replace_id,
       proxy);
 
-  // The webkit notification doesn't timeout.
+  // Web Notifications never 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());
 
-  DesktopNotificationProfileUtil::UsePermission(profile_, origin);
+  DCHECK(cancel_callback);
+  *cancel_callback = base::Bind(&CancelNotification, proxy->id());
+
+  DesktopNotificationProfileUtil::UsePermission(profile_, params.origin);
 }
 
-base::string16 DesktopNotificationService::DisplayNameForOriginInProcessId(
-    const GURL& origin, int process_id) {
+base::string16 DesktopNotificationService::DisplayNameForOrigin(

[Peter Beverloo, 2014/09/17 16:24:08]

This mimics the behavior of GetExtensionsWithAPIPermissionForSecurityOrigin in
the origin.SchemeIs(extensions://) case, but with the exception that it does not
check the process Id.

Why do we have to check the process Id for the relevant extensions if we already
know they have permission to run in whatever that process is? If we do need the
process Id, we can definitely pass it through the API.

[dewittj, 2014/09/17 16:58:48]

+dcheng who wrote GetExtensionsWithAPIPermissionForSecurityOrigin

[dcheng, 2014/10/03 18:40:06]

It looks like I did this since it was suggested by aa@:
https://codereview.chromium.org/8312005#msg3

It looks like we originally could end up with apps in the wrong process somehow?
I'm not sure if this can still happen.

[not at google - send to devlin, 2014/10/17 16:12:27]

Extension pages can end up being hosted in other processes if they're in
iframes. Perhaps this code was to guard against that: say http://google.com has
an iframe to extension "bbb", and that iframe tries to show a notification. With
the old code that wouldn't pass because the process ID is for the web renderer
not the extension's renderer. With the new code it would pass because you just
check the "bbb". The reason for all of this is that we don't trust extension
renderers hosted in web processes.

+    const GURL& origin) {
 #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());
+      const std::string& extension_id = origin.host();
+      const extensions::Extension* extension =
+          extension_info_map->extensions().GetByID(extension_id);
+
+      if (extension &&
+          extension->permissions_data()->HasAPIPermission(
+              extensions::APIPermission::kNotifications)) {
+        NotifierId notifier_id(NotifierId::APPLICATION, extension_id);
         if (IsNotifierEnabled(notifier_id))
-          return base::UTF8ToUTF16((*iter)->name());
+          return base::UTF8ToUTF16(extension->name());
       }
     }
   }
 #endif
 
   return base::UTF8ToUTF16(origin.host());
 }
 
 bool DesktopNotificationService::IsNotifierEnabled(
     const NotifierId& notifier_id) {
@@ skipping 132 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
 }