When an extension is uninstalled, close all desktop notifications from that e...

chrome/browser/notifications/desktop_notification_service.cc

 // Copyright (c) 2010 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/metrics/histogram.h"
 #include "base/thread.h"
@@ skipping 197 matching lines @@
   // Whether the user clicked one of the buttons.
   bool action_taken_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationPermissionInfoBarDelegate);
 };
 
 DesktopNotificationService::DesktopNotificationService(Profile* profile,
     NotificationUIManager* ui_manager)
     : profile_(profile),
       ui_manager_(ui_manager) {
-  registrar_.Init(profile_->GetPrefs());
+  prefs_registrar_.Init(profile_->GetPrefs());
   InitPrefs();
   StartObserving();
 }
 
 DesktopNotificationService::~DesktopNotificationService() {
   StopObserving();
 }
 
 void DesktopNotificationService::RegisterUserPrefs(PrefService* user_prefs) {
   if (!user_prefs->FindPreference(
@@ skipping 24 matching lines @@
 
   prefs_cache_ = new NotificationsPrefsCache();
   prefs_cache_->SetCacheDefaultContentSetting(default_content_setting);
   prefs_cache_->SetCacheAllowedOrigins(allowed_origins);
   prefs_cache_->SetCacheDeniedOrigins(denied_origins);
   prefs_cache_->set_is_initialized(true);
 }
 
 void DesktopNotificationService::StartObserving() {
   if (!profile_->IsOffTheRecord()) {
-    registrar_.Add(prefs::kDesktopNotificationDefaultContentSetting, this);
-    registrar_.Add(prefs::kDesktopNotificationAllowedOrigins, this);
-    registrar_.Add(prefs::kDesktopNotificationDeniedOrigins, this);
+    prefs_registrar_.Add(prefs::kDesktopNotificationDefaultContentSetting,
+                         this);
+    prefs_registrar_.Add(prefs::kDesktopNotificationAllowedOrigins, this);
+    prefs_registrar_.Add(prefs::kDesktopNotificationDeniedOrigins, this);
+
+    notification_registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
+                                NotificationService::AllSources());
   }
+
+  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
+                              Source<Profile>(profile_));
 }
 
 void DesktopNotificationService::StopObserving() {
   if (!profile_->IsOffTheRecord()) {
-    registrar_.RemoveAll();
+    prefs_registrar_.RemoveAll();
   }
+  notification_registrar_.RemoveAll();
 }
 
 void DesktopNotificationService::GrantPermission(const GURL& origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PersistPermissionChange(origin, true);
 
   // Schedule a cache update on the IO thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           prefs_cache_.get(), &NotificationsPrefsCache::CacheAllowedOrigin,
           origin));
 }
 
 void DesktopNotificationService::DenyPermission(const GURL& origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PersistPermissionChange(origin, false);
 
   // Schedule a cache update on the IO thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           prefs_cache_.get(), &NotificationsPrefsCache::CacheDeniedOrigin,
           origin));
 }
 
 void DesktopNotificationService::Observe(NotificationType type,
                                          const NotificationSource& source,
                                          const NotificationDetails& details) {
-  DCHECK(NotificationType::PREF_CHANGED == type);
+  if (NotificationType::PREF_CHANGED == type) {
+    const std::string& name = *Details<std::string>(details).ptr();
+    OnPrefsChanged(name);
+  } else if (NotificationType::EXTENSION_UNLOADED == type) {
+    // Remove all notifications currently shown or queued by the extension
+    // which was unloaded.
+    Extension* extension = Details<Extension>(details).ptr();
+    if (extension)
+      ui_manager_->CancelAllBySourceOrigin(extension->url());
+  } else if (NotificationType::PROFILE_DESTROYED == type) {
+    StopObserving();
+  }
+}
+
+void DesktopNotificationService::OnPrefsChanged(const std::string& pref_name) {
   PrefService* prefs = profile_->GetPrefs();
-  const std::string& name = *Details<std::string>(details).ptr();
 
-  if (name == prefs::kDesktopNotificationAllowedOrigins) {
+  if (pref_name == prefs::kDesktopNotificationAllowedOrigins) {
     NotificationService::current()->Notify(
         NotificationType::DESKTOP_NOTIFICATION_SETTINGS_CHANGED,
         Source<DesktopNotificationService>(this),
         NotificationService::NoDetails());
 
     std::vector<GURL> allowed_origins(GetAllowedOrigins());
     // Schedule a cache update on the IO thread.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(
             prefs_cache_.get(),
             &NotificationsPrefsCache::SetCacheAllowedOrigins,
             allowed_origins));
-  } else if (name == prefs::kDesktopNotificationDeniedOrigins) {
+  } else if (pref_name == prefs::kDesktopNotificationDeniedOrigins) {
     NotificationService::current()->Notify(
         NotificationType::DESKTOP_NOTIFICATION_SETTINGS_CHANGED,
         Source<DesktopNotificationService>(this),
         NotificationService::NoDetails());
 
     std::vector<GURL> denied_origins(GetBlockedOrigins());
     // Schedule a cache update on the IO thread.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(
             prefs_cache_.get(),
             &NotificationsPrefsCache::SetCacheDeniedOrigins,
             denied_origins));
-  } else if (name == prefs::kDesktopNotificationDefaultContentSetting) {
+  } else if (pref_name == prefs::kDesktopNotificationDefaultContentSetting) {
     NotificationService::current()->Notify(
         NotificationType::DESKTOP_NOTIFICATION_DEFAULT_CHANGED,
         Source<DesktopNotificationService>(this),
         NotificationService::NoDetails());
 
     const ContentSetting default_content_setting = IntToContentSetting(
         prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
 
     // Schedule a cache update on the IO thread.
     BrowserThread::PostTask(
@@ skipping 211 matching lines @@
 void DesktopNotificationService::ShowNotification(
     const Notification& notification) {
   ui_manager_->Add(notification, profile_);
 }
 
 bool DesktopNotificationService::CancelDesktopNotification(
     int process_id, int route_id, int notification_id) {
   scoped_refptr<NotificationObjectProxy> proxy(
       new NotificationObjectProxy(process_id, route_id, notification_id,
                                   false));
-  // TODO(johnnyg): clean up this "empty" notification.
-  Notification notif(GURL(), GURL(), string16(), string16(), proxy);
-  return ui_manager_->Cancel(notif);
+  return ui_manager_->CancelById(proxy->id());
 }
 
 
 bool DesktopNotificationService::ShowDesktopNotification(
     const ViewHostMsg_ShowNotification_Params& params,
     int process_id, int route_id, DesktopNotificationSource source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const GURL& origin = params.origin;
   NotificationObjectProxy* proxy =
       new NotificationObjectProxy(process_id, route_id,
@@ skipping 21 matching lines @@
   if (origin.SchemeIs(chrome::kExtensionScheme)) {
     ExtensionsService* ext_service = profile_->GetExtensionsService();
     if (ext_service) {
       const Extension* extension = ext_service->GetExtensionByURL(origin);
       if (extension)
         return UTF8ToUTF16(extension->name());
     }
   }
   return UTF8ToUTF16(origin.host());
 }