Notificaitons refactor step 2

ui/message_center/notification_list.h

 // 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 UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
 #define UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
 
 #include <list>
-#include <map>
 #include <string>
 
 #include "base/string16.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/message_center/message_center_export.h"
 #include "ui/message_center/notification.h"
-#include "ui/notifications/notification_types.h"
+#include "ui/message_center/notification_types.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace message_center {
 
 // A helper class to manage the list of notifications.
 class MESSAGE_CENTER_EXPORT NotificationList {
  public:
-  typedef std::list<Notification> Notifications;
+  // A 'list' because we use sort() to ensure display order by priority/time.

[dewittj, 2013/02/20 23:47:54]

What if we use a std::set<Notification*> which is sorted, to prevent re-sorting
all the time?  I might think we want two sets, a set of those notifications that
are waiting to be shown as popups and a set of notifications that are only in
message center (since you seem to be sorting them in different ways).

[Dmitry Titov, 2013/02/23 00:58:51]

Done.

+  typedef std::list<Notification*> Notifications;
 
   class MESSAGE_CENTER_EXPORT Delegate {
    public:
     Delegate() {}
     virtual ~Delegate() {}
 
     // Removes notifications
     virtual void SendRemoveNotification(const std::string& id) = 0;
     virtual void SendRemoveAllNotifications() = 0;
 
@@ skipping 21 matching lines @@
     // Returns the list of notifications to display.
     virtual NotificationList* GetNotificationList() = 0;
   };
 
   explicit NotificationList(Delegate* delegate);
   virtual ~NotificationList();
 
   // Affects whether or not a message has been "read".
   void SetMessageCenterVisible(bool visible);
 
-  void AddNotification(ui::notifications::NotificationType type,
+  void AddNotification(NotificationType type,
                        const std::string& id,
                        const string16& title,
                        const string16& message,
                        const string16& display_source,
                        const std::string& extension_id,
                        const base::DictionaryValue* optional_fields);
 
   void UpdateNotificationMessage(const std::string& old_id,
                                  const std::string& new_id,
                                  const string16& title,
                                  const string16& message,
                                  const base::DictionaryValue* optional_fields);
 
-  // Returns true if the notification was removed.
-  bool RemoveNotification(const std::string& id);
+  void RemoveNotification(const std::string& id);
 
   void RemoveAllNotifications();
 
   void SendRemoveNotificationsBySource(const std::string& id);
 
   void SendRemoveNotificationsByExtension(const std::string& id);
 
   // Returns true if the notification exists and was updated.
   bool SetNotificationIcon(const std::string& notification_id,
                            const gfx::ImageSkia& image);
 
   // Returns true if the notification exists and was updated.
   bool SetNotificationImage(const std::string& notification_id,
                             const gfx::ImageSkia& image);
 
   // Returns true if the notification and button exist and were updated.
   bool SetNotificationButtonIcon(const std::string& notification_id,
                                  int button_index,
                                  const gfx::ImageSkia& image);
 
   bool HasNotification(const std::string& id);
 
   // Returns false if the first notification has been shown as a popup (which
   // means that all notifications have been shown).
   bool HasPopupNotifications();
 
-  // Modifies |notifications| to contain the |kMaxVisiblePopupNotifications|
-  // least recent notifications that have not been shown as a popup.
-  void GetPopupNotifications(Notifications* notifications);
+  // Returns the recent notifications of the priority higher then LOW,
+  // that have not been shown as a popup. kMaxVisiblePopupNotifications are
+  // used to limit the number of notifications for the DEFAULT priority.
+  Notifications GetPopupNotifications();
 
   // Marks the popups for the |priority| as shown.
   void MarkPopupsAsShown(int priority);
 
   // Marks a specific popup item as shown. Set |mark_notification_as_read| to
   // true in case marking the notification as read too.
   void MarkSinglePopupAsShown(const std::string& id,
                               bool mark_notification_as_read);
 
   bool quiet_mode() const { return quiet_mode_; }
 
   // Sets the current quiet mode status to |quiet_mode|. The new status is not
   // expired.
   void SetQuietMode(bool quiet_mode);
 
   // Sets the current quiet mode to true. The quiet mode will expire in the
   // specified time-delta from now.
   void EnterQuietModeWithExpire(const base::TimeDelta& expires_in);
 
-  void GetNotifications(Notifications* notifications) const;
+  // Returns all notifications, in a (priority-timestamp) order.
+  const Notifications& GetNotifications();
   size_t NotificationCount() const;
   size_t unread_count() const { return unread_count_; }
 
   static const size_t kMaxVisiblePopupNotifications;
   static const size_t kMaxVisibleMessageCenterNotifications;
 
  private:
-  typedef std::map<int, Notifications> NotificationMap;
-
-  // Iterates through the list and stores the first notification matching |id|
-  // (should always be unique) to |iter|. Returns true if it's found.
-  bool GetNotification(const std::string& id, Notifications::iterator* iter);
+  // Iterates through the list and returns the first notification matching |id|.
+  Notifications::iterator GetNotification(const std::string& id);
 
   void EraseNotification(Notifications::iterator iter);
 
-  void PushNotification(Notification& notification);
-
-  // Returns the recent notifications of the |priority| that have not been shown
-  // as a popup. kMaxVisiblePopupNotifications are used to limit the number of
-  // notifications for the default priority.
-  void GetPopupIterators(int priority,
-                         Notifications::iterator* first,
-                         Notifications::iterator* last);
-
-  // Given a dictionary of optional notification fields (or NULL), unpacks all
-  // recognized values into the given Notification struct. We assume prior
-  // proper initialization of |notification| fields that correspond to
-  // |optional_fields|.
-  void UnpackOptionalFields(const base::DictionaryValue* optional_fields,
-                            Notification* notification);
+  void PushNotification(scoped_ptr<Notification> notification);
 
   // Sets the current quiet mode status to |quiet_mode|.
   void SetQuietModeInternal(bool quiet_mode);
 
   Delegate* delegate_;
-  NotificationMap notifications_;
+  Notifications notifications_;

[Jun Mukai, 2013/02/20 22:52:16]

can we use std::priority_queue rather than std::list?  Then, you don't need to
sort at GetNotifications anymore.

[Dmitry Titov, 2013/02/23 00:58:51]

I've replaced it with a std::set<T*, Comparer>. It can keep the order while
inserting/removing.

Also, since we need 2 different sort orders - for popups and for Center - I have
2 sorted sets.

   bool message_center_visible_;
   size_t unread_count_;
   bool quiet_mode_;
   scoped_ptr<base::OneShotTimer<NotificationList> > quiet_mode_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationList);
 };
 
 }  // namespace message_center
 
 #endif // UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_