Makes the response to CheckNotificationPermission asynchronous.

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/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 41 matching lines @@
 #include "ash/system/system_notifier.h"
 #endif
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::WebContents;
 using message_center::NotifierId;
 using WebKit::WebNotificationPresenter;
 using WebKit::WebTextDirection;
 
-
 // NotificationPermissionInfoBarDelegate --------------------------------------
 
 // The delegate for the infobar shown when an origin requests notification
 // permissions.
 class NotificationPermissionInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   // Creates a notification permission infobar delegate and adds it to
   // |infobar_service|.
   static void Create(InfoBarService* infobar_service,
                      DesktopNotificationService* notification_service,
@@ skipping 553 matching lines @@
   for (size_t i = 0; i < pref_list->GetSize(); ++i) {
     std::string element;
     if (pref_list->GetString(i, &element) && !element.empty())
       ids_field->insert(element);
     else
       LOG(WARNING) << i << "-th element is not a string for " << pref_name;
   }
 }
 
 WebKit::WebNotificationPresenter::Permission
-    DesktopNotificationService::HasPermission(const GURL& origin) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+DesktopNotificationService::HasPermission(const GURL& origin, int process_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // There are two ways that permission can be granted:
+  //   * An extension running in the process requested
+
+  ExtensionService* service = profile_->GetExtensionService();
+  std::set<std::string> process_extensions =
+      service->process_map()->GetExtensionsInProcess(process_id);
+  const ExtensionSet* profile_extensions = service->extensions();
+
+  ExtensionSet permission_extensions;
+
+  if (origin.SchemeIs(extensions::kExtensionScheme)) {
+    const std::string& id = origin.host();
+
+    if (process_extensions.find(id) != process_extensions.end()) {
+      const extensions::Extension* extension = profile_extensions->GetByID(id);
+      if (extension && ExtensionApplies(extension))
+        return WebKit::WebNotificationPresenter::PermissionAllowed;
+    }
+  } else {
+    for (std::set<std::string>::iterator iter = process_extensions.begin();
+         iter != process_extensions.end();
+         ++iter) {
+      const std::string& id = *iter;
+      const extensions::Extension* extension = profile_extensions->GetByID(id);
+      if (extension && ExtensionApplies(extension)) {
+        return WebKit::WebNotificationPresenter::PermissionAllowed;
+      }
+    }
+  }
+
+  // Here, none of the known extensions apply to the security origin and have
+  // the notifications permission, so just check the content settings for the
+  // origin.
   HostContentSettingsMap* host_content_settings_map =
       profile_->GetHostContentSettingsMap();
   ContentSetting setting = host_content_settings_map->GetContentSetting(
       origin,
       origin,
       CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
       NO_RESOURCE_IDENTIFIER);
 
   if (setting == CONTENT_SETTING_ALLOW)
     return WebKit::WebNotificationPresenter::PermissionAllowed;
   if (setting == CONTENT_SETTING_BLOCK)
     return WebKit::WebNotificationPresenter::PermissionDenied;
   if (setting == CONTENT_SETTING_ASK)
     return WebKit::WebNotificationPresenter::PermissionNotAllowed;
+
   NOTREACHED() << "Invalid notifications settings value: " << setting;
   return WebKit::WebNotificationPresenter::PermissionNotAllowed;
 }
 
 void DesktopNotificationService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_EXTENSION_UNINSTALLED, type);
 
   extensions::Extension* extension =
       content::Details<extensions::Extension>(details).ptr();
   NotifierId notifier_id(NotifierId::APPLICATION, extension->id());
   if (IsNotifierEnabled(notifier_id))
     return;
 
   SetNotifierEnabled(notifier_id, true);
 }
+
+bool DesktopNotificationService::ExtensionApplies(
+    const extensions::Extension* extension) {
+  message_center::NotifierId notifier_id(
+      message_center::NotifierId::APPLICATION, extension->id());
+  return IsNotifierEnabled(notifier_id) &&
+         extension->HasAPIPermission(extensions::APIPermission::kNotification);
+}