Make notifications permission available in the extension manifest and hook up...

chrome/browser/notifications/desktop_notification_service.cc

 // Copyright (c) 2009 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 "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
@@ skipping 173 matching lines @@
   bool action_taken_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationPermissionInfoBarDelegate);
 };
 
 DesktopNotificationService::DesktopNotificationService(Profile* profile,
     NotificationUIManager* ui_manager)
     : profile_(profile),
       ui_manager_(ui_manager) {
   InitPrefs();
+
+  // Listen for new extension installations so we can cache permissions.
+  notification_registrar_.Add(this,
+    NotificationType::EXTENSION_LOADED,
+    Source<Profile>(profile_));
 }
 
 DesktopNotificationService::~DesktopNotificationService() {
 }
 
 // Initialize the cache with the allowed and denied origins, or
 // create the preferences if they don't exist yet.
 void DesktopNotificationService::InitPrefs() {
   PrefService* prefs = profile_->GetPrefs();
   const ListValue* allowed_sites;
   const ListValue* denied_sites;
 
   if (!prefs->FindPreference(prefs::kDesktopNotificationAllowedOrigins))
     prefs->RegisterListPref(prefs::kDesktopNotificationAllowedOrigins);
   allowed_sites = prefs->GetList(prefs::kDesktopNotificationAllowedOrigins);
 
   if (!prefs->FindPreference(prefs::kDesktopNotificationDeniedOrigins))
     prefs->RegisterListPref(prefs::kDesktopNotificationDeniedOrigins);
   denied_sites = prefs->GetList(prefs::kDesktopNotificationDeniedOrigins);
 
   prefs_cache_ = new NotificationsPrefsCache(allowed_sites, denied_sites);
+
+  ExtensionsService* ext_service = profile_->GetExtensionsService();
+  if (ext_service) {
+    const ExtensionList* extensions = ext_service->extensions();
+    for (ExtensionList::const_iterator iter = extensions->begin();
+         iter != extensions->end(); ++iter) {
+      if ((*iter)->HasApiPermission(Extension::kNotificationPermission)) {
+        prefs_cache_->CacheAllowedOrigin((*iter)->url());

[Aaron Boodman, 2009/11/24 20:38:14]

Why do you need to store this state again? It is already stored in the extension
system.

[John Gregg, 2009/11/24 20:52:44]

I need this state on the IO thread to respond to a synchronous IPC for a
synchronous checkPermission() JS call that's part of the Notifications API.  

So all the notifications permission state (including the stuff I store
persistently on the profile) is cached in this PrefsCache that lives on the IO
thread. 

+      }
+    }
+  }
+}
+
+void DesktopNotificationService::Observe(NotificationType type,
+                                         const NotificationSource& source,
+                                         const NotificationDetails& details) {
+  if (type != NotificationType::EXTENSION_LOADED) {
+    NOTREACHED();
+    return;
+  }
+
+  Details<Extension> extension = static_cast<Details<Extension> >(details);
+  if (extension->HasApiPermission(Extension::kNotificationPermission)) {
+    GrantPermission(extension->url());
+  }
 }
 
 void DesktopNotificationService::GrantPermission(const GURL& origin) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   PrefService* prefs = profile_->GetPrefs();
   ListValue* allowed_sites =
       prefs->GetMutableList(prefs::kDesktopNotificationAllowedOrigins);
   ListValue* denied_sites =
       prefs->GetMutableList(prefs::kDesktopNotificationDeniedOrigins);
   // Remove from the black-list and add to the white-list.
@@ skipping 60 matching lines @@
   scoped_refptr<NotificationObjectProxy> proxy(
       new NotificationObjectProxy(process_id, route_id, notification_id,
                                   false));
   Notification notif(GURL(), GURL(), L"", proxy);
   return ui_manager_->Cancel(notif);
 }
 
 
 bool DesktopNotificationService::ShowDesktopNotification(
     const GURL& origin, const GURL& url, int process_id, int route_id,
-    NotificationSource source, int notification_id) {
+    DesktopNotificationSource source, int notification_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   NotificationObjectProxy* proxy =
       new NotificationObjectProxy(process_id, route_id,
                                   notification_id,
                                   source == WorkerNotification);
   Notification notif(origin, url, DisplayNameForOrigin(origin), proxy);
   ShowNotification(notif);
   return true;
 }
 
 bool DesktopNotificationService::ShowDesktopNotificationText(
     const GURL& origin, const GURL& icon, const string16& title,
     const string16& text, int process_id, int route_id,
-    NotificationSource source, int notification_id) {
+    DesktopNotificationSource source, int notification_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   NotificationObjectProxy* proxy =
       new NotificationObjectProxy(process_id, route_id,
                                   notification_id,
                                   source == WorkerNotification);
   // "upconvert" the string parameters to a data: URL.
   string16 data_url = CreateDataUrl(icon, title, text);
   Notification notif(
       origin, GURL(data_url), DisplayNameForOrigin(origin), proxy);
   ShowNotification(notif);
   return true;
 }
 
 std::wstring DesktopNotificationService::DisplayNameForOrigin(
     const GURL& origin) {
   // If the source is an extension, lookup the display name.
   if (origin.SchemeIs(chrome::kExtensionScheme)) {
     ExtensionsService* ext_service = profile_->GetExtensionsService();
     if (ext_service) {
       Extension* extension = ext_service->GetExtensionByURL(origin);
       if (extension)
         return ASCIIToWide(extension->name());
     }
   }
   return UTF8ToWide(origin.spec());
 }