1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// 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.
#ifndef CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_
#define CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_
#include <map>
#include <string>
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "base/prefs/pref_member.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chrome/browser/notifications/google_now_notification_stats_collector.h"
#include "chrome/browser/notifications/message_center_stats_collector.h"
#include "chrome/browser/notifications/notification.h"
#include "chrome/browser/notifications/notification_system_observer.h"
#include "chrome/browser/notifications/notification_ui_manager.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/message_center_observer.h"
#include "ui/message_center/message_center_tray_delegate.h"
#include "ui/message_center/message_center_types.h"
class MessageCenterSettingsController;
class Notification;
class PrefRegistrySimple;
class PrefService;
class Profile;
namespace message_center {
class NotificationBlocker;
FORWARD_DECLARE_TEST(WebNotificationTrayTest, ManuallyCloseMessageCenter);
}
// This class extends NotificationUIManagerImpl and delegates actual display
// of notifications to MessageCenter, doing necessary conversions.
class MessageCenterNotificationManager
: public NotificationUIManager,
public message_center::MessageCenterObserver {
public:
MessageCenterNotificationManager(
message_center::MessageCenter* message_center,
PrefService* local_state,
scoped_ptr<message_center::NotifierSettingsProvider> settings_provider);
~MessageCenterNotificationManager() override;
// Registers preferences.
static void RegisterPrefs(PrefRegistrySimple* registry);
// NotificationUIManager
void Add(const Notification& notification, Profile* profile) override;
bool Update(const Notification& notification, Profile* profile) override;
const Notification* FindById(const std::string& delegate_id,
ProfileID profile_id) const override;
bool CancelById(const std::string& delegate_id,
ProfileID profile_id) override;
std::set<std::string> GetAllIdsByProfileAndSourceOrigin(
Profile* profile,
const GURL& source) override;
bool CancelAllBySourceOrigin(const GURL& source_origin) override;
bool CancelAllByProfile(ProfileID profile_id) override;
void CancelAll() override;
// MessageCenterObserver
void OnNotificationRemoved(const std::string& notification_id,
bool by_user) override;
void OnCenterVisibilityChanged(message_center::Visibility) override;
void OnNotificationUpdated(const std::string& notification_id) override;
void EnsureMessageCenterClosed();
#if defined(OS_WIN)
// Called when the pref changes for the first run balloon. The first run
// balloon is only displayed on Windows, since the visibility of the tray
// icon is limited.
void DisplayFirstRunBalloon();
void SetFirstRunTimeoutForTest(base::TimeDelta timeout);
bool FirstRunTimerIsActive() const;
#endif
// Takes ownership of |delegate|.
void SetMessageCenterTrayDelegateForTest(
message_center::MessageCenterTrayDelegate* delegate);
// Returns the notification id which this manager will use to add to message
// center, for this combination of delegate id and profile.
std::string GetMessageCenterNotificationIdForTest(
const std::string& delegate_id, Profile* profile);
private:
FRIEND_TEST_ALL_PREFIXES(message_center::WebNotificationTrayTest,
ManuallyCloseMessageCenter);
// This class keeps a set of original Notification objects and corresponding
// Profiles, so when MessageCenter calls back with a notification_id, this
// class has necessary mapping to other source info - for example, it calls
// NotificationDelegate supplied by client when someone clicks on a
// Notification in MessageCenter. Likewise, if a Profile or Extension is
// being removed, the map makes it possible to revoke the notifications from
// MessageCenter. To keep that set, we use the private ProfileNotification
// class that stores a superset of all information about a notification.
// TODO(dimich): Consider merging all 4 types (Notification,
// QueuedNotification, ProfileNotification and NotificationList::Notification)
// into a single class.
class ProfileNotification {
public:
ProfileNotification(Profile* profile,
const Notification& notification,
message_center::MessageCenter* message_center);
virtual ~ProfileNotification();
Profile* profile() const { return profile_; }
const Notification& notification() const { return notification_; }
// Route a new notification to an app/extension.
void AddToAlternateProvider(const std::string extension_id);
private:
// Weak, guaranteed not to be used after profile removal by parent class.
Profile* profile_;
Notification notification_;
};
scoped_ptr<message_center::MessageCenterTrayDelegate> tray_;
message_center::MessageCenter* message_center_; // Weak, global.
// Use a map by notification_id since this mapping is the most often used.
typedef std::map<std::string, ProfileNotification*> NotificationMap;
NotificationMap profile_notifications_;
// Helpers that add/remove the notification from local map.
// The local map takes ownership of profile_notification object.
void AddProfileNotification(ProfileNotification* profile_notification);
void RemoveProfileNotification(ProfileNotification* profile_notification);
// Returns the ProfileNotification for the |id|, or NULL if no such
// notification is found.
ProfileNotification* FindProfileNotification(const std::string& id) const;
// Get the extension ID of the extension that the user chose to take over
// Chorme Notification Center.
std::string GetExtensionTakingOverNotifications(Profile* profile);
#if defined(OS_WIN)
// This function is run on update to ensure that the notification balloon is
// shown only when there are no popups present.
void CheckFirstRunTimer();
// |first_run_pref_| is used to keep track of whether we've ever shown the
// first run balloon before, even across restarts.
BooleanPrefMember first_run_pref_;
// The timer after which we will show the first run balloon. This timer is
// restarted every time the message center is closed and every time the last
// popup disappears from the screen.
base::OneShotTimer<MessageCenterNotificationManager> first_run_balloon_timer_;
// The first-run balloon will be shown |first_run_idle_timeout_| after all
// popups go away and the user has notifications in the message center.
base::TimeDelta first_run_idle_timeout_;
// Provides weak pointers for the purpose of the first run timer.
base::WeakPtrFactory<MessageCenterNotificationManager> weak_factory_;
#endif
scoped_ptr<message_center::NotifierSettingsProvider> settings_provider_;
// To own the blockers.
ScopedVector<message_center::NotificationBlocker> blockers_;
NotificationSystemObserver system_observer_;
// Keeps track of all notification statistics for UMA purposes.
MessageCenterStatsCollector stats_collector_;
// Keeps track of notifications specific to Google Now for UMA purposes.
GoogleNowNotificationStatsCollector google_now_stats_collector_;
DISALLOW_COPY_AND_ASSIGN(MessageCenterNotificationManager);
};
#endif // CHROME_BROWSER_NOTIFICATIONS_MESSAGE_CENTER_NOTIFICATION_MANAGER_H_
|
