Home | History | Annotate | Download | only in notifications 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/notifications/message_center_notification_manager.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/prefs/pref_registry_simple.h"
     10 #include "base/prefs/pref_service.h"
     11 #include "chrome/browser/chrome_notification_types.h"
     12 #include "chrome/browser/notifications/desktop_notification_service.h"
     13 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
     14 #include "chrome/browser/notifications/fullscreen_notification_blocker.h"
     15 #include "chrome/browser/notifications/message_center_settings_controller.h"
     16 #include "chrome/browser/notifications/notification.h"
     17 #include "chrome/browser/notifications/screen_lock_notification_blocker.h"
     18 #include "chrome/browser/profiles/profile.h"
     19 #include "chrome/browser/ui/browser_finder.h"
     20 #include "chrome/browser/ui/chrome_pages.h"
     21 #include "chrome/browser/ui/host_desktop.h"
     22 #include "chrome/common/pref_names.h"
     23 #include "content/public/browser/notification_service.h"
     24 #include "content/public/browser/web_contents.h"
     25 #include "content/public/common/url_constants.h"
     26 #include "extensions/browser/extension_system.h"
     27 #include "extensions/browser/info_map.h"
     28 #include "extensions/common/extension_set.h"
     29 #include "ui/gfx/image/image_skia.h"
     30 #include "ui/message_center/message_center_style.h"
     31 #include "ui/message_center/message_center_tray.h"
     32 #include "ui/message_center/message_center_types.h"
     33 #include "ui/message_center/notifier_settings.h"
     34 
     35 #if defined(OS_CHROMEOS)
     36 #include "chrome/browser/notifications/login_state_notification_blocker_chromeos.h"
     37 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
     38 #endif
     39 
     40 #if defined(USE_ASH)
     41 #include "ash/shell.h"
     42 #include "ash/system/web_notification/web_notification_tray.h"
     43 #endif
     44 
     45 #if defined(OS_WIN)
     46 // The first-run balloon will be shown |kFirstRunIdleDelaySeconds| after all
     47 // popups go away and the user has notifications in the message center.
     48 const int kFirstRunIdleDelaySeconds = 1;
     49 #endif
     50 
     51 MessageCenterNotificationManager::MessageCenterNotificationManager(
     52     message_center::MessageCenter* message_center,
     53     PrefService* local_state,
     54     scoped_ptr<message_center::NotifierSettingsProvider> settings_provider)
     55     : message_center_(message_center),
     56 #if defined(OS_WIN)
     57       first_run_idle_timeout_(
     58           base::TimeDelta::FromSeconds(kFirstRunIdleDelaySeconds)),
     59       weak_factory_(this),
     60 #endif
     61       settings_provider_(settings_provider.Pass()),
     62       system_observer_(this),
     63       stats_collector_(message_center),
     64       google_now_stats_collector_(message_center) {
     65 #if defined(OS_WIN)
     66   first_run_pref_.Init(prefs::kMessageCenterShowedFirstRunBalloon, local_state);
     67 #endif
     68 
     69   message_center_->AddObserver(this);
     70   message_center_->SetNotifierSettingsProvider(settings_provider_.get());
     71 
     72 #if defined(OS_CHROMEOS)
     73   blockers_.push_back(
     74       new LoginStateNotificationBlockerChromeOS(message_center));
     75 #else
     76   blockers_.push_back(new ScreenLockNotificationBlocker(message_center));
     77 #endif
     78   blockers_.push_back(new FullscreenNotificationBlocker(message_center));
     79 
     80 #if defined(OS_WIN) || defined(OS_MACOSX) \
     81   || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
     82   // On Windows, Linux and Mac, the notification manager owns the tray icon and
     83   // views.Other platforms have global ownership and Create will return NULL.
     84   tray_.reset(message_center::CreateMessageCenterTray());
     85 #endif
     86   registrar_.Add(this,
     87                  chrome::NOTIFICATION_FULLSCREEN_CHANGED,
     88                  content::NotificationService::AllSources());
     89 }
     90 
     91 MessageCenterNotificationManager::~MessageCenterNotificationManager() {
     92   message_center_->SetNotifierSettingsProvider(NULL);
     93   message_center_->RemoveObserver(this);
     94 }
     95 
     96 void MessageCenterNotificationManager::RegisterPrefs(
     97     PrefRegistrySimple* registry) {
     98   registry->RegisterBooleanPref(prefs::kMessageCenterShowedFirstRunBalloon,
     99                                 false);
    100   registry->RegisterBooleanPref(prefs::kMessageCenterShowIcon, true);
    101   registry->RegisterBooleanPref(prefs::kMessageCenterForcedOnTaskbar, false);
    102 }
    103 
    104 ////////////////////////////////////////////////////////////////////////////////
    105 // NotificationUIManager
    106 
    107 void MessageCenterNotificationManager::Add(const Notification& notification,
    108                                            Profile* profile) {
    109   if (Update(notification, profile))
    110     return;
    111 
    112   DesktopNotificationServiceFactory::GetForProfile(profile)->
    113       ShowWelcomeNotificationIfNecessary(notification);
    114 
    115   AddProfileNotification(
    116       new ProfileNotification(profile, notification, message_center_));
    117 }
    118 
    119 bool MessageCenterNotificationManager::Update(const Notification& notification,
    120                                               Profile* profile) {
    121   const base::string16& replace_id = notification.replace_id();
    122   if (replace_id.empty())
    123     return false;
    124 
    125   const GURL origin_url = notification.origin_url();
    126   DCHECK(origin_url.is_valid());
    127 
    128   // Since replace_id is provided by arbitrary JS, we need to use origin_url
    129   // (which is an app url in case of app/extension) to scope the replace ids
    130   // in the given profile.
    131   for (NotificationMap::iterator iter = profile_notifications_.begin();
    132        iter != profile_notifications_.end(); ++iter) {
    133     ProfileNotification* old_notification = (*iter).second;
    134     if (old_notification->notification().replace_id() == replace_id &&
    135         old_notification->notification().origin_url() == origin_url &&
    136         old_notification->profile() == profile) {
    137       // Changing the type from non-progress to progress does not count towards
    138       // the immediate update allowed in the message center.
    139       std::string old_id =
    140           old_notification->notification().delegate_id();
    141       DCHECK(message_center_->FindVisibleNotificationById(old_id));
    142 
    143       // Add/remove notification in the local list but just update the same
    144       // one in MessageCenter.
    145       delete old_notification;
    146       profile_notifications_.erase(old_id);
    147       ProfileNotification* new_notification =
    148           new ProfileNotification(profile, notification, message_center_);
    149       profile_notifications_[notification.delegate_id()] = new_notification;
    150 
    151       // Now pass a copy to message center.
    152       scoped_ptr<message_center::Notification> message_center_notification(
    153           make_scoped_ptr(new message_center::Notification(notification)));
    154       message_center_->UpdateNotification(old_id,
    155                                           message_center_notification.Pass());
    156 
    157       new_notification->StartDownloads();
    158       return true;
    159     }
    160   }
    161   return false;
    162 }
    163 
    164 const Notification* MessageCenterNotificationManager::FindById(
    165     const std::string& id) const {
    166   NotificationMap::const_iterator iter = profile_notifications_.find(id);
    167   if (iter == profile_notifications_.end())
    168     return NULL;
    169   return &(iter->second->notification());
    170 }
    171 
    172 bool MessageCenterNotificationManager::CancelById(const std::string& id) {
    173   // See if this ID hasn't been shown yet.
    174   // If it has been shown, remove it.
    175   NotificationMap::iterator iter = profile_notifications_.find(id);
    176   if (iter == profile_notifications_.end())
    177     return false;
    178 
    179   RemoveProfileNotification(iter->second);
    180   message_center_->RemoveNotification(id, /* by_user */ false);
    181   return true;
    182 }
    183 
    184 std::set<std::string>
    185 MessageCenterNotificationManager::GetAllIdsByProfileAndSourceOrigin(
    186     Profile* profile,
    187     const GURL& source) {
    188 
    189   std::set<std::string> notification_ids;
    190   for (NotificationMap::iterator iter = profile_notifications_.begin();
    191        iter != profile_notifications_.end(); iter++) {
    192     if ((*iter).second->notification().origin_url() == source &&
    193         profile == (*iter).second->profile()) {
    194       notification_ids.insert(iter->first);
    195     }
    196   }
    197   return notification_ids;
    198 }
    199 
    200 bool MessageCenterNotificationManager::CancelAllBySourceOrigin(
    201     const GURL& source) {
    202   // Same pattern as CancelById, but more complicated than the above
    203   // because there may be multiple notifications from the same source.
    204   bool removed = false;
    205 
    206   for (NotificationMap::iterator loopiter = profile_notifications_.begin();
    207        loopiter != profile_notifications_.end(); ) {
    208     NotificationMap::iterator curiter = loopiter++;
    209     if ((*curiter).second->notification().origin_url() == source) {
    210       const std::string id = curiter->first;
    211       RemoveProfileNotification(curiter->second);
    212       message_center_->RemoveNotification(id, /* by_user */ false);
    213       removed = true;
    214     }
    215   }
    216   return removed;
    217 }
    218 
    219 bool MessageCenterNotificationManager::CancelAllByProfile(Profile* profile) {
    220   // Same pattern as CancelAllBySourceOrigin.
    221   bool removed = false;
    222 
    223   for (NotificationMap::iterator loopiter = profile_notifications_.begin();
    224        loopiter != profile_notifications_.end(); ) {
    225     NotificationMap::iterator curiter = loopiter++;
    226     if (profile == (*curiter).second->profile()) {
    227       const std::string id = curiter->first;
    228       RemoveProfileNotification(curiter->second);
    229       message_center_->RemoveNotification(id, /* by_user */ false);
    230       removed = true;
    231     }
    232   }
    233   return removed;
    234 }
    235 
    236 void MessageCenterNotificationManager::CancelAll() {
    237   message_center_->RemoveAllNotifications(/* by_user */ false);
    238 }
    239 
    240 ////////////////////////////////////////////////////////////////////////////////
    241 // MessageCenter::Observer
    242 void MessageCenterNotificationManager::OnNotificationRemoved(
    243     const std::string& notification_id,
    244     bool by_user) {
    245   NotificationMap::const_iterator iter =
    246       profile_notifications_.find(notification_id);
    247   if (iter != profile_notifications_.end())
    248     RemoveProfileNotification(iter->second);
    249 
    250 #if defined(OS_WIN)
    251   CheckFirstRunTimer();
    252 #endif
    253 }
    254 
    255 void MessageCenterNotificationManager::OnCenterVisibilityChanged(
    256     message_center::Visibility visibility) {
    257 #if defined(OS_WIN)
    258   if (visibility == message_center::VISIBILITY_TRANSIENT)
    259     CheckFirstRunTimer();
    260 #endif
    261 }
    262 
    263 void MessageCenterNotificationManager::OnNotificationUpdated(
    264     const std::string& notification_id) {
    265 #if defined(OS_WIN)
    266   CheckFirstRunTimer();
    267 #endif
    268 }
    269 
    270 void MessageCenterNotificationManager::EnsureMessageCenterClosed() {
    271   if (tray_.get())
    272     tray_->GetMessageCenterTray()->HideMessageCenterBubble();
    273 
    274 #if defined(USE_ASH)
    275   if (ash::Shell::HasInstance()) {
    276     ash::WebNotificationTray* tray =
    277         ash::Shell::GetInstance()->GetWebNotificationTray();
    278     if (tray)
    279       tray->GetMessageCenterTray()->HideMessageCenterBubble();
    280   }
    281 #endif
    282 }
    283 
    284 void MessageCenterNotificationManager::SetMessageCenterTrayDelegateForTest(
    285     message_center::MessageCenterTrayDelegate* delegate) {
    286   tray_.reset(delegate);
    287 }
    288 
    289 void MessageCenterNotificationManager::Observe(
    290     int type,
    291     const content::NotificationSource& source,
    292     const content::NotificationDetails& details) {
    293   if (type == chrome::NOTIFICATION_FULLSCREEN_CHANGED) {
    294     const bool is_fullscreen = *content::Details<bool>(details).ptr();
    295 
    296     if (is_fullscreen && tray_.get() && tray_->GetMessageCenterTray())
    297       tray_->GetMessageCenterTray()->HidePopupBubble();
    298   }
    299 }
    300 
    301 ////////////////////////////////////////////////////////////////////////////////
    302 // ImageDownloads
    303 
    304 MessageCenterNotificationManager::ImageDownloads::ImageDownloads(
    305     message_center::MessageCenter* message_center,
    306     ImageDownloadsObserver* observer)
    307     : message_center_(message_center),
    308       pending_downloads_(0),
    309       observer_(observer) {
    310 }
    311 
    312 MessageCenterNotificationManager::ImageDownloads::~ImageDownloads() { }
    313 
    314 void MessageCenterNotificationManager::ImageDownloads::StartDownloads(
    315     const Notification& notification) {
    316   // In case all downloads are synchronous, assume a pending download.
    317   AddPendingDownload();
    318 
    319   // Notification primary icon.
    320   StartDownloadWithImage(
    321       notification,
    322       &notification.icon(),
    323       notification.icon_url(),
    324       base::Bind(&message_center::MessageCenter::SetNotificationIcon,
    325                  base::Unretained(message_center_),
    326                  notification.delegate_id()));
    327 
    328   // Notification image.
    329   StartDownloadWithImage(
    330       notification,
    331       NULL,
    332       notification.image_url(),
    333       base::Bind(&message_center::MessageCenter::SetNotificationImage,
    334                  base::Unretained(message_center_),
    335                  notification.delegate_id()));
    336 
    337   // Notification button icons.
    338   StartDownloadWithImage(
    339       notification,
    340       NULL,
    341       notification.button_one_icon_url(),
    342       base::Bind(&message_center::MessageCenter::SetNotificationButtonIcon,
    343                  base::Unretained(message_center_),
    344                  notification.delegate_id(),
    345                  0));
    346   StartDownloadWithImage(
    347       notification,
    348       NULL,
    349       notification.button_two_icon_url(),
    350       base::Bind(&message_center::MessageCenter::SetNotificationButtonIcon,
    351                  base::Unretained(message_center_),
    352                  notification.delegate_id(),
    353                  1));
    354 
    355   // This should tell the observer we're done if everything was synchronous.
    356   PendingDownloadCompleted();
    357 }
    358 
    359 void MessageCenterNotificationManager::ImageDownloads::StartDownloadWithImage(
    360     const Notification& notification,
    361     const gfx::Image* image,
    362     const GURL& url,
    363     const SetImageCallback& callback) {
    364   // Set the image directly if we have it.
    365   if (image && !image->IsEmpty()) {
    366     callback.Run(*image);
    367     return;
    368   }
    369 
    370   // Leave the image null if there's no URL.
    371   if (url.is_empty())
    372     return;
    373 
    374   content::WebContents* contents = notification.GetWebContents();
    375   if (!contents) {
    376     LOG(WARNING) << "Notification needs an image but has no WebContents";
    377     return;
    378   }
    379 
    380   AddPendingDownload();
    381 
    382   contents->DownloadImage(
    383       url,
    384       false,  // Not a favicon
    385       0,  // No maximum size
    386       base::Bind(
    387           &MessageCenterNotificationManager::ImageDownloads::DownloadComplete,
    388           AsWeakPtr(),
    389           callback));
    390 }
    391 
    392 void MessageCenterNotificationManager::ImageDownloads::DownloadComplete(
    393     const SetImageCallback& callback,
    394     int download_id,
    395     int http_status_code,
    396     const GURL& image_url,
    397     const std::vector<SkBitmap>& bitmaps,
    398     const std::vector<gfx::Size>& original_bitmap_sizes) {
    399   PendingDownloadCompleted();
    400 
    401   if (bitmaps.empty())
    402     return;
    403   gfx::Image image = gfx::Image::CreateFrom1xBitmap(bitmaps[0]);
    404   callback.Run(image);
    405 }
    406 
    407 // Private methods.
    408 
    409 void MessageCenterNotificationManager::ImageDownloads::AddPendingDownload() {
    410   ++pending_downloads_;
    411 }
    412 
    413 void
    414 MessageCenterNotificationManager::ImageDownloads::PendingDownloadCompleted() {
    415   DCHECK(pending_downloads_ > 0);
    416   if (--pending_downloads_ == 0 && observer_)
    417     observer_->OnDownloadsCompleted();
    418 }
    419 
    420 ////////////////////////////////////////////////////////////////////////////////
    421 // ProfileNotification
    422 
    423 MessageCenterNotificationManager::ProfileNotification::ProfileNotification(
    424     Profile* profile,
    425     const Notification& notification,
    426     message_center::MessageCenter* message_center)
    427     : profile_(profile),
    428       notification_(notification),
    429       downloads_(new ImageDownloads(message_center, this)) {
    430   DCHECK(profile);
    431 #if defined(OS_CHROMEOS)
    432   notification_.set_profile_id(multi_user_util::GetUserIDFromProfile(profile));
    433 #endif
    434 }
    435 
    436 MessageCenterNotificationManager::ProfileNotification::~ProfileNotification() {
    437 }
    438 
    439 void MessageCenterNotificationManager::ProfileNotification::StartDownloads() {
    440   downloads_->StartDownloads(notification_);
    441 }
    442 
    443 void
    444 MessageCenterNotificationManager::ProfileNotification::OnDownloadsCompleted() {
    445   notification_.DoneRendering();
    446 }
    447 
    448 std::string
    449     MessageCenterNotificationManager::ProfileNotification::GetExtensionId() {
    450   extensions::InfoMap* extension_info_map =
    451       extensions::ExtensionSystem::Get(profile())->info_map();
    452   extensions::ExtensionSet extensions;
    453   extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
    454       notification().origin_url(), notification().process_id(),
    455       extensions::APIPermission::kNotification, &extensions);
    456 
    457   DesktopNotificationService* desktop_service =
    458       DesktopNotificationServiceFactory::GetForProfile(profile());
    459   for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
    460        iter != extensions.end(); ++iter) {
    461     if (desktop_service->IsNotifierEnabled(message_center::NotifierId(
    462             message_center::NotifierId::APPLICATION, (*iter)->id()))) {
    463       return (*iter)->id();
    464     }
    465   }
    466   return std::string();
    467 }
    468 
    469 ////////////////////////////////////////////////////////////////////////////////
    470 // private
    471 
    472 void MessageCenterNotificationManager::AddProfileNotification(
    473     ProfileNotification* profile_notification) {
    474   const Notification& notification = profile_notification->notification();
    475   std::string id = notification.delegate_id();
    476   // Notification ids should be unique.
    477   DCHECK(profile_notifications_.find(id) == profile_notifications_.end());
    478   profile_notifications_[id] = profile_notification;
    479 
    480   // Create the copy for message center, and ensure the extension ID is correct.
    481   scoped_ptr<message_center::Notification> message_center_notification(
    482       new message_center::Notification(notification));
    483   message_center_->AddNotification(message_center_notification.Pass());
    484 
    485   profile_notification->StartDownloads();
    486 }
    487 
    488 void MessageCenterNotificationManager::RemoveProfileNotification(
    489     ProfileNotification* profile_notification) {
    490   std::string id = profile_notification->notification().delegate_id();
    491   profile_notifications_.erase(id);
    492   delete profile_notification;
    493 }
    494 
    495 MessageCenterNotificationManager::ProfileNotification*
    496     MessageCenterNotificationManager::FindProfileNotification(
    497         const std::string& id) const {
    498   NotificationMap::const_iterator iter = profile_notifications_.find(id);
    499   if (iter == profile_notifications_.end())
    500     return NULL;
    501 
    502   return (*iter).second;
    503 }
    504