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 #ifndef CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_ 6 #define CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_ 7 8 #include <map> 9 #include <string> 10 11 #include "base/memory/scoped_ptr.h" 12 #include "base/memory/scoped_vector.h" 13 #include "base/memory/weak_ptr.h" 14 #include "base/prefs/pref_member.h" 15 #include "base/time/time.h" 16 #include "base/timer/timer.h" 17 #include "chrome/browser/notifications/google_now_notification_stats_collector.h" 18 #include "chrome/browser/notifications/message_center_stats_collector.h" 19 #include "chrome/browser/notifications/notification.h" 20 #include "chrome/browser/notifications/notification_system_observer.h" 21 #include "chrome/browser/notifications/notification_ui_manager.h" 22 #include "ui/message_center/message_center.h" 23 #include "ui/message_center/message_center_observer.h" 24 #include "ui/message_center/message_center_tray_delegate.h" 25 #include "ui/message_center/message_center_types.h" 26 27 class MessageCenterSettingsController; 28 class Notification; 29 class PrefRegistrySimple; 30 class PrefService; 31 class Profile; 32 33 namespace message_center { 34 class NotificationBlocker; 35 FORWARD_DECLARE_TEST(WebNotificationTrayTest, ManuallyCloseMessageCenter); 36 } 37 38 // This class extends NotificationUIManagerImpl and delegates actual display 39 // of notifications to MessageCenter, doing necessary conversions. 40 class MessageCenterNotificationManager 41 : public NotificationUIManager, 42 public message_center::MessageCenterObserver { 43 public: 44 MessageCenterNotificationManager( 45 message_center::MessageCenter* message_center, 46 PrefService* local_state, 47 scoped_ptr<message_center::NotifierSettingsProvider> settings_provider); 48 virtual ~MessageCenterNotificationManager(); 49 50 // Registers preferences. 51 static void RegisterPrefs(PrefRegistrySimple* registry); 52 53 // NotificationUIManager 54 virtual void Add(const Notification& notification, 55 Profile* profile) OVERRIDE; 56 virtual bool Update(const Notification& notification, 57 Profile* profile) OVERRIDE; 58 virtual const Notification* FindById( 59 const std::string& notification_id) const OVERRIDE; 60 virtual bool CancelById(const std::string& notification_id) OVERRIDE; 61 virtual std::set<std::string> GetAllIdsByProfileAndSourceOrigin( 62 Profile* profile, 63 const GURL& source) OVERRIDE; 64 virtual bool CancelAllBySourceOrigin(const GURL& source_origin) OVERRIDE; 65 virtual bool CancelAllByProfile(Profile* profile) OVERRIDE; 66 virtual void CancelAll() OVERRIDE; 67 68 // MessageCenterObserver 69 virtual void OnNotificationRemoved(const std::string& notification_id, 70 bool by_user) OVERRIDE; 71 virtual void OnCenterVisibilityChanged(message_center::Visibility) OVERRIDE; 72 virtual void OnNotificationUpdated(const std::string& notification_id) 73 OVERRIDE; 74 75 void EnsureMessageCenterClosed(); 76 77 #if defined(OS_WIN) 78 // Called when the pref changes for the first run balloon. The first run 79 // balloon is only displayed on Windows, since the visibility of the tray 80 // icon is limited. 81 void DisplayFirstRunBalloon(); 82 83 void SetFirstRunTimeoutForTest(base::TimeDelta timeout); 84 bool FirstRunTimerIsActive() const; 85 #endif 86 87 // Takes ownership of |delegate|. 88 void SetMessageCenterTrayDelegateForTest( 89 message_center::MessageCenterTrayDelegate* delegate); 90 91 private: 92 FRIEND_TEST_ALL_PREFIXES(message_center::WebNotificationTrayTest, 93 ManuallyCloseMessageCenter); 94 class ImageDownloadsObserver { 95 public: 96 virtual void OnDownloadsCompleted() = 0; 97 }; 98 99 typedef base::Callback<void(const gfx::Image&)> SetImageCallback; 100 class ImageDownloads 101 : public base::SupportsWeakPtr<ImageDownloads> { 102 public: 103 ImageDownloads( 104 message_center::MessageCenter* message_center, 105 ImageDownloadsObserver* observer); 106 virtual ~ImageDownloads(); 107 108 void StartDownloads(const Notification& notification); 109 void StartDownloadWithImage(const Notification& notification, 110 const gfx::Image* image, 111 const GURL& url, 112 const SetImageCallback& callback); 113 void StartDownloadByKey(const Notification& notification, 114 const char* key, 115 int size, 116 const SetImageCallback& callback); 117 118 // FaviconHelper callback. 119 void DownloadComplete(const SetImageCallback& callback, 120 int download_id, 121 int http_status_code, 122 const GURL& image_url, 123 const std::vector<SkBitmap>& bitmaps, 124 const std::vector<gfx::Size>& original_bitmap_sizes); 125 private: 126 // Used to keep track of the number of pending downloads. Once this 127 // reaches zero, we can tell the delegate that we don't need the 128 // RenderViewHost anymore. 129 void AddPendingDownload(); 130 void PendingDownloadCompleted(); 131 132 // Weak reference to global message center. 133 message_center::MessageCenter* message_center_; 134 135 // Count of downloads that remain. 136 size_t pending_downloads_; 137 138 // Weak. 139 ImageDownloadsObserver* observer_; 140 141 DISALLOW_COPY_AND_ASSIGN(ImageDownloads); 142 }; 143 144 // This class keeps a set of original Notification objects and corresponding 145 // Profiles, so when MessageCenter calls back with a notification_id, this 146 // class has necessary mapping to other source info - for example, it calls 147 // NotificationDelegate supplied by client when someone clicks on a 148 // Notification in MessageCenter. Likewise, if a Profile or Extension is 149 // being removed, the map makes it possible to revoke the notifications from 150 // MessageCenter. To keep that set, we use the private ProfileNotification 151 // class that stores a superset of all information about a notification. 152 153 // TODO(dimich): Consider merging all 4 types (Notification, 154 // QueuedNotification, ProfileNotification and NotificationList::Notification) 155 // into a single class. 156 class ProfileNotification : public ImageDownloadsObserver { 157 public: 158 ProfileNotification(Profile* profile, 159 const Notification& notification, 160 message_center::MessageCenter* message_center); 161 virtual ~ProfileNotification(); 162 163 void StartDownloads(); 164 165 // Overridden from ImageDownloadsObserver. 166 virtual void OnDownloadsCompleted() OVERRIDE; 167 profile()168 Profile* profile() const { return profile_; } notification()169 const Notification& notification() const { return notification_; } 170 171 // Route a new notification to an app/extension. 172 void AddToAlternateProvider(const std::string extension_id); 173 174 private: 175 // Weak, guaranteed not to be used after profile removal by parent class. 176 Profile* profile_; 177 Notification notification_; 178 // Track the downloads for this notification so the notification can be 179 // updated properly. 180 scoped_ptr<ImageDownloads> downloads_; 181 }; 182 183 scoped_ptr<message_center::MessageCenterTrayDelegate> tray_; 184 message_center::MessageCenter* message_center_; // Weak, global. 185 186 // Use a map by notification_id since this mapping is the most often used. 187 typedef std::map<std::string, ProfileNotification*> NotificationMap; 188 NotificationMap profile_notifications_; 189 190 // Helpers that add/remove the notification from local map. 191 // The local map takes ownership of profile_notification object. 192 void AddProfileNotification(ProfileNotification* profile_notification); 193 void RemoveProfileNotification(ProfileNotification* profile_notification); 194 195 // Returns the ProfileNotification for the |id|, or NULL if no such 196 // notification is found. 197 ProfileNotification* FindProfileNotification(const std::string& id) const; 198 199 // Get the extension ID of the extension that the user chose to take over 200 // Chorme Notification Center. 201 std::string GetExtensionTakingOverNotifications(Profile* profile); 202 203 #if defined(OS_WIN) 204 // This function is run on update to ensure that the notification balloon is 205 // shown only when there are no popups present. 206 void CheckFirstRunTimer(); 207 208 // |first_run_pref_| is used to keep track of whether we've ever shown the 209 // first run balloon before, even across restarts. 210 BooleanPrefMember first_run_pref_; 211 212 // The timer after which we will show the first run balloon. This timer is 213 // restarted every time the message center is closed and every time the last 214 // popup disappears from the screen. 215 base::OneShotTimer<MessageCenterNotificationManager> first_run_balloon_timer_; 216 217 // The first-run balloon will be shown |first_run_idle_timeout_| after all 218 // popups go away and the user has notifications in the message center. 219 base::TimeDelta first_run_idle_timeout_; 220 221 // Provides weak pointers for the purpose of the first run timer. 222 base::WeakPtrFactory<MessageCenterNotificationManager> weak_factory_; 223 #endif 224 225 scoped_ptr<message_center::NotifierSettingsProvider> settings_provider_; 226 227 // To own the blockers. 228 ScopedVector<message_center::NotificationBlocker> blockers_; 229 230 NotificationSystemObserver system_observer_; 231 232 // Keeps track of all notification statistics for UMA purposes. 233 MessageCenterStatsCollector stats_collector_; 234 235 // Keeps track of notifications specific to Google Now for UMA purposes. 236 GoogleNowNotificationStatsCollector google_now_stats_collector_; 237 238 DISALLOW_COPY_AND_ASSIGN(MessageCenterNotificationManager); 239 }; 240 241 #endif // CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_ 242