Notificaitons refactor step 2

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"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/notifications/notification_types.h"
+#include "ui/message_center/notification_types.h"
 
 namespace message_center {
 namespace {
 
 class MockNotificationListDelegate : public NotificationList::Delegate {
  public:
   MockNotificationListDelegate() : send_remove_count_(0) {}
   virtual ~MockNotificationListDelegate() {}
 
   size_t GetSendRemoveCountAndReset() {
@@ skipping 53 matching lines @@
     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(
-        ui::notifications::NOTIFICATION_TYPE_SIMPLE, new_id,
+        message_center::NOTIFICATION_TYPE_SIMPLE, new_id,
         UTF8ToUTF16(StringPrintf(kTitleFormat, counter_)),
         UTF8ToUTF16(StringPrintf(kMessageFormat, counter_)),
         UTF8ToUTF16(kDisplaySource), kExtensionId,
         optional_fields);
     counter_++;
     return new_id;
   }
 
   // Utility methods of AddNotification.
   std::string AddPriorityNotification(int priority) {
     base::DictionaryValue optional;
-    optional.SetInteger(ui::notifications::kPriorityKey, priority);
+    optional.SetInteger(message_center::kPriorityKey, priority);
     return AddNotification(&optional);
   }
   void SetupTimestampKey(const base::Time& time,
                          base::DictionaryValue* optional) {
     string16 time_formatted = base::TimeFormatShortDateAndTime(time);
-    optional->SetString(ui::notifications::kTimestampKey, time_formatted);
+    optional->SetString(message_center::kTimestampKey, time_formatted);
   }
 
   size_t GetPopupCounts() {
-    NotificationList::Notifications popups;
-    notification_list()->GetPopupNotifications(&popups);
-    return popups.size();
+    return notification_list()->GetPopupNotifications().size();
   }
 
   MockNotificationListDelegate* delegate() { return delegate_.get(); }
   NotificationList* notification_list() { return notification_list_.get(); }
 
  private:
   static const char kIdFormat[];
   static const char kTitleFormat[];
   static const char kMessageFormat[];
   static const char kDisplaySource[];
@@ skipping 28 matching lines @@
   EXPECT_TRUE(notification_list()->HasNotification(id0));
   EXPECT_TRUE(notification_list()->HasNotification(id1));
   EXPECT_FALSE(notification_list()->HasNotification(id1 + "foo"));
 
   EXPECT_EQ(2u, GetPopupCounts());
 
   notification_list()->MarkPopupsAsShown(0);
   EXPECT_EQ(2u, notification_list()->NotificationCount());
   EXPECT_EQ(0u, GetPopupCounts());
 
-  EXPECT_TRUE(notification_list()->RemoveNotification(id0));
+  notification_list()->RemoveNotification(id0);
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   EXPECT_EQ(1u, notification_list()->unread_count());
 
   AddNotification(NULL);
   EXPECT_EQ(2u, notification_list()->NotificationCount());
 
   notification_list()->RemoveAllNotifications();
   EXPECT_EQ(0u, notification_list()->NotificationCount());
   EXPECT_EQ(0u, notification_list()->unread_count());
 }
@@ skipping 11 matching lines @@
   ASSERT_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);
   EXPECT_EQ(1u, notification_list()->NotificationCount());
-  NotificationList::Notifications notifications;
-  notification_list()->GetNotifications(&notifications);
-  EXPECT_EQ(replaced, notifications.begin()->id);
-  EXPECT_EQ(UTF8ToUTF16("newtitle"), notifications.begin()->title);
-  EXPECT_EQ(UTF8ToUTF16("newbody"), notifications.begin()->message);
+  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, SendRemoveNotifications) {
   notification_list()->AddNotification(
-      ui::notifications::NOTIFICATION_TYPE_SIMPLE, "id0", UTF8ToUTF16("title0"),
+      message_center::NOTIFICATION_TYPE_SIMPLE, "id0", UTF8ToUTF16("title0"),
       UTF8ToUTF16("message0"), UTF8ToUTF16("source0"), "ext0", NULL);
   notification_list()->AddNotification(
-      ui::notifications::NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title1"),
+      message_center::NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title1"),
       UTF8ToUTF16("message1"), UTF8ToUTF16("source0"), "ext0", NULL);
   notification_list()->AddNotification(
-      ui::notifications::NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title1"),
+      message_center::NOTIFICATION_TYPE_SIMPLE, "id2", UTF8ToUTF16("title1"),
       UTF8ToUTF16("message1"), UTF8ToUTF16("source1"), "ext0", NULL);
   notification_list()->AddNotification(
-      ui::notifications::NOTIFICATION_TYPE_SIMPLE, "id3", UTF8ToUTF16("title1"),
+      message_center::NOTIFICATION_TYPE_SIMPLE, "id3", UTF8ToUTF16("title1"),
       UTF8ToUTF16("message1"), UTF8ToUTF16("source2"), "ext1", NULL);
 
   notification_list()->SendRemoveNotificationsBySource("id0");
   EXPECT_EQ(2u, delegate()->GetSendRemoveCountAndReset());
   notification_list()->SendRemoveNotificationsByExtension("id0");
   EXPECT_EQ(3u, delegate()->GetSendRemoveCountAndReset());
 }
 
 TEST_F(NotificationListTest, OldPopupShouldNotBeHidden) {
   std::vector<std::string> ids;
   for (size_t i = 0; i <= NotificationList::kMaxVisiblePopupNotifications;
        i++) {
     ids.push_back(AddNotification(NULL));
   }
 
-  NotificationList::Notifications popups;
-  notification_list()->GetPopupNotifications(&popups);
+  NotificationList::Notifications popups =
+      notification_list()->GetPopupNotifications();
   // The popup should contain the oldest kMaxVisiblePopupNotifications. Newer
   // one should come earlier in the popup list. It means, the last element
   // of |popups| should be the firstly added one, and so on.
   EXPECT_EQ(NotificationList::kMaxVisiblePopupNotifications, popups.size());
   NotificationList::Notifications::const_reverse_iterator iter =
       popups.rbegin();
   for (size_t i = 0; i < NotificationList::kMaxVisiblePopupNotifications;
        ++i, ++iter) {
-    EXPECT_EQ(ids[i], iter->id) << i;
+    EXPECT_EQ(ids[i], (*iter)->id()) << i;
   }
 
-  notification_list()->MarkPopupsAsShown(ui::notifications::DEFAULT_PRIORITY);
+  notification_list()->MarkPopupsAsShown(message_center::DEFAULT_PRIORITY);
   popups.clear();
-  notification_list()->GetPopupNotifications(&popups);
+  popups = notification_list()->GetPopupNotifications();
   EXPECT_EQ(1u, popups.size());
-  EXPECT_EQ(ids[ids.size() - 1], popups.begin()->id);
+  EXPECT_EQ(ids[ids.size() - 1], (*popups.begin())->id());
 }
 
 TEST_F(NotificationListTest, Priority) {
   ASSERT_EQ(0u, notification_list()->NotificationCount());
   ASSERT_EQ(0u, notification_list()->unread_count());
 
   // Default priority has the limit on the number of the popups.
   for (size_t i = 0; i <= NotificationList::kMaxVisiblePopupNotifications;
        ++i) {
     AddNotification(NULL);
@@ skipping 35 matching lines @@
   EXPECT_EQ(NotificationList::kMaxVisiblePopupNotifications * 4,
             GetPopupCounts());
 }
 
 TEST_F(NotificationListTest, PriorityPromotion) {
   std::string id0 = AddPriorityNotification(-1);
   std::string replaced = id0 + "_replaced";
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   EXPECT_EQ(0u, GetPopupCounts());
   base::DictionaryValue optional;
-  optional.SetInteger(ui::notifications::kPriorityKey, 1);
+  optional.SetInteger(message_center::kPriorityKey, 1);
   notification_list()->UpdateNotificationMessage(
       id0, replaced, UTF8ToUTF16("newtitle"), UTF8ToUTF16("newbody"),
       &optional);
   EXPECT_EQ(1u, notification_list()->NotificationCount());
   EXPECT_EQ(1u, GetPopupCounts());
-  NotificationList::Notifications notifications;
-  notification_list()->GetNotifications(&notifications);
-  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);
+  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, NotificationOrderAndPriority) {
   base::Time now = base::Time::Now();
   base::DictionaryValue optional;
   SetupTimestampKey(now, &optional);
-  optional.SetInteger(ui::notifications::kPriorityKey, 2);
+  optional.SetInteger(message_center::kPriorityKey, 2);
   std::string max_id = AddNotification(&optional);
   now += base::TimeDelta::FromSeconds(1);
   SetupTimestampKey(now, &optional);
-  optional.SetInteger(ui::notifications::kPriorityKey, 1);
+  optional.SetInteger(message_center::kPriorityKey, 1);
   std::string high_id = AddNotification(&optional);
   now += base::TimeDelta::FromSeconds(1);
   SetupTimestampKey(now, &optional);
-  optional.SetInteger(ui::notifications::kPriorityKey, 0);
+  optional.SetInteger(message_center::kPriorityKey, 0);
   std::string default_id = AddNotification(&optional);
 
   // Popups: latest comes first.
-  NotificationList::Notifications popups;
-  notification_list()->GetPopupNotifications(&popups);
+  NotificationList::Notifications popups =
+      notification_list()->GetPopupNotifications();
   EXPECT_EQ(3u, popups.size());
   NotificationList::Notifications::const_iterator iter = popups.begin();
-  EXPECT_EQ(default_id, iter->id);
+  EXPECT_EQ(default_id, (*iter)->id());
   iter++;
-  EXPECT_EQ(high_id, iter->id);
+  EXPECT_EQ(high_id, (*iter)->id());
   iter++;
-  EXPECT_EQ(max_id, iter->id);
+  EXPECT_EQ(max_id, (*iter)->id());
 
   // Notifications: high priority comes ealier.
-  NotificationList::Notifications notifications;
-  notification_list()->GetNotifications(&notifications);
+  const NotificationList::Notifications& notifications =
+      notification_list()->GetNotifications();
   EXPECT_EQ(3u, notifications.size());
   iter = notifications.begin();
-  EXPECT_EQ(max_id, iter->id);
+  EXPECT_EQ(max_id, (*iter)->id());
   iter++;
-  EXPECT_EQ(high_id, iter->id);
+  EXPECT_EQ(high_id, (*iter)->id());
   iter++;
-  EXPECT_EQ(default_id, iter->id);
+  EXPECT_EQ(default_id, (*iter)->id());
 }
 
 TEST_F(NotificationListTest, MarkSinglePopupAsShown) {
   std::string id1 = AddNotification(NULL);
   std::string id2 = AddNotification(NULL);
   std::string id3 = AddNotification(NULL);
   ASSERT_EQ(3u, notification_list()->NotificationCount());
   ASSERT_EQ(std::min(static_cast<size_t>(3u),
                      NotificationList::kMaxVisiblePopupNotifications),
             GetPopupCounts());
 
   notification_list()->MarkSinglePopupAsShown(id2, true);
   notification_list()->MarkSinglePopupAsShown(id3, false);
   EXPECT_EQ(3u, notification_list()->NotificationCount());
   EXPECT_EQ(2u, notification_list()->unread_count());
   EXPECT_EQ(1u, GetPopupCounts());
-  NotificationList::Notifications popups;
-  notification_list()->GetPopupNotifications(&popups);
-  EXPECT_EQ(id1, popups.begin()->id);
+  NotificationList::Notifications popups =
+      notification_list()->GetPopupNotifications();
+  EXPECT_EQ(id1, (*popups.begin())->id());
 
   // Reorder happens -- popup-notifications should be at the beginning of the
   // list.
   // TODO(mukai): confirm this behavior is expected.
-  NotificationList::Notifications notifications;
-  notification_list()->GetNotifications(&notifications);
+  NotificationList::Notifications notifications =
+      notification_list()->GetNotifications();
   NotificationList::Notifications::const_iterator iter = notifications.begin();
-  EXPECT_EQ(id1, iter->id);
+  EXPECT_EQ(id1, (*iter)->id());
   iter++;
-  EXPECT_EQ(id3, iter->id);
+  // The shown_as_popup, newest first.
+  EXPECT_EQ(id3, (*iter)->id());
   iter++;
-  EXPECT_EQ(id2, iter->id);
+  EXPECT_EQ(id2, (*iter)->id());
 
   // Trickier scenario.
-  notification_list()->MarkPopupsAsShown(ui::notifications::DEFAULT_PRIORITY);
+  notification_list()->MarkPopupsAsShown(message_center::DEFAULT_PRIORITY);
   std::string id4 = AddNotification(NULL);
   std::string id5 = AddNotification(NULL);
   std::string id6 = AddNotification(NULL);
   notification_list()->MarkSinglePopupAsShown(id5, true);
   popups.clear();
   notifications.clear();
-  notification_list()->GetPopupNotifications(&popups);
-  notification_list()->GetNotifications(&notifications);
+  popups = notification_list()->GetPopupNotifications();
+  notifications = notification_list()->GetNotifications();
   EXPECT_EQ(2u, popups.size());
   iter = popups.begin();
-  EXPECT_EQ(id6, iter->id);
+  EXPECT_EQ(id6, (*iter)->id());
   iter++;
-  EXPECT_EQ(id4, iter->id);
+  EXPECT_EQ(id4, (*iter)->id());
   EXPECT_EQ(6u, notifications.size());
   iter = notifications.begin();
-  EXPECT_EQ(id6, iter->id);
+  // Popups go first.
+  EXPECT_EQ(id6, (*iter)->id());
   iter++;
-  EXPECT_EQ(id4, iter->id);
+  EXPECT_EQ(id4, (*iter)->id());
   iter++;
-  EXPECT_EQ(id5, iter->id);
+  // The shown_as_popup, newest first.
+  EXPECT_EQ(id5, (*iter)->id());
   iter++;
-  EXPECT_EQ(id1, iter->id);
+  EXPECT_EQ(id3, (*iter)->id());
   iter++;
-  EXPECT_EQ(id3, iter->id);
+  EXPECT_EQ(id2, (*iter)->id());
   iter++;
-  EXPECT_EQ(id2, iter->id);
+  EXPECT_EQ(id1, (*iter)->id());
 }
 
 TEST_F(NotificationListTest, QuietMode) {
   notification_list()->SetQuietMode(true);
   AddNotification(NULL);
   AddPriorityNotification(1);
   AddPriorityNotification(2);
   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 message_center