Enable users of NotificationUIManager to specify binary images.

ui/message_center/notification_list_unittest.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/basictypes.h"
 #include "base/i18n/time_formatting.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 14 matching lines @@
     notification_list_.reset(new NotificationList());
     counter_ = 0;
   }
 
  protected:
   // Currently NotificationListTest doesn't care about some fields like title or
   // message, so put a simple template on it. Returns the id of the new
   // notification.
   std::string AddNotification(const base::DictionaryValue* optional_fields) {
     std::string new_id = base::StringPrintf(kIdFormat, counter_);
-    notification_list_->AddNotification(
+    scoped_ptr<Notification> notification(new Notification(
         message_center::NOTIFICATION_TYPE_SIMPLE,
         new_id,
         UTF8ToUTF16(base::StringPrintf(kTitleFormat, counter_)),
         UTF8ToUTF16(base::StringPrintf(kMessageFormat, counter_)),
+        gfx::Image(),
         UTF8ToUTF16(kDisplaySource),
         kExtensionId,
         optional_fields,
-        NULL);
+        NULL));
+    notification_list_->AddNotification(notification.Pass());
     counter_++;
     return new_id;
   }
 
   // Utility methods of AddNotification.
   std::string AddPriorityNotification(NotificationPriority priority) {
     base::DictionaryValue optional;
     optional.SetInteger(message_center::kPriorityKey,
                         static_cast<int>(priority));
     return AddNotification(&optional);
@@ skipping 11 matching lines @@
   Notification* GetNotification(const std::string& id) {
     NotificationList::Notifications::iterator iter =
         notification_list()->GetNotification(id);
     if (iter == notification_list()->GetNotifications().end())
       return NULL;
     return *iter;
   }
 
   NotificationList* notification_list() { return notification_list_.get(); }
 
- private:
   static const char kIdFormat[];
   static const char kTitleFormat[];
   static const char kMessageFormat[];
   static const char kDisplaySource[];
   static const char kExtensionId[];
 
+ private:
   scoped_ptr<NotificationList> notification_list_;
   size_t counter_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationListTest);
 };
 
 bool IsInNotifications(const NotificationList::Notifications& notifications,
                        const std::string& id) {
   for (NotificationList::Notifications::const_iterator iter =
            notifications.begin(); iter != notifications.end(); ++iter) {
@@ skipping 65 matching lines @@
   notification_list()->MarkSinglePopupAsDisplayed(id0);
   EXPECT_EQ(1u, notification_list()->unread_count());
   notification_list()->MarkSinglePopupAsDisplayed(id1);
   EXPECT_EQ(0u, notification_list()->unread_count());
 }
 
 TEST_F(NotificationListTest, UpdateNotification) {
   std::string id0 = AddNotification(NULL);
   std::string replaced = id0 + "_replaced";
   EXPECT_EQ(1u, notification_list()->NotificationCount());
-  notification_list()->UpdateNotificationMessage(id0,
-                                                 replaced,
-                                                 UTF8ToUTF16("newtitle"),
-                                                 UTF8ToUTF16("newbody"),
-                                                 NULL,
-                                                 NULL);
+  scoped_ptr<Notification> notification(
+      new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                       replaced,
+                       UTF8ToUTF16("newtitle"),
+                       UTF8ToUTF16("newbody"),
+                       gfx::Image(),
+                       UTF8ToUTF16(kDisplaySource),
+                       kExtensionId,
+                       NULL,
+                       NULL));
+  notification_list()->UpdateNotificationMessage(id0, notification.Pass());
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   const NotificationList::Notifications& notifications =
       notification_list()->GetNotifications();
   EXPECT_EQ(replaced, (*notifications.begin())->id());
   EXPECT_EQ(UTF8ToUTF16("newtitle"), (*notifications.begin())->title());
   EXPECT_EQ(UTF8ToUTF16("newbody"), (*notifications.begin())->message());
 }
 
 TEST_F(NotificationListTest, GetNotificationsBySourceOrExtensions) {
-  notification_list()->AddNotification(message_center::NOTIFICATION_TYPE_SIMPLE,
-                                       "id0",
-                                       UTF8ToUTF16("title0"),
-                                       UTF8ToUTF16("message0"),
-                                       UTF8ToUTF16("source0"),
-                                       "ext0",
-                                       NULL,
-                                       NULL);
-  notification_list()->AddNotification(message_center::NOTIFICATION_TYPE_SIMPLE,
-                                       "id1",
-                                       UTF8ToUTF16("title1"),
-                                       UTF8ToUTF16("message1"),
-                                       UTF8ToUTF16("source0"),
-                                       "ext0",
-                                       NULL,
-                                       NULL);
-  notification_list()->AddNotification(message_center::NOTIFICATION_TYPE_SIMPLE,
-                                       "id2",
-                                       UTF8ToUTF16("title1"),
-                                       UTF8ToUTF16("message1"),
-                                       UTF8ToUTF16("source1"),
-                                       "ext0",
-                                       NULL,
-                                       NULL);
-  notification_list()->AddNotification(message_center::NOTIFICATION_TYPE_SIMPLE,
-                                       "id3",
-                                       UTF8ToUTF16("title1"),
-                                       UTF8ToUTF16("message1"),
-                                       UTF8ToUTF16("source2"),
-                                       "ext1",
-                                       NULL,
-                                       NULL);
+  scoped_ptr<Notification> notification(
+      new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                       "id0",
+                       UTF8ToUTF16("title0"),
+                       UTF8ToUTF16("message0"),
+                       gfx::Image(),
+                       UTF8ToUTF16("source0"),
+                       "ext0",
+                       NULL,
+                       NULL));
+  notification_list()->AddNotification(notification.Pass());
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      "id1",
+                                      UTF8ToUTF16("title1"),
+                                      UTF8ToUTF16("message1"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16("source0"),
+                                      "ext0",
+                                      NULL,
+                                      NULL));
+  notification_list()->AddNotification(notification.Pass());
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      "id2",
+                                      UTF8ToUTF16("title1"),
+                                      UTF8ToUTF16("message1"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16("source1"),
+                                      "ext0",
+                                      NULL,
+                                      NULL));
+  notification_list()->AddNotification(notification.Pass());
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      "id3",
+                                      UTF8ToUTF16("title1"),
+                                      UTF8ToUTF16("message1"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16("source2"),
+                                      "ext1",
+                                      NULL,
+                                      NULL));
+  notification_list()->AddNotification(notification.Pass());
 
   NotificationList::Notifications by_source =
       notification_list()->GetNotificationsBySource("id0");
   EXPECT_TRUE(IsInNotifications(by_source, "id0"));
   EXPECT_TRUE(IsInNotifications(by_source, "id1"));
   EXPECT_FALSE(IsInNotifications(by_source, "id2"));
   EXPECT_FALSE(IsInNotifications(by_source, "id3"));
 
   NotificationList::Notifications by_extension =
       notification_list()->GetNotificationsByExtension("id0");
@@ skipping 77 matching lines @@
   EXPECT_EQ(1u, GetPopupCounts());
 }
 
 TEST_F(NotificationListTest, PriorityPromotion) {
   std::string id0 = AddPriorityNotification(LOW_PRIORITY);
   std::string replaced = id0 + "_replaced";
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   EXPECT_EQ(0u, GetPopupCounts());
   base::DictionaryValue optional;
   optional.SetInteger(message_center::kPriorityKey, 1);
-  notification_list()->UpdateNotificationMessage(id0,
-                                                 replaced,
-                                                 UTF8ToUTF16("newtitle"),
-                                                 UTF8ToUTF16("newbody"),
-                                                 &optional,
-                                                 NULL);
+  scoped_ptr<Notification> notification(
+      new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                       replaced,
+                       UTF8ToUTF16("newtitle"),
+                       UTF8ToUTF16("newbody"),
+                       gfx::Image(),
+                       UTF8ToUTF16(kDisplaySource),
+                       kExtensionId,
+                       &optional,
+                       NULL));
+  notification_list()->UpdateNotificationMessage(id0, notification.Pass());
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   EXPECT_EQ(1u, GetPopupCounts());
   const NotificationList::Notifications& notifications =
       notification_list()->GetNotifications();
   EXPECT_EQ(replaced, (*notifications.begin())->id());
   EXPECT_EQ(UTF8ToUTF16("newtitle"), (*notifications.begin())->title());
   EXPECT_EQ(UTF8ToUTF16("newbody"), (*notifications.begin())->message());
   EXPECT_EQ(1, (*notifications.begin())->priority());
 }
 
 TEST_F(NotificationListTest, PriorityPromotionWithPopups) {
   std::string id0 = AddPriorityNotification(LOW_PRIORITY);
   std::string id1 = AddPriorityNotification(DEFAULT_PRIORITY);
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id1, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // id0 promoted to LOW->DEFAULT, it'll appear as toast (popup).
   base::DictionaryValue priority_default;
   priority_default.SetInteger(message_center::kPriorityKey,
                               static_cast<int>(DEFAULT_PRIORITY));
-  notification_list()->UpdateNotificationMessage(id0,
-                                                 id0,
-                                                 UTF8ToUTF16("newtitle"),
-                                                 UTF8ToUTF16("newbody"),
-                                                 &priority_default,
-                                                 NULL);
+  scoped_ptr<Notification> notification(
+      new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                       id0,
+                       UTF8ToUTF16("newtitle"),
+                       UTF8ToUTF16("newbody"),
+                       gfx::Image(),
+                       UTF8ToUTF16(kDisplaySource),
+                       kExtensionId,
+                       &priority_default,
+                       NULL));
+  notification_list()->UpdateNotificationMessage(id0, notification.Pass());
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id0, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // update with no promotion change for id0, it won't appear as a toast.
-  notification_list()->UpdateNotificationMessage(
-      id0, id0, UTF8ToUTF16("newtitle2"), UTF8ToUTF16("newbody2"), NULL, NULL);
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      id0,
+                                      UTF8ToUTF16("newtitle2"),
+                                      UTF8ToUTF16("newbody2"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16(kDisplaySource),
+                                      kExtensionId,
+                                      NULL,
+                                      NULL));
+  notification_list()->UpdateNotificationMessage(id0, notification.Pass());
   EXPECT_EQ(0u, GetPopupCounts());
 
   // id1 promoted to DEFAULT->HIGH, it'll appear as toast (popup).
   base::DictionaryValue priority_high;
   priority_high.SetInteger(message_center::kPriorityKey,
                            static_cast<int>(HIGH_PRIORITY));
-  notification_list()->UpdateNotificationMessage(id1,
-                                                 id1,
-                                                 UTF8ToUTF16("newtitle"),
-                                                 UTF8ToUTF16("newbody"),
-                                                 &priority_high,
-                                                 NULL);
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      id1,
+                                      UTF8ToUTF16("newtitle"),
+                                      UTF8ToUTF16("newbody"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16(kDisplaySource),
+                                      kExtensionId,
+                                      &priority_high,
+                                      NULL));
+  notification_list()->UpdateNotificationMessage(id1, notification.Pass());
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id1, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // id1 promoted to HIGH->MAX, it'll appear as toast again.
   base::DictionaryValue priority_max;
   priority_max.SetInteger(message_center::kPriorityKey,
                           static_cast<int>(MAX_PRIORITY));
-  notification_list()->UpdateNotificationMessage(id1,
-                                                 id1,
-                                                 UTF8ToUTF16("newtitle2"),
-                                                 UTF8ToUTF16("newbody2"),
-                                                 &priority_max,
-                                                 NULL);
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      id1,
+                                      UTF8ToUTF16("newtitle2"),
+                                      UTF8ToUTF16("newbody2"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16(kDisplaySource),
+                                      kExtensionId,
+                                      &priority_max,
+                                      NULL));
+  notification_list()->UpdateNotificationMessage(id1, notification.Pass());
   EXPECT_EQ(1u, GetPopupCounts());
   notification_list()->MarkSinglePopupAsShown(id1, true);
   EXPECT_EQ(0u, GetPopupCounts());
 
   // id1 demoted to MAX->DEFAULT, no appearing as toast.
-  notification_list()->UpdateNotificationMessage(id1,
-                                                 id1,
-                                                 UTF8ToUTF16("newtitle3"),
-                                                 UTF8ToUTF16("newbody3"),
-                                                 &priority_default,
-                                                 NULL);
+  notification.reset(new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                                      id1,
+                                      UTF8ToUTF16("newtitle3"),
+                                      UTF8ToUTF16("newbody3"),
+                                      gfx::Image(),
+                                      UTF8ToUTF16(kDisplaySource),
+                                      kExtensionId,
+                                      &priority_default,
+                                      NULL));
+  notification_list()->UpdateNotificationMessage(id1, notification.Pass());
   EXPECT_EQ(0u, GetPopupCounts());
 }
 
 TEST_F(NotificationListTest, NotificationOrderAndPriority) {
   base::Time now = base::Time::Now();
   base::DictionaryValue optional;
   SetupTimestampKey(now, &optional);
   optional.SetInteger(message_center::kPriorityKey, 2);
   std::string max_id = AddNotification(&optional);
   now += base::TimeDelta::FromSeconds(1);
@@ skipping 108 matching lines @@
   EXPECT_FALSE(n1->shown_as_popup());
   EXPECT_TRUE(n1->is_read());
 
   notification_list()->MarkSinglePopupAsShown(id1, true);
 
   n1 = GetNotification(id1);
   EXPECT_TRUE(n1->shown_as_popup());
   EXPECT_TRUE(n1->is_read());
 
   const std::string replaced("test-replaced-id");
-  notification_list()->UpdateNotificationMessage(id1,
-                                                 replaced,
-                                                 UTF8ToUTF16("newtitle"),
-                                                 UTF8ToUTF16("newbody"),
-                                                 NULL,
-                                                 NULL);
+  scoped_ptr<Notification> notification(
+      new Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                       replaced,
+                       UTF8ToUTF16("newtitle"),
+                       UTF8ToUTF16("newbody"),
+                       gfx::Image(),
+                       UTF8ToUTF16(kDisplaySource),
+                       kExtensionId,
+                       NULL,
+                       NULL));
+  notification_list()->UpdateNotificationMessage(id1, notification.Pass());
   n1 = GetNotification(id1);
   EXPECT_TRUE(n1 == NULL);
   const Notification* nr = GetNotification(replaced);
   EXPECT_TRUE(nr->shown_as_popup());
   EXPECT_TRUE(nr->is_read());
 }
 
 TEST_F(NotificationListTest, QuietMode) {
   notification_list()->SetQuietMode(true);
   AddNotification(NULL);
   AddPriorityNotification(HIGH_PRIORITY);
   AddPriorityNotification(MAX_PRIORITY);
   EXPECT_EQ(3u, notification_list()->NotificationCount());
   EXPECT_EQ(0u, GetPopupCounts());
   // TODO(mukai): fix here when notification_list distinguish dismiss by quiet
   // mode and by user operation.
   EXPECT_EQ(0u, notification_list()->unread_count());
 
   notification_list()->SetQuietMode(false);
   AddNotification(NULL);
   EXPECT_EQ(4u, notification_list()->NotificationCount());
   EXPECT_EQ(1u, GetPopupCounts());
 
   // TODO(mukai): Add test of quiet mode with expiration.
 }
 
 }  // namespace test
 }  // namespace message_center