Enable users of NotificationUIManager to specify binary images.

ui/message_center/notification.h

 // Copyright (c) 2013 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_H_
 #define UI_MESSAGE_CENTER_NOTIFICATION_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 14 matching lines @@
   NotificationItem(const string16& title, const string16& message);
 };
 
 struct MESSAGE_CENTER_EXPORT ButtonInfo {
   string16 title;
   gfx::Image icon;
 
   ButtonInfo(const string16& title);
 };
 
+class MESSAGE_CENTER_EXPORT RichNotificationData {
+ public:
+  RichNotificationData();
+  RichNotificationData(const RichNotificationData& other);
+  ~RichNotificationData();
+
+  int priority;
+  bool never_timeout;
+  base::Time timestamp;
+  string16 expanded_message;
+  gfx::Image icon;

[Jun Mukai, 2013/05/31 17:08:10]

Almost all notifications have icons, especially webkit notification will be
created with icon URL.
Probably better to extract image resources here and name it as
NotificationImages or something like that.

[dewittj, 2013/05/31 22:13:56]

Not sure what you mean.  Do you mean take out icon from optional_fields_? 
Perhaps better to just rename optional_fields_?

+  gfx::Image image;
+  std::vector<NotificationItem> items;
+  std::vector<ButtonInfo> buttons;
+};
+
 class MESSAGE_CENTER_EXPORT Notification {
  public:
   Notification(NotificationType type,
                const std::string& id,
                const string16& title,
                const string16& message,
+               const gfx::Image& icon,
                const string16& display_source,
                const std::string& extension_id,
                const DictionaryValue* optional_fields,  // May be NULL.
                NotificationDelegate* delegate);         // May be NULL.
+
+  Notification(NotificationType type,
+               const std::string& id,
+               const string16& title,
+               const string16& message,
+               const string16& display_source,
+               const std::string& extension_id,
+               const RichNotificationData& optional_fields,
+               NotificationDelegate* delegate);
   virtual ~Notification();
 
   // Copies the internal on-memory state from |base|, i.e. shown_as_popup,
   // is_read, is_expanded, and never_timeout.
   void CopyState(Notification* base);
 
   NotificationType type() const { return type_; }
   const std::string& id() const { return id_; }
   const string16& title() const { return title_; }
   const string16& message() const { return message_; }
   const string16& display_source() const { return display_source_; }
   const std::string& extension_id() const { return extension_id_; }
 
   // Begin unpacked values from optional_fields.
-  int priority() const { return priority_; }
-  base::Time timestamp() const { return timestamp_; }
-  const string16& expanded_message() const { return expanded_message_; }
-  const std::vector<NotificationItem>& items() const { return items_; }
+  int priority() const { return optional_fields_.priority; }
+  base::Time timestamp() const { return optional_fields_.timestamp; }
+  const string16& expanded_message() const {
+    return optional_fields_.expanded_message;
+  }
+  const std::vector<NotificationItem>& items() const {
+    return optional_fields_.items;
+  }
   // End unpacked values.
 
   // Images fetched asynchronously.
-  const gfx::Image& icon() const { return icon_; }
-  void set_icon(const gfx::Image& icon) { icon_ = icon; }
+  const gfx::Image& icon() const { return optional_fields_.icon; }
+  void set_icon(const gfx::Image& icon) { optional_fields_.icon = icon; }
 
-  const gfx::Image& image() const { return image_; }
-  void set_image(const gfx::Image& image) { image_ = image; }
+  const gfx::Image& image() const { return optional_fields_.image; }
+  void set_image(const gfx::Image& image) { optional_fields_.image = image; }
 
   // Buttons, with icons fetched asynchronously.
-  const std::vector<ButtonInfo>& buttons() const { return buttons_; }
-  bool SetButtonIcon(size_t index, const gfx::Image& icon);
+  const std::vector<ButtonInfo>& buttons() const {
+    return optional_fields_.buttons;
+  }
+  void SetButtonIcon(size_t index, const gfx::Image& icon);
 
   bool shown_as_popup() const { return shown_as_popup_; }
   void set_shown_as_popup(bool shown_as_popup) {
     shown_as_popup_ = shown_as_popup;
   }
 
   // Read status in the message center.
   bool is_read() const { return is_read_; }
   void set_is_read(bool read) { is_read_ = read; }
 
   // Expanded status in the message center (not the popups).
   bool is_expanded() const { return is_expanded_; }
   void set_is_expanded(bool expanded) { is_expanded_ = expanded; }
 
   // Used to keep the order of notifications with the same timestamp.
   // The notification with lesser serial_number is considered 'older'.
   unsigned serial_number() { return serial_number_; }
 
-  bool never_timeout() const { return never_timeout_; }
+  bool never_timeout() const { return optional_fields_.never_timeout; }
   NotificationDelegate* delegate() { return delegate_.get(); }
+  const RichNotificationData& optional_fields() { return optional_fields_; }
 
  private:
   // Unpacks the provided |optional_fields| and applies the values to override
   // the notification's data members.
   void ApplyOptionalFields(const DictionaryValue* optional_fields);
 
   NotificationType type_;
   std::string id_;
   string16 title_;
   string16 message_;
   string16 display_source_;
   std::string extension_id_;
-  int priority_;
-  base::Time timestamp_;
   unsigned serial_number_;
-  string16 expanded_message_;
-  std::vector<NotificationItem> items_;
-  gfx::Image icon_;
-  gfx::Image image_;
-  std::vector<ButtonInfo> buttons_;
+  RichNotificationData optional_fields_;
   bool shown_as_popup_;  // True if this has been shown as a popup.
   bool is_read_;  // True if this has been seen in the message center.
   bool is_expanded_;  // True if this has been expanded in the message center.
-  bool never_timeout_; // True if it doesn't timeout when it appears as a toast.
 
   // A proxy object that allows access back to the JavaScript object that
   // represents the notification, for firing events.
   scoped_refptr<NotificationDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Notification);
 };
 
 }  // namespace message_center
 
 #endif  // UI_MESSAGE_CENTER_NOTIFICATION_H_