Enable users of NotificationUIManager to specify binary images.

ui/message_center/notification_list.cc

 // 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.
 
 #include "ui/message_center/notification_list.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/time.h"
@@ skipping 53 matching lines @@
     Notification* notification = *iter;
     notification->set_shown_as_popup(true);
     notification->set_is_read(true);
     if (updated_ids &&
         !(notification->shown_as_popup() && notification->is_read())) {
       updated_ids->insert(notification->id());
     }
   }
 }
 
-void NotificationList::AddNotification(NotificationType type,
-                                       const std::string& id,
-                                       const string16& title,
-                                       const string16& message,
-                                       const string16& display_source,
-                                       const std::string& extension_id,
-                                       const DictionaryValue* optional_fields,
-                                       NotificationDelegate* delegate) {
-  scoped_ptr<Notification> notification(new Notification(type,
-                                                         id,
-                                                         title,
-                                                         message,
-                                                         display_source,
-                                                         extension_id,
-                                                         optional_fields,
-                                                         delegate));
+void NotificationList::AddNotification(scoped_ptr<Notification> notification) {
   PushNotification(notification.Pass());
 }
 
 void NotificationList::UpdateNotificationMessage(
     const std::string& old_id,
-    const std::string& new_id,
-    const string16& title,
-    const string16& message,
-    const base::DictionaryValue* optional_fields,
-    NotificationDelegate* delegate) {
+    scoped_ptr<Notification> new_notification) {
   Notifications::iterator iter = GetNotification(old_id);
   if (iter == notifications_.end())
     return;
 
-  // Copy and update a notification. It has an effect of setting a new timestamp
-  // if not overridden by optional_fields
-  scoped_ptr<Notification> notification(
-      new Notification((*iter)->type(),
-                       new_id,
-                       title,
-                       message,
-                       (*iter)->display_source(),
-                       (*iter)->extension_id(),
-                       optional_fields,
-                       delegate));
-  notification->CopyState(*iter);
+  new_notification->CopyState(*iter);
 
   // Handles priority promotion. If the notification is already dismissed but
   // the updated notification has higher priority, it should re-appear as a
   // toast.
-  if ((*iter)->priority() < notification->priority()) {
-    notification->set_is_read(false);
-    notification->set_shown_as_popup(false);
+  if ((*iter)->priority() < new_notification->priority()) {
+    new_notification->set_is_read(false);
+    new_notification->set_shown_as_popup(false);
   }
 
   // Do not use EraseNotification and PushNotification, since we don't want to
   // change unread counts nor to update is_read/shown_as_popup states.
-  Notification *old = *iter;
+  Notification* old = *iter;
   notifications_.erase(iter);
   delete old;
-  notifications_.insert(notification.release());
+  notifications_.insert(new_notification.release());
 }
 
 void NotificationList::RemoveNotification(const std::string& id) {
   EraseNotification(GetNotification(id));
 }
 
 void NotificationList::RemoveAllNotifications() {
   for (Notifications::iterator loopiter = notifications_.begin();
        loopiter != notifications_.end(); ) {
     Notifications::iterator curiter = loopiter++;
@@ skipping 51 matching lines @@
   (*iter)->set_image(image);
   return true;
 }
 
 bool NotificationList::SetNotificationButtonIcon(
     const std::string& notification_id, int button_index,
     const gfx::Image& image) {
   Notifications::iterator iter = GetNotification(notification_id);
   if (iter == notifications_.end())
     return false;
-  return (*iter)->SetButtonIcon(button_index, image);
+  (*iter)->SetButtonIcon(button_index, image);
+  return true;
 }
 
 bool NotificationList::HasNotification(const std::string& id) {
   return GetNotification(id) != notifications_.end();
 }
 
 bool NotificationList::HasPopupNotifications() {
   for (Notifications::iterator iter = notifications_.begin();
        iter != notifications_.end(); ++iter) {
     if ((*iter)->priority() < DEFAULT_PRIORITY)
@@ skipping 161 matching lines @@
     notification->set_shown_as_popup(message_center_visible_ || quiet_mode_);
     if (!quiet_mode_ && notification->priority() > MIN_PRIORITY)
         ++unread_count_;
   }
   // Take ownership. The notification can only be removed from the list
   // in EraseNotification(), which will delete it.
   notifications_.insert(notification.release());
 }
 
 }  // namespace message_center